Kache

Build once. Reuse the work.

Kache is a compiler cache for Rust, C/C++, and CUDA on Linux, macOS, and Windows. It restores matching compiler outputs across worktrees and CI runs, so you spend less time rebuilding and less disk space storing the same bytes.

Built by Kunobi.

Get started · Benchmarks · Kache vs sccache · CI setup

Install

Install Kache v2.1.1 and enable it for your build tools:

cargo install kache --locked --version 2.1.1
kache init
kache doctor --probe

Unversioned install commands select the latest stable release. Blaze routing is optional and off by default.

If you use RC.2 with an older cache index, upgrade. RC.3 and later rebuild incompatible prediction metadata and keep compiled entries. Choose a version or upgrade an existing installation →

kache init shows the changes before applying them. It configures Cargo's compiler wrapper and the background service. On Unix it also sets up Cargo and C/C++ shims, test pacing, and shell completions. Open a new terminal after setup. Run kache init --check for a preview. The probe checks compile, store and restore in an isolated local cache without contacting a remote.

Then use Cargo as usual in your project. Kache caches eligible compiler work automatically.

Cargo installation needs Rust 1.95 or newer. Prefer a prebuilt package? Homebrew, APT, AUR, Windows packages, mise, and Nix →

V2 installs kache and its matching kache-engine companion. Keep both when copying an installation into a container or managing release archives yourself.

What v2 covers

Workflow	Start here
Upgrade from 1.x, including the paired binaries and daemon	Upgrade guide
Reuse artifacts and private incremental state across worktrees	Worktrees
Inspect one build, its misses, and work Kache did not cache	Monitor · Troubleshooting
Manage storage, cleanup, and configuration files	Storage and cleanup · Configuration
Understand the client, engine, and concurrent daemon pipelines	Architecture
Opt into local Blaze routing	Blaze

See it reuse a build

Build the same revision in two worktrees with separate target directories. The second can restore compatible outputs from the first. Try the walkthrough.

View the still image.

A new cache needs a build to fill it. Reuse requires matching inputs, toolchain, and build settings. Unsupported compiler invocations run normally. What can be cached →

Why use Kache?

• Reuse eligible Rust libraries, executables, and build scripts across worktrees. It also caches GCC, Clang, clang-cl, and single-source CUDA object compilations.
• Keep identical output bytes once in a cache with a disk budget. On filesystems with copy-on-write cloning, restored outputs share disk blocks with the cache.
• Run builds together. Compiles with the same cache key share one in-flight build, while the scheduler paces compiler processes.
• Share work through S3-compatible storage, Google Cloud Storage, a shared filesystem, or an OCI registry. The local cache works on its own.
• See what happened. Inspect hits and misses, then ask kache explain what changed.

Rust executables and build-script runs are cached by default on Linux and macOS. See platform support and caching limits for Windows and other workload details.

Less disk per worktree

In a Firefox 151 benchmark with Kache 0.7.0 on macOS/APFS, the second worktree added about 3 GB of new data. Read the measurements and methodology →

Nightly workflows measure cold and warm builds of real projects, including Firefox, LLVM, and SurrealDB. Browse the benchmark reports to see the workload, platform, and validation behind each result.

Optional Blaze builds

The Cargo shim can route eligible local commands through an installed Blaze client. Install Blaze separately and opt in from the project:

kache config set --project cache.blaze true
cargo build

This is the beginning of the README. Read the rest at the original. Read the full README ↗