# GitHub Actions on ARM64: ubuntu-24.04-arm, prices, and building arm64 images natively

Source: https://flamewill.com/guides/github-actions-arm64-runners/ · updated 2026-10-24T17:47:14Z · prices and specs read on 24 Oct 2026

**Set runs-on: ubuntu-24.04-arm to run a GitHub Actions job on a GitHub-hosted ARM64 Linux runner: in a public repository it is a standard runner (4 vCPU, 16 GB, free), in a private one it has 2 vCPU and 8 GB and costs $0.005 a minute, a sixth less than the x64 runner of the same size.**

## The switch is one line

```yaml
jobs:
  test:
    runs-on: ubuntu-24.04-arm   # was: ubuntu-latest
    steps:
      - uses: actions/checkout@v5
      - uses: actions/setup-node@v5
        with:
          node-version: 24
      - run: npm ci && npm test
```

To run the same job on both architectures, put the label in a matrix:

```yaml
jobs:
  test:
    strategy:
      matrix:
        runner: [ubuntu-24.04, ubuntu-24.04-arm]
    runs-on: ${{ matrix.runner }}
```

## What GitHub's ARM64 runners hold and cost

| Label | Repository | vCPU | Memory | Disk | Price per minute |
|---|---|---|---|---|---|
| `ubuntu-24.04-arm` (also `-22.04-arm`, `-26.04-arm`) | public | 4 | 16 GB | 14 GB | free (standard runner) |
| same | private | 2 | 8 GB | 14 GB | $0.005, from your included minutes first |
| arm64 larger runner, 4 cores | any | 4 | 16 GB | 150 GB | $0.008, always charged |
| arm64 larger runner, 8 cores | any | 8 | 32 GB | 300 GB | $0.014, always charged |

## What can break

- **Docker container actions and images without an arm64 build.** A `uses:` that points at an x64-only image fails to start. Most official images (node, python, postgres, redis) publish arm64.
- **Downloaded binaries.** A step that fetches `…-linux-amd64.tar.gz` by name needs the arm64 file instead; `uname -m` prints `aarch64` on ARM.
- **Snapshot tests that depend on the CPU.** Floating-point output, image rendering or font hinting can differ by a pixel or a digit between architectures. Compare a run on each before you switch the gate.
- **Caches.** Keys that do not include the architecture restore x64 `node_modules` native modules on ARM. Put `runner.arch` in the key.

## Building arm64 Docker images without emulation

QEMU lets an x64 runner build arm64 images, but Docker notes that building several platforms on one runner can significantly extend build times. Docker's own reusable workflow builds one platform per runner, arm64 on `ubuntu-24.04-arm`, and assembles the multi-platform image for you:

```yaml
jobs:
  build:
    permissions:
      contents: read
      id-token: write
    uses: docker/github-builder/.github/workflows/build.yml@v1
    with:
      output: image
      push: true
      platforms: linux/amd64,linux/arm64
      meta-images: ghcr.io/${{ github.repository }}
    secrets:
      registry-auths: |
        - registry: ghcr.io
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}
```

## Other ARM64 runners

- **Blacksmith** offers ARM runners at $0.0025 a minute for 2 vCPU, with 3 GB per vCPU.
- **FlameWill** is ARM64 only (current Arm Neoverse cores, in the EU) and sizes memory separately from cores, up to 8 GB per vCPU:

| Label | vCPU | Memory | Price per minute |
|---|---|---|---|
| `flamewill-2vcpu-8gb-ubuntu-2404` | 2 | 8 GB | $0.0012 |
| `flamewill-2vcpu-16gb-ubuntu-2404` | 2 | 16 GB | $0.0015 |
| `flamewill-4vcpu-32gb-ubuntu-2404` | 4 | 32 GB | $0.0030 |

Docker, Node.js, Bun and Playwright's browsers are already installed on FlameWill's machines, so a job's setup steps download less.

## Questions

### Which ARM64 runner labels does GitHub offer?

ubuntu-24.04-arm, ubuntu-22.04-arm and ubuntu-26.04-arm for standard Linux runners, plus arm64 larger runners from 2 to 64 cores that an organization creates with its own labels.

### Are ARM64 runners cheaper than x64 on GitHub?

Yes, at every size GitHub lists. 2 cores cost $0.005 a minute against $0.006 on x64; 64 cores cost $0.098 against $0.162.

### Do JavaScript and composite actions work on ARM64?

Yes, they run on the runner's own Node.js. Actions that ship a Docker image or a prebuilt binary work only if they publish an arm64 build; check before switching a workflow that uses one.

### Should I use QEMU to build arm64 Docker images?

QEMU emulation lets an x64 runner build for arm64, but Docker notes that building several platforms on one runner can significantly extend build times. Building each platform on a runner of that architecture avoids emulation.

## Sources

- [GitHub, GitHub-hosted runners (labels and specifications)](https://docs.github.com/en/actions/reference/runners/github-hosted-runners)
- [GitHub, Actions runner pricing](https://docs.github.com/en/billing/reference/actions-runner-pricing)
- [GitHub, GitHub Actions billing (free use in public repositories)](https://docs.github.com/en/billing/concepts/product-billing/github-actions)
- [Docker, multi-platform images with GitHub Actions](https://docs.docker.com/build/ci/github-actions/multi-platform/)
- [Blacksmith, runner instance types](https://docs.blacksmith.sh/blacksmith-runners/overview)
- [FlameWill, docs](https://flamewill.com/docs/)