Benchmarking: Compare kache vs sccache

[jleni]

How does Kache compare with sccache, and what benchmark scenarios would be useful?

[jleni]

kache is benchmarked continuously, and we treat it as more than a speed contest. Wall-clock time is one axis; hit rate, deduplication, and miss behavior matter just as much, because a cache that is fast but wrong or wasteful is not actually winning.

How we benchmark

• Nightly runs, not one-off numbers, so regressions show up fast.
• Real projects at real scale: Firefox, LLVM, and Substrate.
• A full OS matrix: Linux, macOS, and Windows.
• Currently in active tuning, so the numbers are still improving.
• We published an initial writeup on local macOS performance (linked below).

What we measure, not just speed

• Cold versus warm wall-clock time.
• Cache hit rate (local and remote).
• Deduplication and disk saved, which is the dominant pain for anyone running many worktrees.
• A breakdown of misses by compile time, so you can see which crates still cost you.

Where kache puts its emphasis

• Correctness first: keys are content-addressed, so kache does not serve a stale artifact. It would rather miss than be wrong.
• Sharing without coupling: the same content-addressed keys converge across worktrees and across machines, so parallel checkouts and CI runners reuse each other's work.
• Zero-copy restores: hits are materialized by reflink or hardlink, so a warm cache lands almost instantly on modern filesystems.
• Rust and C/C++ together: hybrid projects are cached as one graph, which most Rust-only caches do not cover.
• Visibility: hit, miss, and dedup metrics are first-class, including a per-run report in CI.

Benchmark scenarios that are actually useful

• Cold build from empty, the baseline cost.
• Warm rebuild with no changes, the best case.
• Cross-worktree: build one checkout, then a second checkout at a different path, and measure the hits.
• Cross-machine and CI: populate the cache on one runner, then measure a fresh runner pulling from the remote.
• Single-crate edit and rebuild, to see the incremental path.
• Polyglot: a Rust plus C/C++ project, including -sys crates.
• Disk under load: N parallel worktrees, measured with and without dedup, to show bytes saved.

What is next

The current foundation is about correct, well-measured caching. The next phase focuses on optimizing prefetching and network behavior, which is where remote and CI builds get their next big step up, especially on cold or ephemeral runners.

❗❗ Btw, if you really want to help benchmarking, writing blogs or opening issues, please, we are more than happy to receive any contributions!!!