Installation

kache requires Rust 1.95 or later and is built with the 2024 edition (Cargo.toml edition = "2024"). The binary is self-contained — no runtime dependencies.

Methods

mise downloads the pre-built binary from GitHub releases and pins the version per project or globally.

# install globally
mise use -g github:kunobi-ninja/kache@latest

# or pin a specific version
mise use -g github:kunobi-ninja/kache@0.5.0

To pin kache in your project so every contributor gets the same version, add it to your mise.toml:

[tools]
"github:kunobi-ninja/kache" = "latest"

Running mise install in the project root will install the pinned version.

cargo-binstall downloads the pre-built binary from GitHub releases without compiling.

cargo binstall kache

Every release (including RCs) is published to crates.io, so the plain crate name works. To install an unreleased branch build instead, use the --git form: cargo binstall --git https://github.com/kunobi-ninja/kache kache.

If a pre-built binary isn't available for your target, use the source install method below.

cargo install kache

This compiles kache with your local toolchain. It takes a couple of minutes and works on Linux, macOS, and Windows (with the MSVC toolchain). To build an unreleased branch instead, use cargo install --git https://github.com/kunobi-ninja/kache kache.

The methods above install the latest stable release. Release-candidates are published but never resolve as "latest", so request one explicitly: cargo install kache --version 0.6.0-rc.1 (or cargo binstall kache@0.6.0-rc.1).

OS package managers

kache is also published to Homebrew, APT, winget, Scoop, Chocolatey, and the AUR. Most have both a stable channel and an unstable channel (release-candidates / betas).

# Stable
brew install kunobi-ninja/kunobi/kache

# Unstable (RC/beta)
brew install kunobi-ninja/kunobi/kache-unstable

Install the signing key once, then add the repo — stable or unstable suite:

# Signing key (KMS-rooted OpenPGP cert), dearmored into a keyring
sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://r2.kunobi.com/kache/apt/gpg.key \
  | sudo gpg --dearmor -o /etc/apt/keyrings/kache.gpg

# Stable
echo "deb [signed-by=/etc/apt/keyrings/kache.gpg] https://r2.kunobi.com/kache/apt stable main" \
  | sudo tee /etc/apt/sources.list.d/kache.list

# Unstable (RC/beta) — swap the suite instead:
# echo "deb [signed-by=/etc/apt/keyrings/kache.gpg] https://r2.kunobi.com/kache/apt unstable main" \
#   | sudo tee /etc/apt/sources.list.d/kache.list

sudo apt update && sudo apt install kache

Stable .debs also land in the unstable suite, so an unstable subscriber still receives GA releases.

# Stable
winget install kunobi-ninja.kache

# Unstable (RC/beta)
winget install kunobi-ninja.kache.Unstable

Add the Kunobi bucket once, then install from it:

scoop bucket add kunobi https://github.com/kunobi-ninja/scoop-kunobi

# Stable
scoop install kunobi/kache

# Unstable (RC/beta)
scoop install kunobi/kache-unstable

kache and kache-unstable both provide a kache command. With both installed, run scoop reset kache-unstable (or scoop reset kache) to choose which one the kache shim points at.

# Stable
choco install kache

# Unstable (RC/beta) — same package, pre-release versions
choco install kache --pre

Three packages are available (all provide the kache command — install one):

# Official prebuilt binary — recommended (statically linked, x86_64 + aarch64, no compile)
paru -S kache-bin

# Official, builds the latest main from source
paru -S kache-git

# Community-maintained, builds the latest release from source
paru -S kache

kache-bin and kache-git are the official Kunobi packages; kache is a community-maintained source build.

Nix

The repo is a flake. Unlike the methods above it builds kache from source, with the Rust toolchain pinned in rust-toolchain.toml rather than whatever rustc your nixpkgs happens to ship.

# Run it once without installing
nix run github:kunobi-ninja/kache -- --version

# Install into your profile
nix profile install github:kunobi-ninja/kache

To consume it from your own flake, add the input and apply the overlay. The overlay provides pkgs.kache and pkgs.kache-rust-toolchain:

{
  inputs.kache.url = "github:kunobi-ninja/kache";

  outputs = { nixpkgs, kache, ... }: {
    # ...
    nixpkgs.overlays = [ kache.overlays.default ];
    environment.systemPackages = [ pkgs.kache ];
  };
}

There is also a NixOS and nix-darwin module that installs kache, writes config.toml, optionally sets RUSTC_WRAPPER system-wide, and runs the daemon as a systemd user service (Linux) or launchd agent (macOS):

{
  imports = [ kache.nixosModules.default ];  # or kache.darwinModules.default

  services.kache = {
    enable = true;
    daemon.enable = true;
    settings.cache = {
      local_max_size = "50GB";
      remote = {
        type = "s3";
        bucket = "my-kache-bucket";
      };
    };
  };
}

Apply kache.overlays.default alongside the module. services.kache.package defaults to pkgs.kache from the overlay; without it the module falls back to building against nixpkgs' rustc, which can be older than the crate's rust-version.

The flake builds for x86_64-linux, aarch64-linux, and aarch64-darwin. Intel macOS (x86_64-darwin) is absent because nixpkgs 26.11 dropped the platform, not because kache dropped it: the pre-built x86_64-apple-darwin binary and cargo install both still work there.

Contributors can get the pinned toolchain plus just and cargo-deny with nix develop. mise remains the primary tool manager for the repo.

Supported platforms

Pre-built binaries are available for:

Target	Notes
`x86_64-unknown-linux-musl`	Statically linked, works on any Linux
`aarch64-unknown-linux-musl`	ARM Linux (AWS Graviton, etc.)
`x86_64-apple-darwin`	Intel macOS
`aarch64-apple-darwin`	Apple Silicon
`x86_64-pc-windows-msvc`	Windows x64 (MSVC)
`aarch64-pc-windows-msvc`	Windows ARM64 (MSVC)

Verify the installation

kache --version

You should see a version string like kache 0.5.0. If the command isn't found, make sure the binary is on your PATH (mise handles this automatically).

Next: enable kache for cargo

Installing the binary doesn't yet wire it into cargo. Run kache init to configure your cargo config (~/.cargo/config.toml, or the legacy ~/.cargo/config if that file already exists), install the daemon as a login service, and start it — see Quick start for the full walkthrough.