# GitHub Actions runner alternatives, ranked by published rate

> GitHub Actions runner alternatives ranked by the rate each vendor published on 2026-09-20, with the memory it buys and what each one does not do.

Source: https://latchkey.dev/learn/runners/github-actions-runner-alternatives  
Updated: 2026-09-20

The GitHub Actions runner alternatives below are ranked by the Linux rate each vendor published on 2026-09-20 at 2 vCPU, because the rate is the only number all of them state in public. Rate alone picks the wrong runner more often than it picks the right one, so every row also carries the memory that rate buys, the free tier, and the thing that vendor does not do.

Two preconditions decide whether any of this applies. GitHub documents that "the use of standard GitHub-hosted runners is free" in public repositories, and nothing metered beats free. If the repository is private and still inside its included minutes, 2,000 a month on Free, 3,000 on Team and 50,000 on Enterprise Cloud, moving to a metered vendor turns a zero bill into a real one.

Past both of those, the criterion here is the published per-minute rate for a Linux x64 runner at 2 vCPU, private repository, read on 2026-09-20. It has one trap in it, and it is why most roundups mislead: vendors do not sell the same machine at 2 vCPU. Namespace prices a 4 GB shape and an 8 GB shape separately, and the cheap number quoted everywhere is the 4 GB one. Every table below carries the memory next to the rate.

One cost appears in none of these rate cards: the job that fails for a reason unrelated to your code, such as [an out-of-memory kill](/learn/failures/exit-code-137-in-github-actions) or [a registry rate limit](/learn/failures/docker-hub-pull-rate-limit-in-ci). Those minutes bill, the re-run bills, and the merge waits. Work out what share of your runs are retries first.

## Rates, free minutes and billing, ranked cheapest first

Ranks here are against the cheapest card each vendor publishes in this table. Latchkey is joint fourth of the eight. Hold the memory at 8 GB, what GitHub-hosted gives you at 2 vCPU, and it moves to joint third while Namespace drops from joint second to fifth, because its cheap card carries 4 GB.

| Vendor | Linux, 2 vCPU | Linux, 4 vCPU | Free tier | Billing granularity | Best for |
| --- | --- | --- | --- | --- | --- |
| Ubicloud | $0.0012 standard, $0.0020 premium (8 GB) | $0.0025 standard, $0.0040 premium | 1,250 min/month | Not published | The lowest published Linux rate |
| Namespace | $0.002 prepaid at 4 GB, $0.004 at 8 GB | $0.004 prepaid at 8 GB, $0.008 at 16 GB | 30-day trial, no standing allowance | Unit minutes, prepaid or overage | Cheapest per vCPU if 2 GB per vCPU fits |
| WarpBuild | $0.002 BYOC flat, $0.004 managed (8 GB) | $0.002 BYOC flat, $0.008 managed | Not published as a minute allowance | Per minute | Running runners inside your own cloud account |
| Latchkey | $0.0025 (8 GB) | $0.005 (16 GB) | 2,000 to 6,000 min/month by plan | Per minute | Pipelines where re-runs are a real share of the bill |
| Blacksmith | $0.0025 ARM, $0.004 Ubuntu x64 | $0.005 ARM, $0.008 Ubuntu x64 | 3,000 min/month | Not published | A compile-bound critical path |
| Depot | $0.006 (8 GB) | $0.012 (16 GB) | None standalone; 2,000 min on the $20/mo plan | Tracked per second, billed monthly in whole minutes | Docker builds and large caches |
| GitHub-hosted | $0.006 (8 GB) | $0.012 (16 GB) | Free on public repos; 2,000 to 50,000 min by plan | Each job rounded up to the whole minute | Public repos and anyone inside their included minutes |
| RunsOn | No per-minute fee | No per-minute fee | Free for OSS, nonprofit, education | Your AWS bill, per second | Very high volume with AWS already in-house |

> Ubicloud shows two numbers for the same runner and the lower pair is stale, not wrong. Its headline cards still read $0.0010 and $0.0016 a minute; its own size table prices the 2 vCPU 8 GB shape at $0.0012 standard and $0.0020 premium. [RunsOn's benchmark changelog](https://runs-on.com/benchmarks/github-actions-runners/), read 2026-09-20, records the reason: Ubicloud raised both tiers by 25% effective 1 September 2026, taking the 2 vCPU standard rate from $0.0010 to $0.00125, which its table rounds to $0.0012, and premium from $0.0016 to $0.0020. The table above uses the size table, because that is the current rate and the one with a shape attached to it.

## What each rate actually gets you

These rows decide whether a cheap minute is a cheap job. A 10 GB cache is a different product from 250 GB, at any rate.

| Vendor | Sizes and OS | Cache | Docker build acceleration |
| --- | --- | --- | --- |
| Ubicloud | Linux x64, 2 to 16 vCPU | 30 GB standard, 100 GB premium | Not published |
| Namespace | Linux x64 and arm64, Windows, macOS | Cache volumes, $0.0048/GB-day | Remote Docker builders, per build |
| WarpBuild | Linux x64 and arm64, Windows, macOS M4 Pro | Not priced separately on the page read | Add-ons, free on BYOC |
| Latchkey | Linux x86_64 only, 2 to 16 vCPU | No size published; entries kept 14 days, per organization | Docker layer cache on the runner |
| Blacksmith | Ubuntu x64 and ARM, Windows x64, macOS M4 | 25 GB per repo per week free; sticky disks +$0.50/GB/mo | Layer caching add-on, +$0.50/GB/mo |
| Depot | Ubuntu x64 and arm64, Windows, macOS, GPU; 2 to 64 vCPU | 25 GB or 250 GB, then $0.20/GB/mo, up to 1,000 MiB/s | Its core product, remote BuildKit builders |
| GitHub-hosted | Linux and Windows x64 and arm64, macOS, 1 to 96 vCPU | `actions/cache`, 10 GB per repo, 7-day eviction | None beyond the `gha` cache backend |
| RunsOn | Any EC2 instance type you allow | Yours to configure in your own account | Yours to configure |

## Concurrency, location and what you change to switch

The last column is the real cost of trying one: six of these eight change nothing but the `runs-on` line once the vendor is connected.

| Vendor | Concurrency | Where jobs run | Self-healing | Setup change |
| --- | --- | --- | --- | --- |
| Ubicloud | Not published | Ubicloud's own cloud | No | `runs-on` label |
| Namespace | 32 / 64 / 160 Linux vCPU by plan | Namespace Compute | No | `runs-on` label plus a profile |
| WarpBuild | Not published | WarpBuild's cloud, or yours on BYOC | No | `runs-on` label |
| Latchkey | 20 busy runners per workspace, 4-hour job cap | Latchkey's cloud, one job per runner | Diagnoses and retries inside the run | `runs-on` label, GitHub orgs only |
| Blacksmith | No limits at all, per its runner docs | Blacksmith's own metal | No | GitHub App plus `runs-on` label |
| Depot | Unlimited on every plan | Depot's cloud | No | `runs-on` label, GitHub orgs only |
| GitHub-hosted | 20 / 40 / 60 / 500 jobs by plan, 5 macOS | GitHub's cloud | No | None, it is the default |
| RunsOn | Your AWS account limits | Your own AWS account | No | Infrastructure in your AWS account |

> Every managed vendor here also needs its GitHub connection authorized once. The setup column lists only what changes in the workflow file afterwards. This is the full matrix for all eight vendors. The vendor pages linked below carry a five-row shortlist instead, chosen for the vendor each one is about. Latchkey's row comes from its [runner limits](https://latchkey.dev/documentation/runner-limits), read 2026-09-20: 20 busy runners per workspace by default, raised on request, and a job terminated at four hours.

## Ubicloud: the lowest published rate, Linux only

Ubicloud is an open-source cloud selling GitHub Actions runners on AMD EPYC Genoa as standard and Ryzen 9 as premium, at $0.0012 and $0.0020 a minute for 2 vCPU with 8 GB, with 1,250 free minutes a month and 30 GB of cache included. That is the cheapest published Linux rate here. What it lacks: Linux x64 only, sizes stopping at 16 vCPU, no published billing granularity or concurrency ceiling, and headline cards that disagree with its own size table by 20% on standard and 25% on premium.

## Namespace: cheap per vCPU, if 2 GB per vCPU fits

Namespace bills unit minutes rather than runners: a unit is 1 vCPU and 2 GB of RAM for a minute, times a multiplier of 1 for Linux, 2 for Windows and 10 for macOS. A 2 vCPU 4 GB runner is $0.002 a minute prepaid; the same shape with 8 GB is $0.004, because memory costs units too. It publishes a Linux concurrency ceiling of 32, 64 or 160 vCPU by plan. What it lacks: at 8 GB it is no longer cheap, and there is no standing free allowance.

## WarpBuild: the same managed rate, or half of it in your own cloud

WarpBuild sells managed Linux x64 at $0.004 a minute for 2 vCPU with 8 GB, arm64 at $0.003, Windows at $0.016 on its 4 vCPU card and macOS M4 Pro at $0.08 on its 6 vCPU card. Its distinctive row is bring-your-own-cloud: a flat $0.002 a minute for Linux runners, no size tiers, add-ons free, inside your own cloud account. What it lacks: no published free allowance, concurrency ceiling or cache size, and BYOC hands capacity planning back to you.

## Latchkey: the same rate as its peers, plus repair

Latchkey sells managed Linux runners at $0.0025 a minute for 2 vCPU with 8 GB, $0.005 at 4 vCPU and $0.02 at 16, with 2,000 to 6,000 free minutes a month and a dependency cache that is a one-line swap for `actions/cache`. Its distinctive row is the last in the table: a transient failure is diagnosed and retried inside the run rather than billing the re-run. What it lacks: Linux x86_64 only, so arm64, Windows and macOS jobs stay put, three vendors here undercut its rate, and it publishes no cache size where most of this table does.

## Blacksmith: a high single-core clock, at the median rate

Blacksmith runs jobs on its own metal and sells Ubuntu x64 at $0.004 a minute at 2 vCPU, Ubuntu ARM at $0.0025 on 3 GB per vCPU, Windows x64 at $0.008 and macOS M4 at $0.08, with 3,000 free minutes a month on every card. Its pitch, in its own words rather than a benchmark run here, is a high single-core clock. What it lacks: billing granularity is published nowhere, and Docker layer caching and sticky disks are add-ons at $0.50 per GB per month.

## Depot: GitHub-hosted list price, with a real cache

Depot prices its GitHub Actions runners at $0.006 a minute for 2 vCPU with 8 GB, and its runner docs say it tracks builds by the second and bills for whole minutes used at the end of the month, with no one-minute minimum enforced. It sells 2 to 64 vCPU, Windows, macOS, arm64 and GPU, unlimited concurrency, and 25 GB or 250 GB of cache at up to 1,000 MiB/s. What it lacks: the minute no longer undercuts GitHub-hosted, there is no standalone free tier, and the repository must belong to a GitHub organization.

## GitHub-hosted and RunsOn: the two ends of the table

GitHub-hosted is the reference implementation at $0.006 a minute for Linux 2-core x64, $0.005 for arm64, $0.010 for Windows and $0.062 for macOS, free on public repositories, with the widest OS coverage here. It rounds every job up to the whole minute, the one row where it is worst in class.

RunsOn is a different shape: a flat annual license from EUR 300 up to EUR 3,600 by volume tier, no per-minute markup, and the compute billed to you by AWS per second in your own account. Free for open source, nonprofits and education. What it lacks is everything managed: capacity, images and the pager are yours.

## How to choose without guessing

Four measurements decide this. None is the rate card.

1. Confirm you are paying at all. Public repo, or inside your included minutes, and the answer is stay.
2. Read the memory column, not just the rate. Rank the table at the memory your slowest job actually needs, and half the order changes.
3. Count your re-runs. Pull the last month of workflow runs and work out what share are retries of a failed run. Above a few percent, reliability is the axis, not price.
4. Trial one job for two weeks. Runner selection is per job, so a wrong answer costs a revert commit rather than a migration.

> If your jobs are short and numerous, check the billing granularity row before the rate. Forty jobs of 70 seconds is 46.7 minutes of work and 80 billed minutes once every job is rounded up on its own. Tracking by the second and totalling at the end of the month makes the same work 47 billed minutes, removing 33 of those 80 at an identical rate.

## Switching is one line, in both directions

Selection is per job: point your most expensive job at one vendor, leave the pipeline alone, and compare two weeks of runs. The vendor-specific paths are in [Blacksmith alternatives](/learn/runners/blacksmith-alternatives), [Depot alternatives](/learn/runners/depot-alternatives) and [BuildJet alternatives](/learn/runners/buildjet-alternatives).

```.github/workflows/ci.yml
jobs:
  build:
    runs-on: ubuntu-latest                    # GitHub-hosted
    # runs-on: blacksmith-2vcpu-ubuntu-2404
    # runs-on: depot-ubuntu-24.04
    # runs-on: namespace-profile-default
    # runs-on: latchkey-small
    steps:
      - uses: actions/checkout@v7
      - run: npm ci && npm test
```

## The short answer

Public repository, or private and inside your included minutes: stay on GitHub-hosted. Linux x64 only and the rate decides it: Ubicloud. Cheapest per vCPU when 2 GB per vCPU is enough: Namespace prepaid. A compile-bound critical path: Blacksmith, whose ARM card at $0.0025 buys 6 GB at 2 vCPU, not 8.

Docker-heavy or cache-heavy builds: Depot. High volume with AWS in-house: RunsOn. Runners in your own cloud account: WarpBuild BYOC. Re-runs a measurable share of the bill: Latchkey.

## FAQ

### What are the fastest drop-in replacements for GitHub-hosted runners?

Blacksmith and Depot are the two competing on speed rather than price, and both are a `runs-on` label change. Blacksmith sells a high single-core clock, for a compile-bound critical path. Depot sells cache throughput up to 1,000 MiB/s and remote BuildKit builders, for a Docker-heavy pipeline. Neither claim is benchmarked here.

### What is the cheapest alternative to GitHub-hosted runners?

On published Linux rates at 2 vCPU read on 2026-09-20, Ubicloud at $0.0012 a minute for 8 GB is the lowest, with Namespace at $0.002 for a 4 GB shape and WarpBuild BYOC at a flat $0.002 behind it. At high volume RunsOn beats all three, charging a flat annual license with the compute on your own AWS bill.

### Is there a limit on usage by public repositories?

Not on standard runners. GitHub documents that their use is free in public repositories, with no minute allowance to exhaust. Larger runners are the exception: GitHub states they are not free for public repositories, so a public repo moving a job to one starts paying for it.

### Which GitHub Actions services let you run jobs on faster hardware without self-hosting?

All seven vendors here, each selected by the `runs-on` label rather than by running machines yourself. The two that put the hardware in your own cloud account while keeping the control plane managed are WarpBuild BYOC at a flat $0.002 a minute and RunsOn, which charges a license and no meter.

## References

- [GitHub Actions runner per-minute rates and rounding (verified 2026-09-20)](https://docs.github.com/en/billing/reference/actions-runner-pricing)
- [GitHub Actions billing: included minutes and free public repositories (verified 2026-09-20)](https://docs.github.com/en/billing/concepts/product-billing/github-actions)
- [GitHub Actions limits: concurrent jobs by plan (verified 2026-09-20)](https://docs.github.com/en/actions/reference/limits)
- [Ubicloud GitHub Actions runner sizes and rates (verified 2026-09-20)](https://www.ubicloud.com/use-cases/github-actions)
- [Depot GitHub Actions runners: per-second tracking and whole-minute billing (verified 2026-09-20)](https://depot.dev/docs/github-actions/overview)

---

Latchkey runs CI/CD that repairs its own failures. Agent entry points: https://latchkey.dev/agent.txt, https://latchkey.dev/openapi.json, https://latchkey.dev/llms.txt