Benchmark: RisingWave builds 11.5x faster on Avrea than GitHub Actions
On GitHub Actions, a no-cache RisingWave build takes 21 minutes 40 seconds. On Avrea, the same build, same 2 vCPU spec: 10 minutes 48 seconds without cache, 1 minute 52 seconds with a warm sccache.
Why RisingWave
RisingWave is a distributed streaming database written in Rust. It has hundreds of crates and a dependency graph deep enough to exercise the compiler's worst cases.
Rust builds are expensive. Each crate goes through parsing, type-checking, borrow-checking, and LLVM codegen. The compiler does a lot of work per crate, and the dependency graph is often wider than people expect, so caching effects depend heavily on where changes land.
sccache is a compiler-level cache. It hashes the inputs to each compilation (source, compiler flags, etc.) and stores the output object file. On a cache hit, the compiler doesn't run for that crate.
How we ran the test
We ran cargo build --release on both sides. Rust stable, 2 vCPU runners, the same pinned RisingWave 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, sccache's remote cache pointed at Avrea's cache backing. On the no-cache run, sccache was disabled. The GitHub Actions side had no remote sccache configured on either run.
A few runs per config. The numbers below are typical.
Results
| GitHub Actions | Avrea | Speedup | |
|---|---|---|---|
| No cache | 21m 40s | 10m 48s | 2x |
| With cache | n/a | 1m 52s | 11.5x |
Hardware alone runs at 2x. Pointing sccache at Avrea's remote cache brings the warm time down to 1 minute 52 seconds, for 11.5x total.
Why it's faster
The hardware (the 2x)
Rust compilation is heavily single-threaded per crate, with some parallelism across independent crates. Avrea's single-core CPU and disk I/O both matter.
Rust has the narrowest no-cache margin of anything we've benchmarked. Cargo parallelizes well across independent crates, so the compiler isn't pinning a single core for the whole build. The CPU-speed advantage matters less here than it does on builds where the compiler is the sole bottleneck.
The cache (the 11.5x)
sccache catches the compilation work when inputs haven't changed. On a cached build with most crate inputs matching, sccache returns cached object files and rustc just runs the linker at the end.
Avrea's cache backing is local to the runners. Reads come off NVMe, which for Rust's bulkier codegen output is faster than pulling objects from S3.
The 11.5x is more modest than Next.js's 142x because Rust compilation is less cache-friendly out of the box. A change to a single source file can invalidate a long dependency chain of downstream crates. And LLVM codegen output is large enough that even cached reads take real time.
In practice on RisingWave, warm builds still spent 30-40 seconds in rustc compiling the crates where changes actually landed. The rest was sccache handing back cached objects near-instantly. That split is closer to real Rust CI than a fully-green cache is.
Other benchmarks in this series
- Bazel (39.7x)
- Linux kernel (68x)
- Ghostty (27x)
- Kafka (6.6x)
- Next.js (142x)
What Avrea is
A one-line YAML change moves your build to Avrea. runs-on: avrea-ubuntu-latest, and your Cargo build runs on our hardware instead of GitHub's.
Each job gets step-level resource metrics, full-text search across logs, and live SSH into the VM. Long Rust builds are where SSH pays off. When sccache returns cold on a crate that shouldn't have changed, checking the cache directory directly beats rerunning and waiting.
