Sccache

0.14.0 · active · verified Mon Apr 13

Sccache (Shared Compilation Cache) is a ccache-like tool written in Rust that acts as a compiler wrapper to accelerate build times by caching compilation results. It supports C/C++, Rust, and CUDA, and can utilize various local and cloud storage backends like S3, Google Cloud Storage, Redis, and Memcached. The PyPI package for sccache (version 0.14.0) primarily provides access to this binary tool for Python environments. It is actively maintained by Mozilla and a community of contributors, with regular releases providing new features and bug fixes.

Warnings

gotcha The `sccache` PyPI package primarily provides a pre-compiled Rust binary. It does not expose a direct Python API for its core caching functionality. Usage is typically via environment variables or by configuring build systems to use the `sccache` executable as a compiler wrapper.
Fix: Interact with `sccache` as a shell command-line tool (e.g., via `subprocess.run` in Python) or configure your build system's compiler paths and environment variables (e.g., `RUSTC_WRAPPER`, `CC`, `CXX`). Do not expect to `import sccache` and call Python functions for caching.
gotcha By default, the `sccache` server will terminate after 10 minutes of inactivity. This can lead to unexpected server shutdowns during long pauses in development or CI.
Fix: To prevent premature server shutdown, you can either explicitly restart the server when needed (`sccache --start-server`) or configure a longer inactivity timeout by setting the `SCCACHE_IDLE_TIMEOUT` environment variable (value in seconds) or in the `sccache` configuration file.
gotcha If the `sccache` server fails to communicate (e.g., due to a crash or network issue), `sccache` will, by default, fail the build.
Fix: To ensure builds gracefully fall back to the local compiler without stopping, set the environment variable `SCCACHE_IGNORE_SERVER_IO_ERROR=1`.
gotcha If you suspect the cache contains broken build artifacts, subsequent builds might repeatedly use corrupted data.
Fix: To force `sccache` to overwrite existing cache entries for a given build, set the environment variable `SCCACHE_RECACHE=1` before running your compilation commands. This forces a re-compilation and updates the cache.
deprecated Older versions of the `mozilla-actions/sccache-action` GitHub Action (and other third-party actions/products using the GitHub Actions cache service) might be impacted by the decommissioning of the old cache service, potentially leading to build failures or lack of caching.
Fix: Ensure you are using the latest version of `mozilla-actions/sccache-action` or any other integration to leverage the updated GitHub Actions cache service. Verify your workflows are not interacting with the decommissioned service by reviewing GitHub's breaking changes notifications.

Install

pip install sccache Install via pip (downloads binary)
cargo install sccache Install via Cargo (requires Rust toolchain)
brew install sccache Install on macOS via Homebrew
scoop install sccache Install on Windows via Scoop

Quickstart

Sccache is primarily used as a command-line wrapper for compilers, configuring your build system to use `sccache` as the compiler executable or wrapper. The PyPI package installs the `sccache` binary. This example demonstrates how to invoke `sccache` via Python's `subprocess` module to wrap a Rust build, showing the typical `RUSTC_WRAPPER` environment variable usage. For C/C++ builds, you would typically set `CC='sccache gcc'` or `CXX='sccache g++'`.

import os
import subprocess

# Ensure sccache is in PATH or set SCCACHE env var if installed elsewhere
# For simplicity, assuming 'sccache' is callable from PATH after 'pip install sccache'

# Start the sccache server in the background (optional, but recommended for efficiency)
# The server automatically stops after 10 minutes of inactivity by default.
subprocess.run(['sccache', '--start-server'])

# Example usage: Compile a Rust project with sccache
# This environment variable tells Cargo/rustc to use sccache as a wrapper
env = os.environ.copy()
env['RUSTC_WRAPPER'] = 'sccache'

print('Building Rust project with sccache...')
try:
    # Simulate a Rust build command
    subprocess.run(['cargo', 'build', '--release'], env=env, check=True)
    print('First build (warming cache) completed.')

    # Run again to demonstrate caching effect
    subprocess.run(['cargo', 'clean'], check=True)
    print('Cache cleaned, running second build...')
    subprocess.run(['cargo', 'build', '--release'], env=env, check=True)
    print('Second build (should be faster due to cache) completed.')

    # Show sccache statistics
    subprocess.run(['sccache', '--show-stats'], check=True)

finally:
    # Stop the sccache server
    subprocess.run(['sccache', '--stop-server'])
    print('Sccache server stopped.')

view raw JSON →