Benchmark: Ghostty builds 27x faster on Avrea than GitHub Actions
On GitHub Actions, a no-cache Ghostty build takes 10 minutes 27 seconds. On Avrea, the same build, same 2 vCPU spec: 3 minutes 33 seconds without cache, 23 seconds with a warm Nix binary cache.
Why Ghostty
Ghostty is an open-source terminal emulator by Mitchell Hashimoto (of HashiCorp), written in Zig and packaged with Nix. We picked it because the build graph is realistic (Zig toolchain, system libraries, final binary) and because Nix caches differently from every other build tool we've benchmarked. We wanted to see what Nix caching actually looks like in numbers.
Nix caches whole derivations: built packages keyed by the hash of their inputs. The full Ghostty build graph, including the compiler toolchain and system dependencies, is a graph of derivations. On a cache hit, Nix pulls the derivation's output. On a miss, it builds from source. The more hits you get, the closer the build gets to doing nothing.
How we ran the test
We ran nix build . against a pinned Ghostty commit. Runner sizes matched across both sides.
| 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 Avrea's Nix binary cache as a substitute for the default substituters. On the no-cache run, the binary cache was disabled; every derivation built from source. The GitHub Actions side had no binary cache backing on either run, which is typical: most Nix CI setups don't wire one up unless someone does it explicitly.
Each configuration ran a handful of times. The numbers are medians. Avrea's cached runs were tight (within a few seconds). GitHub Actions was noisier on the no-cache side.
Results
| GitHub Actions | Avrea | Speedup | |
|---|---|---|---|
| No cache | 10m 27s | 3m 33s | 2.9x |
| With cache | n/a | 23.0s | 27.2x |
Hardware alone runs 2.9x faster. Pointing Nix at Avrea's binary cache brings the warm time to 23 seconds, for 27x total. Nix on GitHub-hosted runners has no equivalent cache path in this test.
The Zig toolchain is the heaviest derivation in this build. On a cache miss it accounts for a big chunk of the cold time. On a cache hit, that same derivation becomes a read off disk. That one dependency moving from “build” to “fetch” is a big part of why Ghostty's gap is so wide.
Why it's faster
The hardware (the 2.9x)
A no-cache Ghostty build compiles Zig, builds system libraries, and links the final binary. CPU-heavy but also dependency-dense: many small builds, lots of filesystem operations for staging and linking.
On a 2 vCPU runner, Avrea clocks roughly 6,500 sysbench events/sec single-core. GitHub does around 3,670. Disk is a wider gap: 4 GB/s vs 220 MB/s on writes. Hardware carries the 2.9x on its own.
The cache (the 27x)
Nix's binary cache is content-addressed: if the inputs haven't changed, the derivation's output already exists somewhere, named by its hash. A cached build becomes: resolve the graph, read or fetch the cached outputs, done.
Avrea's binary cache sits on the same infrastructure as the runners. “Fetch” is a read from local NVMe. That's how the Ghostty build goes from 10 minutes to 23 seconds without the compiler running at all.
Nix's caching model stores whole-derivation outputs rather than single compile units, which is why the warm number drops so hard. If you're running Nix in CI without a binary cache, that's the gap you're leaving on the table.
Other benchmarks in this series
- Bazel (39.7x)
- Linux kernel (68x)
- Kafka (6.6x)
- Next.js (142x)
- RisingWave (11.5x)
What Avrea is
Avrea's runners are drop-in replacements for GitHub's. Change one line in your workflow: runs-on: avrea-ubuntu-latest.
Each job has step-level metrics on CPU and memory, full-text search across the log history, and live SSH access to the VM. SSH access is especially useful on Nix. Hash mismatches and unhelpful build logs are a Nix speciality; opening up the actual build directory beats reading the log and guessing.
