Namespace runners alternatives, and what the unit minute hides

By Kaveh Alemi·Latchkey

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.

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.

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.

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.

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

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.

Frequently asked questions

Related guides

References

• Namespace pricing: unit minutes, prepaid and overage rates, plan ceilings and rounding (verified 2026-09-20)
• Namespace GitHub Actions docs: runner profiles, cache volumes and remote builders (verified 2026-09-20)
• Ubicloud GitHub Actions runner sizes and rates (verified 2026-09-20)
• WarpBuild pricing: managed size tiers, the flat BYOC rate and snapshot fees (verified 2026-09-20)
• RunsOn benchmarks: published single-thread scores across providers (verified 2026-09-20)
• GitHub Actions documentation