Skip to content
All posts

The Fastest GitHub Actions Runners in 2026: CPU Benchmarks Are Half the Story

Avrea leads RunsOn's 4-vCPU x64 build benchmark. Compare the latest build, CPU and cache results, with methods and runner sizes.

Tatu Mäkijärvi

The Fastest GitHub Actions Runners in 2026: CPU Benchmarks Are Half the Story

Avrea is the fastest GitHub Actions runner in RunsOn's 4-vCPU x64 build benchmark, finishing the three workloads in 6m58s. Here is how that result compares with CPU scores, cache transfers and warm builds.

Build results from RunsOn’s November 5 snapshot; CPU and cache results checked November 3, latest run November 2.

Avrea took first place for combined build time in RunsOn’s four-vCPU x64 comparison. Its Rust, TypeScript and Docker workloads totalled 6m58s, versus GitHub’s 18m18s: 2.63x as fast, or 62% less build time. The ranking adds the median build-step times with build caches disabled; queueing and runner overhead are separate. Our benchmark announcement has the full provider table and workload breakdown.

Avrea is our product. The cross-provider build, CPU and cache results below are published by RunsOn, which also sells runners. We label Avrea’s own tests separately and link to the methods so you can assess both.

What makes a GitHub Actions runner fast?

A workflow spends time waiting for capacity, starting a runner, checking out code, installing dependencies, building and testing, and transferring caches and artifacts. The fastest CPU can still leave you waiting if another step dominates.

Single-thread performance matters for serial work. Parallel compilation and test suites also depend on available cores, memory and how effectively the job uses them. CPU can matter in both cold and warm builds; cache hits reduce the amount of work left to do. Storage and network performance affect both.

That is why a runner comparison needs three views: CPU performance, cache behavior, and an end-to-end run of your actual workflow.

Which GitHub Actions runners have the fastest CPUs?

The table shows x64 runners with 2 vCPU and 8 GB RAM, using PassMark single-thread scores. Higher is better. Scores are medians of completed jobs; RunsOn selects each provider’s highest-scoring tested variant at that size.

Runner / tested variantPassMark single-thread
Namespace 2x84,639
Avrea4,503
RunsOn m8azn.large4,266
WarpBuild4,161
Blacksmith3,985
Ubicloud standard2,923
GitHub 2-core2,306

Swipe to see more →

Source: RunsOn CPU benchmark, checked November 3, 2026; latest run November 2. Each listed score is the median of five runs. These are synthetic CPU scores, not build-time speedups.

For ARM64 at 4 vCPU and 16 GB RAM, Avrea leads the same source’s single-thread comparison at 4,875 points, against 1,876 for GitHub. See the ARM benchmark for cold Rust build times at three runner sizes. Architecture and runner tier must match your workload; an x64 dependency may prevent an otherwise attractive ARM migration.

Use these results to form a shortlist. For a highly parallel build, inspect all-core measurements too. For a memory-heavy test suite, match RAM as carefully as vCPU count. Providers or configurations absent from this selection have not been shown to be slower.

How fast is the GitHub Actions cache?

RunsOn’s cache test saves a 4 GB random file, deletes it, and restores it immediately on the same runner. The figures below are median step durations for x64 runners with 4 vCPU and 16 GB RAM, using actions/cache. Lower is better.

Runner / cache configurationRestoreSave
RunsOn + Magic Cache, m8azn.xlarge, tuned gp38s9s
Avrea11s19s
Blacksmith13s6s
Namespace 4x1618s13s
StarSling21s20s
WarpBuild28s16s
GitHub 4-core46s25s
Ubicloud standard70s56s

Swipe to see more →

Source: RunsOn cache benchmark, checked November 3, 2026; latest run November 2. Storage configurations and cache backends differ; RunsOn’s row uses its tuned gp3 configuration with Magic Cache. The suite reports 3–5 runs per runner and action. This table retains the listed 16-GB configurations; it does not compare persistent cache volumes, snapshot runners or every build tool’s remote cache.

Avrea restored this payload in 11 seconds versus GitHub’s 46 seconds: about 4.2x as fast for that step. Save times were 19 and 25 seconds respectively. Include both in the time your workflow spends waiting.

A large random file is useful for comparing transfers, but your cache may contain thousands of small files, compress well, or miss after a dependency change. Measure your own payload and hit rate before projecting the result onto a whole build.

For runner performance and caching details, see Avrea vs Blacksmith and Avrea vs Depot.

The Avrea vs WarpBuild comparison covers both of WarpBuild’s cache options. Avrea vs Ubicloud compares its standard and premium runners, including CPU and cache results.

Our separate Avrea-published cache test measured a 1 GB restore at 14.10 seconds on GitHub-hosted and 2.89 seconds on Avrea. That is a different test and payload, so those numbers should not be combined with RunsOn’s 4 GB results.

Cold builds and warm builds need separate comparisons

A cold build has no usable cache for the layer being tested. A warm build can reuse previously stored dependencies or build outputs. State which layer is warm: a package download cache, an actions/cache archive, a compiler cache, and a Docker layer cache each avoid different work.

GitHub-hosted runners can use caches across jobs. A fresh VM does not mean a workflow must rebuild everything. GitHub supports restoring files through dependency caching, and workflows can configure compatible external cache services. What matters is which cache is configured, whether it hits, and how long restoring it takes.

On Avrea, GitHub Actions cache requests use colocated storage. Supported build tools also have preconfigured remote build caches, including Bazel, ccache, Go, Gradle, Nix, sccache and Turborepo. That reduces setup work and can avoid compilation when the inputs match.

A warm Avrea run compared with a cold GitHub run demonstrates the combined effect of hardware and caching. It does not establish the speed difference between equally cached providers. For a purchasing decision, compare cold against cold and warm against warm.

What do the differences mean for a real build?

Our Linux kernel benchmark used the same kernel revision and build command on Ubuntu 24.04, with 2 vCPU and 7.8 GiB RAM on each provider. These are Avrea-published results from May 2026.

Build conditionGitHub-hostedAvrea
Cold: cache disabled27m 23s9m 3s
Warm: populated ccacheNot measured24.1s

Swipe to see more →

The cold comparison is about 3x faster on Avrea in this workload. The 24.1-second warm result shows what reusing compiled objects can do. Because that test did not measure GitHub with a populated ccache, it cannot tell you the warm-versus-warm difference.

This is the distinction to look for in any large speedup claim. A repeat of an unchanged commit can be almost entirely cached. A real pull request may invalidate several tasks, and a toolchain or lockfile update may invalidate far more. Include those cases in your evaluation.

Which runner should you choose?

  • If most time goes to compilation or tests: shortlist runners using CPU results, then test your actual parallelism and memory requirements. A larger machine only helps if the workload can use it.
  • If installs and cache restores dominate: check cache hit rates, transfer times and support for your build tools. Avrea is worth evaluating when you want its supported caches configured alongside the runner.
  • If jobs are short: measure queue and startup time under your normal concurrency. A quicker build step may not reduce total feedback time.
  • If cost is the constraint: compare cost per successful workflow, including retries, billing increments, storage and any plan or infrastructure fees. Price per minute alone can be misleading.

GitHub-hosted remains a useful baseline, especially when your jobs already fit its included usage or free standard runners for public repositories. The provider comparisons cover differences beyond speed, and our GitHub Actions pricing guide explains how to compare total costs.

For macOS, test a real Xcode workflow with the same Xcode version, destination and cache state. Linux CPU scores do not predict an iOS build reliably. Avrea’s current macOS offering uses Apple M5 Max hardware; the relevant measure is how long your build and tests take on the runner size you would buy. Our iOS and macOS build benchmark reports uncached and warm-cache results on open-source apps.

How to benchmark runners on your own workflow

  1. Choose one representative workflow. Use the same commit, commands, tool versions, OS and architecture, with comparable CPU and memory allocations. Keep deployment and release side effects out of the comparison.
  2. Define cold and warm conditions. Use an isolated cache namespace or disable the relevant cache for cold runs. Populate each provider’s cache before warm measurements and verify hits in the logs. Record any automatic cache layer you cannot control.
  3. Test realistic changes. Include an unchanged repeat, a small source edit, and a dependency change. Use the same changes on each provider so cache invalidation is comparable.
  4. Repeat and record the whole wait. Run at different times and under representative concurrency. Track queue, startup, checkout, install, restore, build, test and save time, plus failures. Start with at least 10 runs per condition for an initial view; collect more before relying on tail percentiles.
  5. Compare outcomes. Report the median and observed range with the sample count. Use p95 only with enough observations to make it useful. Compare total feedback time and cost per successful run, then investigate the slowest steps.

For cache keys and misses, see our GitHub Actions caching guide. For deployment models and migration tradeoffs, see the guide to GitHub Actions runners.

To try Avrea, follow the getting started guide, install the GitHub App for your test repository, and change the runner label in your comparison workflow:

runs-on: avrea-ubuntu-latest

Start a comparison on Avrea, then judge the result against your existing workflow with both caches configured.

Frequently asked questions

What is the fastest GitHub Actions runner in 2026?

Avrea recorded the fastest combined build time in RunsOn’s November 5, 2026 comparison of four-vCPU x64 runners: 6m58s across Rust, TypeScript and Docker. That ranking covers the measured build steps. Compare your own workflow’s full duration, cache behavior and cost before choosing a runner.

How much faster are third-party runners than GitHub-hosted?

In RunsOn’s four-vCPU x64 build comparison, Avrea took 6m58s versus GitHub’s 18m18s, or 2.63x as fast. Our separate kernel test showed about a 3x improvement with cache disabled on both providers. The gain depends on the workload and cache state.

Can GitHub-hosted runners have warm builds?

Yes. A new VM can restore cached files or use a configured remote build cache. Check the build tool’s hit rate as well as the cache action’s output: restoring an archive does not guarantee the tool reuses every result.

Do faster runners require workflow changes?

On Avrea, install the GitHub App and change the runs-on label to begin. Verify image, architecture and tool compatibility for your workflow. Other providers’ setup and advanced cache features vary, so check the configuration you are actually testing.

Should I choose ARM64 or macOS based on these scores?

Choose the OS your build requires first, then an architecture your dependencies support. Test native workloads on each candidate. A Linux ARM64 CPU score is not an Xcode build benchmark, even when both runners use Apple silicon.

Last updated

Start shipping with Avrea