# Namespace runners alternatives, and what the unit minute hides

> Namespace runners alternatives for GitHub Actions, priced against its unit-minute model with every rate read on 2026-09-20 and what each one gives up.

Source: https://latchkey.dev/learn/runners/namespace-alternatives  
Updated: 2026-09-20

Namespace runners alternatives are usually shopped for one of two reasons: the bill came in above the rate that was quoted, or a job needs something the plan ceiling will not give it. Both are properties of the unit-minute model rather than of the hardware, which is genuinely good, so the first job of this page is to show where the money goes and the second is to price the five vendors people move to.

Namespace does not sell runners by the hour or by the size. It sells compute units, where one unit is 1 vCPU and 2 GB of RAM for a minute, multiplied by a platform factor of 1 for Linux, 2 for Windows, 10 for macOS and 7 for Linux on Apple Silicon. A shape that is not a multiple of 1 vCPU to 2 GB is charged at `max(vCPU, RAM / 2)`, so memory costs units even when the cores sit idle.

That is why the headline number and the invoice disagree. The widely quoted $0.002 a minute is a 2 vCPU machine with 4 GB. The like-for-like machine against everyone else, 2 vCPU with 8 GB, is $0.004 prepaid and $0.006 as overage. Prepaid is the effective rate inside a plan: $100 a month buys 100,000 unit minutes on Team, $250 buys 250,000 on Business, and every unit past that bills 50% higher.

The five alternatives below are ranked against that 2 vCPU 8 GB row, read on 2026-09-20, and every one of them is a `runs-on` label change. The full eight-vendor matrix is in [GitHub Actions runner alternatives](/learn/runners/github-actions-runner-alternatives).

## What each alternative does that Namespace does not

A shortlist rather than the field: the five vendors Namespace users actually move to, priced against its 2 vCPU 8 GB prepaid rate of $0.004. Ubicloud for the rate, Blacksmith for a standing free allowance, WarpBuild for runners inside your own cloud, Latchkey for re-run waste, Depot for the cache. Ranked cheapest first, they run Ubicloud, Latchkey, Blacksmith and WarpBuild level, then Depot.

| Alternative | Against $0.004 at 2 vCPU and 8 GB | Best for | What it adds | What it gives up |
| --- | --- | --- | --- | --- |
| Ubicloud | 70% under at $0.0012 | Linux x64 where the rate is the whole argument | 1,250 free minutes a month and 30 GB of cache, with no plan to buy first | Windows, macOS, arm64 and Apple Silicon; Linux x64 only, to 16 vCPU |
| Latchkey | 38% under at $0.0025 | Pipelines where re-runs are a real share of the bill | Repair and retry inside the run, and one rate with no prepaid and overage split | Every platform except Linux x86_64, sizes above 16 vCPU, remote Docker builders |
| Blacksmith | Level at $0.004 for Ubuntu x64 | A single-threaded compile on the critical path | 3,000 free minutes a month and 25 GB of weekly cache per repository | The small shapes: its floor is 2 vCPU with 8 GB, where Namespace sells 1 vCPU with 2 GB |
| WarpBuild | Level managed, 50% under in your own cloud | Runners inside your own AWS, GCP or Azure account | Bring-your-own-cloud at a flat $0.002 a minute with the add-ons free | Capacity planning goes back to you, and snapshots are metered per restore and per hour |
| Depot | 50% above at $0.006 | Docker builds and caches above 25 GB | 25 GB or 250 GB of cache at up to 1,000 MiB/s, and sizes to 64 vCPU | The cheap minute, and a $20 monthly plan before the first job runs |

> Namespace is the only vendor in this table that publishes a concurrency ceiling you can read before you sign: 32, 64 or 160 Linux vCPUs and 12, 24 or 48 macOS vCPUs, by plan. That cuts both ways, which is the point of the row above.

## Where the unit minute helps you, and where it does not

It helps when your jobs are small and memory-light. A 1 vCPU 2 GB shape is $0.001 a minute prepaid and $0.0015 as overage, and nobody else in this comparison sells a machine that small: the floor elsewhere is a 2 vCPU card. It also helps on billing granularity, where Namespace publishes an unusual rule: a minimum of one minute, and everything after that rounds the next 15 seconds down, so 70 seconds bills as one minute and 150 seconds as three.

It stops helping the moment memory outgrows cores. A 4 vCPU machine with 16 GB is 8 units, not 4, so it costs $0.008 a minute while a fixed-size vendor charges the same $0.005 to $0.008 for a card it calls 4 vCPU. And it stops helping at the plan edge, where every rate steps up by half: $0.0030 instead of $0.0020 at 4 GB, $0.0060 instead of $0.0040 at 8 GB, $0.0120 instead of $0.0080 at 16 GB. Nothing about the runner changes.

## What you would be giving up

Concede the strengths before the switch, because three of them have no equivalent in the table above. Namespace publishes the widest platform range of any vendor here: Linux AMD64 and arm64, Windows, macOS on Apple Silicon, and Linux running on Apple Silicon at a 7x multiplier, where a 6 vCPU machine is $0.049 a minute. Its Business plan allows jobs up to 24 hours, where GitHub-hosted caps a job at 6.

It also leads the only published cross-vendor CPU benchmark in this market, RunsOn's Passmark suite, at 4,686 on the 2 vCPU x64 shape against 2,268 for GitHub-hosted. That is a vendor-published number about a competitor, read on 2026-09-20 and not measured here, and it is discussed with the rest of the published evidence in [fastest GitHub Actions runners](/learn/runners/fastest-github-actions-runners).

## The parts of your workflow that are Namespace-shaped

Leaving is a label change plus an undo. Namespace ships its own actions, and a workflow that adopted them has to go back to the standard ones: `nscloud-checkout-action` to `actions/checkout`, and `nscloud-cache-action` to `actions/cache` with real keys. Its remote Docker builders are on by default, so a workflow that deleted `docker/setup-buildx-action` has to put it back.

```.github/workflows/ci.yml
jobs:
  test:
    runs-on: namespace-profile-default
    # runs-on: latchkey-small
    steps:
      - uses: namespacelabs/nscloud-checkout-action@v8
      # - uses: actions/checkout@v5
      - uses: namespacelabs/nscloud-cache-action@v1
        with:
          cache: npm
      # - uses: actions/cache@v4
      #   with:
      #     path: ~/.npm
      #     key: npm-${{ hashFiles('**/package-lock.json') }}
      - run: npm ci && npm test
```

> One behavior changes in both directions and quietly. Namespace documents that its cache action does not support manual partitioning: entries are shared across everything using that runner profile, including main and every branch. `actions/cache` is the opposite, restorable only from the writing branch or the default branch, so expect cold restores on new branches after the move.

## If you are leaving on price: Ubicloud or Latchkey

Ubicloud is the largest gap on this page. Its size table prices 2 vCPU with 8 GB at $0.0012 a minute on AMD EPYC Genoa, or $0.0020 on Ryzen 9, with 1,250 free minutes a month and 30 GB of cache included. Against $0.004 prepaid that is a 70% cut, and against the $0.006 overage rate it is 80%. Worth knowing: its headline cards read $0.0010 and $0.0016, which disagree with its own size table by 20% and 25%.

Latchkey is $0.0025 a minute for the same 2 vCPU with 8 GB, 38% under the prepaid rate and 58% under overage, with 25 GB of cache per repository and 2,000 to 6,000 free minutes by plan on top of a plan fee that starts at $5 a month. Neither of them sells anything but Linux x86_64, which rules both out for the Windows, macOS and Apple Silicon work that is often the reason a team chose Namespace.

## How to choose

Four checks, and the first two are arithmetic you can do from an invoice rather than from a rate card.

1. Pull last month's unit minutes and split them into prepaid and overage. If a fifth of them billed at overage, your effective rate is not the one you compare vendors against.
2. List your shapes and work out `max(vCPU, RAM / 2)` for each. Any job where memory exceeds twice the cores is paying for memory, and a fixed-size card elsewhere may be cheaper for the identical machine.
3. Check what is not Linux x64. Windows, macOS and Apple Silicon jobs eliminate Ubicloud and Latchkey outright, which usually turns this into a two-vendor answer rather than a switch.
4. Count the re-runs in a month of workflow history. If a few percent of your runs are retries of a failure unrelated to your code, that share is worth more than the rate difference between any two rows above.

## The short answer

Stay on Namespace if you use more than one platform, if you need a job longer than six hours, or if a published concurrency ceiling is something you plan capacity against. Its hardware is not the problem anyone is solving by leaving.

Move to Ubicloud if the work is Linux x64 and the rate is the entire argument. Move to Blacksmith for 3,000 standing free minutes and an included weekly cache. Move to WarpBuild if the runners should sit in your own cloud account at a flat $0.002. Move to Depot if a large, fast cache is what you are actually buying. Move to Latchkey if the minutes you want back are the ones spent re-running red jobs, and if Linux x86_64 covers what you run.

## FAQ

### What are unit minutes on Namespace?

A compute unit is 1 vCPU and 2 GB of RAM for one minute, times a platform multiplier of 1 for Linux, 2 for Windows, 10 for macOS and 7 for Linux on Apple Silicon. A shape with more memory than 2 GB per vCPU is charged at the larger of the two, so a 4 vCPU machine with 16 GB bills 8 units a minute rather than 4.

### Why is my Namespace bill higher than the advertised rate?

Usually one of two reasons. The quoted $0.002 a minute is a 2 vCPU shape with 4 GB, and the 8 GB shape everyone else compares against is $0.004. Or your usage passed the unit minutes included in the plan, and overage is exactly 50% above prepaid on every shape Namespace lists: $0.006 instead of $0.004 at 2 vCPU, $0.09 instead of $0.06 on a 6 vCPU macOS machine.

### What is the best alternative to Namespace runners?

It depends which property you are replacing. For rate alone on Linux x64, Ubicloud at $0.0012 a minute. For a standing free allowance, Blacksmith at 3,000 minutes a month. For runners in your own cloud, WarpBuild BYOC at a flat $0.002. For cache throughput and Docker builds, Depot. For re-run waste rather than rate, Latchkey. None of them matches the platform range you would be leaving.

### Does Namespace bill partial minutes?

Partly. Its pricing page documents a one-minute minimum and then rounds the next 15 seconds down, so 30 seconds bills as one minute, 70 seconds bills as one minute, and 150 seconds bills as three. That is friendlier than whole-minute rounding on jobs just over a minute, and it is still a minimum on jobs under one.

## References

- [Namespace pricing: unit minutes, prepaid and overage rates, plan ceilings and rounding (verified 2026-09-20)](https://namespace.so/pricing)
- [Namespace GitHub Actions docs: runner profiles, cache volumes and remote builders (verified 2026-09-20)](https://namespace.so/docs/features/faster-github-actions)
- [Ubicloud GitHub Actions runner sizes and rates (verified 2026-09-20)](https://www.ubicloud.com/use-cases/github-actions)
- [WarpBuild pricing: managed size tiers, the flat BYOC rate and snapshot fees (verified 2026-09-20)](https://www.warpbuild.com/pricing)
- [RunsOn benchmarks: published single-thread scores across providers (verified 2026-09-20)](https://runs-on.com/benchmarks/github-actions-cpu-performance/)

---

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