ARM runners for GitHub Actions

GitHub ARM runners build and test arm64 code on real arm64 chips, with no emulation. You can use GitHub's hosted arm64 runners for Linux and macOS, or run arm64 jobs on your own Apple silicon Macs and arm64 Linux machines.

Why arm64 CI matters now

A lot of code now ships to arm64. Every new Mac uses Apple silicon. Phones use ARM chips. Many cloud servers do too.

If you ship arm64 code, you should test it on arm64. A bug can hide on x86 and show up only on ARM. Native builds are also much faster than emulated ones.

There is a cost side too. Emulated builds run longer, and on hosted runners you pay for each minute. A native arm64 build often finishes sooner and costs less.

Some tools only matter on one chip. Xcode builds need a Mac. Native add-ons in Node, Python wheels with C code and Go binaries with cgo all compile per CPU. Each needs a test on the CPU it ships to.

GitHub's hosted arm64 runners

GitHub has hosted arm64 runners for both Linux and macOS. As of November 2026, its docs list these labels:

• Linux arm64: ubuntu-24.04-arm and ubuntu-22.04-arm. They are free on public repos. On private repos they use your included minutes, then cost per minute.
• macOS arm64: macos-latest, macos-15 and macos-26 run on Apple silicon (M1).
• macOS Intel: labels that end in -intel, like macos-15-intel.

So "macOS x64 or arm64?" comes down to the label. macos-latest is arm64 today. Pick an -intel label only if you still need x64. Labels and plans change, so check GitHub's runner docs.

A GitHub Actions arm64 job on Linux looks like this:

jobs:
  test-arm:
    runs-on: ubuntu-24.04-arm
    steps:
      - uses: actions/checkout@v4
      - run: uname -m   # prints aarch64

Emulation with QEMU is slow

Before hosted ARM runners, teams used QEMU. It lets an x86 machine pretend to be ARM. Docker's multi-platform builds use it:

- uses: docker/setup-qemu-action@v3
- uses: docker/setup-buildx-action@v3
- uses: docker/build-push-action@v6
  with:
    platforms: linux/amd64,linux/arm64

It works, but it is slow. QEMU turns each ARM instruction into x86 ones as it runs. Compile steps can take many times longer than on a real ARM chip.

A better way: build each platform on its own native runner, in parallel. Then merge the images into one tag.

With native runners, the work splits like this. One job builds the amd64 image on an x86 runner. Another builds the arm64 image on an ARM runner. A last job joins them into one multi-platform tag with docker buildx imagetools create. Each build runs at full speed on its own chip.

Apple silicon Macs as arm64 runners

Your own Mac can be a GitHub Actions ARM runner. Every Apple silicon Mac is arm64.

Codemany runs jobs on Macs with Apple silicon and macOS 14 or later. Intel Macs are not supported, and neither is Windows. Each job gets a fresh, single-use runner. The runner always carries the ARM64 label.

A Mac runs macOS jobs: Xcode builds, iOS tests, Swift packages and arm64 macOS binaries. Jobs run as your user, with the tools you have installed. Read the Mac runner guide or see Mac runners.

Your Mac keeps the tools you install. Xcode, Homebrew packages and simulators are there for every job, so jobs don't spend time setting them up. Downloads from actions/setup-* steps stay in a shared tool cache too.

arm64 Linux machines

For arm64 Linux jobs, use an arm64 Linux machine. That could be an ARM server, a cloud VM or a small board at home.

Codemany runs on any 64-bit Linux with systemd, on x86-64 and arm64. Install it with one command:

curl --proto '=https' --tlsv1.2 -fsSL https://codemany.com/install.sh | sh
codemany setup-link

Linux runners carry Linux and either X64 or ARM64. Read the Linux runner guide or see Linux runners.

Already have an ARM server in the cloud? It works as long as it runs 64-bit Linux with systemd. Codemany can also create a machine for you in your own Google Cloud, Hetzner or DigitalOcean account. Your cloud bills you for it.

Pick the right runs-on labels

A job goes to a runner that has every label in its runs-on. Add the OS and the CPU to pick the right machine:

To test on both CPUs at once, use a matrix:

jobs:
  test:
    strategy:
      matrix:
        arch: [X64, ARM64]
    runs-on: [self-hosted, Linux, "${{ matrix.arch }}", codemany]
    steps:
      - uses: actions/checkout@v4
      - run: make test

Machine requirements are in the FAQ.

Put self-hosted first so a job never lands on a GitHub-hosted machine by mistake. Each label you add narrows which runners can take the job, so add only what you need.

Questions

Does GitHub have arm64 runners?

Yes, for Linux and for macOS on Apple silicon. Check GitHub's docs for which plans get them.

Can an Apple silicon Mac run arm64 Linux jobs?

Codemany runs Linux jobs on Linux machines. A Mac runs macOS jobs.

Does Codemany support Intel Macs?

No. Macs need Apple silicon and macOS 14 or later.

Related

Read next: Mac runners, Linux runners, the Mac runner guide, the Linux runner guide and requirements.

Start a 14-day trial No card needed. $20 a month for 2 machines after that.