Benchmark: Linux kernel builds 68x faster on Avrea than GitHub Actions
On GitHub Actions, a no-cache Linux kernel build takes 27 minutes 23 seconds. On Avrea, the same build, same 2 vCPU spec: 9 minutes 3 seconds without cache, 24 seconds with a warm ccache.
Why the Linux kernel
The Linux kernel is one of the largest open-source C codebases anywhere. Millions of lines of code, a deep object graph, and a build system designed for incremental work. Building it from scratch is a useful way to find out what a CI runner can actually do when you ask it to turn a lot of text into a lot of binary.
The build is CPU-heavy on compilation and linking, and it churns through a lot of intermediate data on disk. If a runner is slow on either, a kernel build exposes it immediately.
How we ran the test
We ran make defconfig && make -j2 on both sides. Same runner spec (2 vCPU, 7.8 GiB, Ubuntu 24.04), same kernel commit.
| GitHub Actions | Avrea | |
|---|---|---|
| Runner label | ubuntu-24.04 | avrea-ubuntu-latest-2-vcpu |
| vCPU | 2 | 2 |
| RAM | 7.8Gi | 7.8Gi |
For the cached run, we used ccache with Avrea's remote cache as the backing store. On the no-cache run, ccache was disabled entirely. The GitHub Actions side had no ccache backing on either run, which is closer to what most CI pipelines look like when no one's set up compiler caching yet.
Each configuration got a few runs; the numbers below are the median. Avrea was consistent, under a second of variance on cached runs. GitHub Actions was noisier: 30-90 seconds of swing on cold builds, depending on which shared VM the job landed on.
Results
| GitHub Actions | Avrea | Speedup | |
|---|---|---|---|
| No cache | 27m 23s | 9m 3s | 3x |
| With cache | n/a | 24.1s | 68x |
Hardware alone runs 3x faster. Add ccache with Avrea's cache layer behind it and a warm build finishes in 24 seconds. The GitHub Actions side has no equivalent cache path in this test.
Why it's faster
The hardware (the 3x)
A no-cache kernel build is brutal on both CPU and disk. The compiler pins a single core for most of the run. The build also writes tens of thousands of object files to /tmp, then the link step at the end reads most of them back.
Avrea's 2 vCPU runner is on dedicated hardware. Single-core sysbench puts it at ~6,500 events/sec; GitHub runs at ~3,670. Disk writes are the bigger gap: ~4 GB/s on Avrea, ~220 MB/s on GitHub. For a build that touches as much disk as a kernel does, that gap dominates.
That's the 3x. Pure machine. No ccache involved.
The cache (the 68x)
ccache hashes each compilation's inputs (the preprocessed source, compiler flags, etc.) and caches the output. If a compilation's hash matches later, ccache hands back the cached object and the compiler never runs.
Kernel builds are unusually well-suited to ccache. Between reasonable commits, most translation units receive identical preprocessor output, so the warm-run hit rate stays very high. On a fully-warm run, the compiler barely runs at all.
Avrea's cache is co-located with the runners, so every ccache lookup reads straight off NVMe. The whole build finishes in 24 seconds.
Other benchmarks in this series
- Bazel (39.7x)
- Ghostty (27x)
- Kafka (6.6x)
- Next.js (142x)
- RisingWave (11.5x)
What Avrea is
Avrea is a drop-in replacement for GitHub Actions runners. Update the runs-on label in your workflow and the build moves over. The rest of the YAML runs unchanged.
Runs come with per-step CPU and memory metrics, searchable log history, and SSH into the running VM. SSH is the one that pays off on long C builds. Linker errors on a kernel build aren't always explainable from the log, and pulling up the object tree directly beats waiting another 9 minutes for a rerun.
