ARM Runners

Native ARM64 GitHub Actions runners.

aarch64 jobs on real Ampere metal, no QEMU emulation. Build multi-arch images and ARM binaries at native speed, change one runs-on label, and pay the same per-vCPU rate as x86. Billed by the second.

npx sandal migrate --repo your-org/your-repo
.github/workflows/ci.yml−1 +1
build:
- runs-on: ubuntu-latest
+ runs-on: sandal-ubuntu-24.04-arm
steps:
- uses: actions/checkout@v4
- run: cargo build --release

Real ARM cores. No emulation layer, no cross-compile toolchain to babysit.

nativeaarch64, no QEMU
$0.0003per minute, from
64 vCPUmax shape
<1smicroVM boot
per secondmetering
Speed

Faster because
the hardware is faster.

One vCPU is one physical Ampere core. The big wins are the workloads teams emulate on x86 today, building them natively removes the QEMU tax entirely.

Workload Test Comparison

4.8xFaster
Docker multi-arch build
3m 52s
18m 40s
3xFaster
Rust release build (aarch64)
6m 20s
19m 10s
2.6xFaster
Node install + test
3m 01s
7m 48s
Sandal GitHub arm64
Labels

Pick it in the workflow file.

Label
Spec
Arch
sandal-ubuntu-24.04-arm
2 / 4 GB
aarch64
sandal-ubuntu-24.04-arm-8
8 / 16 GB
aarch64
sandal-ubuntu-24.04-arm-32
32 / 64 GB
aarch64

Add -arm to any Ubuntu label to move it to aarch64. RAM scales at 2 GB per core; disk is 150 GB on every shape.

Native silicon

No emulation tax.

Jobs run on physical Ampere cores over KVM, not QEMU on an x86 host. A multi-arch Docker build stops paying the 5–10× emulation penalty most pipelines eat today.

Same price

ARM costs the same as x86.

An aarch64 shape is billed at the same per-vCPU rate as its x86 twin, no arm surcharge, no partner tier. Often it is the cheaper way to run the same build.

Multi-arch

Both arches, one workflow.

Matrix x86 and arm legs in the same file and account. The arm leg runs on Ampere metal; the x86 leg on EPYC. One bill, one label grammar.

Cost

Native ARM, at the x86 price.

No arm surcharge and no emulation. The same per-vCPU rate as Linux x86, billed by the second on Ampere metal.

Runner
GitHub arm64 / min
Sandal / min
2 vCPU / 4 GB
$0.005
$0.0003
8 vCPU / 16 GB
$0.020
$0.0012
32 vCPU / 64 GB
$0.080
$0.0048

GitHub’s arm64 hosted runners start at $0.005/min for 2 cores. Sandal bills the same wall-clock second as its x86 shapes. All runners, every OS →

Plans

One balance. Every machine you run.

Runners draw from the same credit pool as your sandboxes, simulators and Xcode builds, billed by the second at one published rate card.

Starter

For a solo build or a first agent in production.

$20/ month

$20 of usage credits

≈ 550 VM-hours or 33,000 CI minutes

Get started
  • 20 concurrent machines
  • Committed in-plan rates on every product
  • Linux & Windows, sandboxes, VMs, runners
  • Per-second billing, paused is free
  • Full API, SDKs, CLI & MCP server
  • Unlimited seats
  • Community support
Most popular

Team

Apple silicon unlocked, and a balance that rolls over.

$100/ month

$100 of usage credits

≈ 2,700 VM-hours or 10,000 Mac build minutes

Get started
  • 100 concurrent machines
  • Everything in Starter, plus:
  • macOS, iOS/Android simulators & Xcode builds
  • Unused credits roll over one month
  • Usage exports & per-second line items
  • Email support

Business

Higher ceilings for a team leaning on the fleet daily.

$250/ month

$250 of usage credits

≈ 6,900 VM-hours or 25,000 Mac build minutes

Get started
  • 300 concurrent machines
  • Everything in Team, plus:
  • Raised concurrency & start rate
  • Priority support & shared Slack channel
  • Single sign-on (SAML / OIDC)
  • Volume credit rate

Enterprise

Dedicated capacity, your compliance surface, one invoice.

Custom

Committed volume rate

Committed volume rate, negotiated per account

Talk to sales
  • Reserved bare-metal capacity
  • BYOC or self-host the control plane
  • SSO & SCIM, audit logs, data residency
  • Annual invoicing, MSA, DPA
  • Support SLA & solutions engineering
  • Custom regions on request

Every plan spends its credit pool first, then usage keeps flowing and bills per second at your committed in-plan rate, no hard stop mid-run, no forced upgrade. Without a plan you pay the on-demand rate instead. Prices are illustrative pending final list pricing; the per-second billing model is final.

Rate card

The runner rate card.

Linux

MachineIn-plan / minuteOn-demand / minute
2 vCPU / 4 GB$0.0003$0.0004
4 vCPU / 8 GB$0.0006$0.0009
8 vCPU / 16 GB$0.0012$0.0018
16 vCPU / 32 GB$0.0024$0.0036
32 vCPU / 64 GB$0.0048$0.0072
64 vCPU / 128 GB$0.0096$0.014

Windows

MachineIn-plan / minuteOn-demand / minute
2 vCPU / 4 GB$0.0006$0.0009
4 vCPU / 8 GB$0.0012$0.0018
8 vCPU / 16 GB$0.0024$0.0036
16 vCPU / 32 GB$0.0048$0.0072
32 vCPU / 64 GB$0.0096$0.014
64 vCPU / 128 GB$0.019$0.029

macOS · Apple silicon

MachineIn-plan / minuteOn-demand / minute
M-series · 4 cores / 8 GB$0.01$0.015
M-series Pro · 8 cores / 16 GB$0.02$0.03

Linux runners are the VM ladder priced per minute; Windows is 2x. macOS runners are dedicated Apple-silicon Mac minis. On-demand is 1.5× the in-plan rate. All usage bills by the second; paused machines are not billed.

Get started

Give your AI agents somewhere to run today.

Your agents get their own machines across Linux, macOS, Windows, iOS and Xcode in milliseconds, and you stop paying for idle.

npx sandal init