# macOS Runner Sizes and Configurations for GitHub Actions | WarpBuild
URL: https://www.warpbuild.com/runners/macos/sizes
Description: WarpBuild macOS runners for GitHub Actions come in 6 vCPU and 12 vCPU sizes at $0.08 and $0.16 a minute. Specs, list prices, and which size fits a job.

# macOS Runner Sizes and Configurations for GitHub Actions

WarpBuild macOS runners for GitHub Actions come in 6 vCPU and 12 vCPU sizes at $0.08 and $0.16 a minute. Specs, list prices, and which size fits a job.

Last verified: 2026-08-13

WarpBuild macOS runners for GitHub Actions come in two sizes: 6 vCPU with 14GB of memory and a 120GB SSD at $0.08 per minute, and 12 vCPU with 28GB 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](/docs/ci/cloud-runners) and were re-checked on 2026-08-13.

## [Catalog](#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.

| Label                   | macOS image | Size | vCPU | Memory | Storage   | Rate         |
| ----------------------- | ----------- | ---- | ---- | ------ | --------- | ------------ |
| warp-macos-26-arm64-6x  | macOS 26    | 6x   | 6    | 14GB   | 120GB SSD | $0.08/minute |
| warp-macos-26-arm64-12x | macOS 26    | 12x  | 12   | 28GB   | 270GB SSD | $0.16/minute |
| warp-macos-15-arm64-6x  | macOS 15    | 6x   | 6    | 14GB   | 120GB SSD | $0.08/minute |
| warp-macos-15-arm64-12x | macOS 15    | 12x  | 12   | 28GB   | 270GB SSD | $0.16/minute |
| warp-macos-14-arm64-6x  | macOS 14    | 6x   | 6    | 14GB   | 120GB SSD | $0.08/minute |

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](#what-changes-between-the-two-sizes)

| Specification        | 6x           | 12x          | Change                |
| -------------------- | ------------ | ------------ | --------------------- |
| vCPU                 | 6            | 12           | 6 more cores          |
| Memory               | 14GB         | 28GB         | 14GB more             |
| Storage              | 120GB SSD    | 270GB SSD    | 150GB more            |
| Rate                 | $0.08/minute | $0.16/minute | $0.08 more per minute |
| Rate per vCPU-minute | $0.0133      | $0.0133      | unchanged             |
| Memory per vCPU      | 3.67GB       | 3.67GB       | unchanged             |

Cores and memory scale together, so a job that fits comfortably in 14GB 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](/docs/ci/preinstalled-software) lists what each macOS image carries. Per-image Xcode detail lives on [Xcode versions and simulator runtimes on each macOS image](/runners/macos/xcode-images).

## [Pricing](#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.

| Size | Rate         | Rate per vCPU-minute | 10-minute job | 1,000 minutes |
| ---- | ------------ | -------------------- | ------------- | ------------- |
| 6x   | $0.08/minute | $0.0133              | $0.80         | $80.00        |
| 12x  | $0.16/minute | $0.0133              | $1.60         | $160.00       |

### [Against the nearest GitHub-hosted macOS ARM64 shape](#against-the-nearest-github-hosted-macos-arm64-shape)

`warp-macos-latest-arm64-6x` (6 vCPU, 14GB) 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](https://docs.github.com/en/billing/reference/actions-runner-pricing).

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 carries the same 14GB of memory, plus 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](/guides/github-actions-macos-runner-cost).

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](/pricing).

## [Configuration](#configuration)

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

| Workload                                                                             | Start on                                 | Reasoning                                                                                                                                                                                                      |
| ------------------------------------------------------------------------------------ | ---------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Unit tests (swift test, XCTest without a simulator)                                  | 6x                                       | Compile and test of a package tree stays inside 14GB of memory and 120GB of disk, and the job bills $0.08 a minute while it runs.                                                                              |
| Simulator tests (xcodebuild test against iOS, tvOS, watchOS, or visionOS simulators) | 6x, then 12x when the test plan fans out | Each booted simulator holds memory and disk on top of derived data and the downloaded runtimes, and a plan running several destinations at once is where 28GB and 270GB earn the extra $0.08 a minute.         |
| Archive and distribution builds (xcodebuild archive, \-exportArchive, notarization)  | 12x                                      | A release build writes derived data, an .xcarchive, and an exported artifact onto the same disk in one job, and whole-module optimization across many targets is the phase that occupies every available core. |

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](/runners/macos). For disk ceilings measured against a real Xcode job, see [how much disk macOS GitHub Actions runners have](/answers/how-much-disk-do-macos-github-actions-runners-have).

## [FAQ](#faq)

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

Two. The 6x size is 6 vCPU, 14GB of memory, and a 120GB SSD at $0.08 per minute. The 12x size is 12 vCPU, 28GB 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 14GB and 28GB, 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, 14GB) 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](https://docs.github.com/en/billing/reference/actions-runner-pricing)).