macOS Runner Sizes and Configurations for GitHub Actions

WarpBuild macOS runners for GitHub Actions come in two sizes: 6 vCPU with 22GB of memory and a 120GB SSD at $0.08 per minute, and 12 vCPU with 44GB of memory and a 270GB SSD at $0.16 per minute. Five warp- labels carry those two sizes across macOS 26, macOS 15, and macOS 14, so changing the size of a job is a one line runs-on edit.

This page is the size reference. It lists what each size gives a job, prices both sizes against GitHub's published macOS list prices, and maps sizes onto three common Xcode workloads: unit tests, simulator tests, and archive builds. Specifications and rates come from the WarpBuild cloud runners documentation and were re-checked on 2026-08-13.

Catalog

WarpBuild provides Linux x64, Linux ARM64, macOS, and Windows runners. The macOS fleet runs on Apple Silicon with ARM64 architecture, and every macOS label resolves to one of two sizes.

macOS 14 carries the 6x size only. macOS 26 and macOS 15 carry both. The aliases warp-macos-latest-arm64-6x and warp-macos-latest-arm64-12x resolve to the two macOS 15 labels.

What changes between the two sizes

Cores and memory scale together, so a job that fits comfortably in 22GB on 6x has the same headroom per core on 12x. Storage moves further than either. The rate goes from $0.08 to $0.16 a minute while the disk goes from 120GB to 270GB, an increase of 150GB, so storage is the one specification on this list that outgrows the rate rise. Storage is ephemeral on both sizes and is destroyed with the runner at the end of the job.

The image and the size are separate choices. Which Xcode versions and simulator runtimes a job gets is decided by the macOS image in the label, and the preinstalled software reference lists what each macOS image carries. Per-image Xcode detail lives on Xcode versions and simulator runtimes on each macOS image.

Pricing

Pricing is purely usage based. There is no base subscription fee, no platform fee, and no seat fee. A macOS job bills runner minutes at the rate of the size it ran on.

Against the nearest GitHub-hosted macOS ARM64 shape

warp-macos-latest-arm64-6x (6 vCPU, 22GB) costs $0.08 per minute against $0.102 per minute for the largest GitHub-hosted macOS ARM64 runner (5 vCPU, 14GB): 22 percent lower list price. GitHub list price checked on 2026-08-13 against the GitHub Actions runner pricing reference.

The arithmetic, written out: ($0.102 - $0.08) / $0.102 = 0.2157, which rounds to 22 percent. Per core the gap is wider, because the WarpBuild size carries one more vCPU. $0.08 divided by 6 vCPU is $0.0133 per vCPU-minute; $0.102 divided by 5 vCPU is $0.0204 per vCPU-minute; ($0.0204 - $0.0133) / $0.0204 = 0.35, or 35 percent lower per core. The same 6 vCPU size also carries 22GB of memory against 14GB and a 120GB SSD.

Applied to a month of builds at the same wall-clock minutes, 1,000 macOS minutes costs $80.00 on the 6x size against $102.00 at GitHub's list rate for that shape, a difference of $22.00. To run the same arithmetic against a real repository and its own job durations, work through modeling the monthly cost of macOS runners for GitHub Actions.

Signup includes $10 free credits, which covers 125 minutes on a 6x macOS runner or 62 minutes on a 12x macOS runner. Every rate quoted here also appears on the pricing page.

Configuration

Pick the size per job rather than per repository. Three Xcode workloads sort cleanly.

Because both sizes bill $0.0133 per vCPU-minute, moving a job to 12x changes the total bill only through wall-clock time. A job that keeps 12 cores busy and finishes proportionally sooner lands near the same total. A job that keeps 4 cores busy still bills $0.16 a minute instead of $0.08 and finishes at the same time, so a 20-minute job goes from $1.60 to $3.20 for the same result. Measure before upgrading: print df -h / at the end of a job to see how close the disk came to its ceiling, and sysctl -n hw.ncpu plus a build log timestamp to see whether the extra cores were used at all.

A workflow that splits the three workloads across sizes:

name: ios
on:
  pull_request:
    branches: [main]
  push:
    branches: [main]

jobs:
  unit-tests:
    runs-on: warp-macos-15-arm64-6x
    steps:
      - uses: actions/checkout@v4
      - run: swift test --parallel

  simulator-tests:
    runs-on: warp-macos-15-arm64-6x
    steps:
      - uses: actions/checkout@v4
      - name: Run the test plan
        run: |
          xcodebuild test \
            -scheme App \
            -destination 'platform=iOS Simulator,name=iPhone 17,OS=latest' \
            -resultBundlePath TestResults.xcresult
      - run: df -h /
        if: always()

  archive:
    if: github.event_name == 'push'
    runs-on: warp-macos-26-arm64-12x
    steps:
      - uses: actions/checkout@v4
      - name: Archive for distribution
        run: |
          xcodebuild archive \
            -scheme App \
            -archivePath build/App.xcarchive \
            -destination 'generic/platform=iOS'
      - run: df -h /
        if: always()

Changing the size of a job later is a single line:

   archive:
-    runs-on: warp-macos-26-arm64-6x
+    runs-on: warp-macos-26-arm64-12x

Nothing else in the job needs editing, because both sizes boot the same macOS image and differ only in the machine underneath it. For the full label list, the alias behaviour of the latest tags, and the constraints that apply to every macOS size, see WarpBuild macOS runners for GitHub Actions. For disk ceilings measured against a real Xcode job, see how much disk macOS GitHub Actions runners have.

FAQ

What sizes do WarpBuild macOS runners for GitHub Actions come in?

Two. The 6x size is 6 vCPU, 22GB of memory, and a 120GB SSD at $0.08 per minute. The 12x size is 12 vCPU, 44GB of memory, and a 270GB SSD at $0.16 per minute. Five labels carry those sizes across macOS 26, macOS 15, and macOS 14, and macOS 14 carries the 6x size only.

Does the 12 vCPU macOS runner cost more per core than the 6 vCPU one?

No. $0.08 divided by 6 vCPU is $0.0133 per vCPU-minute, and $0.16 divided by 12 vCPU is the same $0.0133 per vCPU-minute. Memory scales with the same ratio at 22GB and 44GB, so the size choice is about wall-clock time and headroom rather than a per-core discount.

How does the 6 vCPU macOS size compare with GitHub-hosted macOS ARM64 list prices?

warp-macos-latest-arm64-6x (6 vCPU, 22GB) costs $0.08 per minute against $0.102 per minute for the largest GitHub-hosted macOS ARM64 runner (5 vCPU, 14GB), which is 22 percent lower list price. GitHub list price checked on 2026-08-13 (GitHub Actions runner pricing).