Which ARM64 Runner Sizes Are Available?

Linux ARM64 runners come in the same five sizes as Linux x64, 2x through 32x, running from 2 vCPU and 8GB of memory up to 32 vCPU and 128GB, with 150GB of SSD storage at every size (cloud runners documentation, checked on 2026-08-13). Each ARM64 size costs less per minute than the x64 size with the same vCPU and memory: $0.003 against $0.004 at 2x, and $0.048 against $0.064 at 32x.

Answer

WarpBuild provides Linux x64, Linux ARM64, macOS, and Windows runners. The Linux ARM64 line is a five-rung ladder where the number in the label is the vCPU count, memory is 4GB per vCPU, and storage is flat.

Every row comes from the cloud runners documentation, checked on 2026-08-13, and the Linux ARM64 runner catalog carries the same rows with the alias column.

Each size exists on two Ubuntu releases. The warp-ubuntu-latest-arm64-* labels run Ubuntu 24.04 and each carries a pinned alias, warp-ubuntu-2404-arm64-2x through warp-ubuntu-2404-arm64-32x. The warp-ubuntu-2604-arm64-* labels run Ubuntu 26.04 at the same five sizes and the same five rates. That makes ten Linux ARM64 labels, five shapes across two releases.

ARM64 coverage outside Linux is macOS, where the runners are ARM64 already and the catalog is two sizes, 6 vCPU with 22GB at $0.08 per minute and 12 vCPU with 44GB at $0.16 per minute. The Windows catalog is x86-64 only, so a Windows job stays on a warp-windows label.

Detail

What the ARM64 sizes cost against GitHub-hosted ARM64 runners

Both tables below quote GitHub list prices from the GitHub pricing page and the GitHub Actions billing reference, checked on 2026-08-13. WarpBuild rates come from the cloud runners documentation.

The arithmetic behind each row is plain division. At 4x, ($0.008 - $0.006) / $0.008 = 25 percent lower list price. At 16x, ($0.026 - $0.024) / $0.026 = 8 percent lower list price. GitHub list prices checked on 2026-08-13.

Put that against real volume. A repository that queues 10,000 minutes a month on the 16x size pays 10,000 x $0.024 = $240 on warp-ubuntu-latest-arm64-16x, against 10,000 x $0.026 = $260 on the 16-core Linux ARM64 larger runner. Whether ARM64 or x64 is the cheaper choice for a given job is covered in is ARM64 cheaper than x64.

Picking a size

The size in the label is the only thing that changes between rungs, so sizing is one line of YAML:

name: build

on:
  pull_request:

jobs:
  build:
    runs-on: warp-ubuntu-latest-arm64-8x
    steps:
      - uses: actions/checkout@v4

      - name: Show the shape
        run: |
          uname -m
          nproc
          free -g

      - name: Build
        run: cargo build --release --jobs "$(nproc)"

uname -m prints aarch64, nproc prints 8, and the build parallelism follows the size rather than a hardcoded number. Move the job up a rung and the same file uses the extra cores.

Two rules of thumb keep the choice honest. A step that runs one process at a time, such as a single-threaded linter or a deploy step, gains nothing above 4x. A step that saturates cores, such as a Rust or C++ compile or a sharded test suite, keeps scaling until the job becomes disk or network bound, and 150GB of SSD is the same at every size. 32x is the top rung, so work that needs more parallelism than 32 vCPU splits across a matrix of ARM64 runners, or sends its container image build to a remote Docker builder.

Ubuntu releases and the sizes they cover

The five sizes are identical across Ubuntu 24.04 and Ubuntu 26.04. The Ubuntu 24.04 ARM64 runners are compatible with GitHub's Ubuntu 24.04 ARM64 runners, and the package list lives at actions/partner-runner-images. Ubuntu 26.04 ARM64 tracks actions/runner-images. The preinstalled software documentation links both lists, which is worth checking before you pin a language version, since ARM64 and x86-64 images do not always ship the same set.

The arm64 images for ubuntu-22.04 were deprecated on March 31, 2025 (preinstalled software documentation), so there is no 22.04 ARM64 rung at any size. Ubuntu 22.04 remains available on x64 at all five sizes.

One image difference to plan for

The arm64 images for Ubuntu 24.04 set the work directory to /runner/_work, which differs from GitHub's /home/runner/work/ for the same instance (cloud runners documentation). The path is the same at every ARM64 size, so this is a per-image detail rather than a per-size one. Any step holding a literal /home/runner/work/... path needs ${{ github.workspace }} in YAML or $GITHUB_WORKSPACE in a shell step. Docker -v mounts, coverage upload paths, and cache path globs are the usual places a literal hides. The ARM64 migration checklist walks the rest of the switch.

One hard limit applies across the whole ARM64 ladder rather than to any single size: nested virtualization and /dev/kvm access are not available on ARM64 runners (cloud runners documentation), so Android emulator jobs and similar workloads run on an x86-64 size with the nested-virtualization.enabled=true label.

Related Questions

What ARM64 runner sizes are available on GitHub Actions?

Five Linux ARM64 sizes, 2x, 4x, 8x, 16x, and 32x, running from 2 vCPU and 8GB of memory to 32 vCPU and 128GB. Every size carries 150GB of SSD storage and every size exists on both Ubuntu 24.04 and Ubuntu 26.04, which makes ten Linux ARM64 labels in total. The Linux ARM64 runner catalog lists all ten with aliases.

Do ARM64 runners come in the same sizes as x64 runners?

Yes. The Linux ARM64 ladder matches the Linux x64 ladder vCPU for vCPU and GB for GB, from 2x to 32x. The rate differs. ARM64 runs $0.003 per minute at 2x against $0.004 for x64, and $0.048 at 32x against $0.064 for x64 (cloud runners documentation). The cost side of that choice is in is ARM64 cheaper than x64.

How much memory does each ARM64 runner size have?

4GB per vCPU at every size: 8GB at 2x, 16GB at 4x, 32GB at 8x, 64GB at 16x, and 128GB at 32x. Storage stays at 150GB of SSD across the ladder, so only vCPU and memory change with the size.

Pick a size from the Linux ARM64 runner catalog, check the per-minute rate for it on the pricing page, and confirm the image tooling in the preinstalled software documentation.