sccache: caché de compilación para Rust

Compilar Rust es seguro, pero no es gratis. Cada build desde cero vuelve a traducir dependencias que no cambiaron. sccache es una herramienta de Mozilla que actúa como envoltorio del compilador: antes de compilar una unidad, revisa si ya tiene el resultado guardado y, si coincide, lo entrega desde la caché en lugar de rehacer el trabajo. Es el equivalente de ccache, pero pensado también para Rust y para cachés compartidas.

Cómo se instala y se activa

Lo instalas con cargo. Si quieres evitar compilarlo desde el código, cargo-binstall baja un binario ya construido:

cargo install sccache
# o, más rápido:
cargo binstall sccache

Para que cargo lo use, hay dos caminos. El puntual es una variable de entorno:

export RUSTC_WRAPPER=sccache
cargo build --release

El permanente es dejarlo escrito en ~/.cargo/config.toml, para que aplique a todos tus proyectos sin recordar la variable:

[build]
rustc-wrapper = "sccache"

Mira si de verdad está cacheando

No des por hecho que funciona: mídelo. sccache lleva la cuenta de aciertos y fallos de caché, y los muestra con un comando:

sccache --show-stats

Una sesión típica para comprobarlo es compilar en limpio y revisar las cifras. La primera vez casi todo serán fallos (aún no hay nada guardado); la segunda, tras un cargo clean, deberías ver muchos aciertos:

export RUSTC_WRAPPER=sccache
cargo clean
cargo build --release
sccache --show-stats   # revisa "Cache hits" vs "Cache misses"

Caché local frente a caché compartida

Por defecto, sccache guarda todo en disco, en tu propia máquina. Eso ya sirve para no repetir trabajo entre ramas o después de limpiar target/. Pero su diseño brilla cuando la caché se comparte: puede apoyarse en un almacén remoto para que varias máquinas —o los runners de CI— reutilicen los mismos artefactos.

Cada backend remoto se configura con sus propias variables de entorno. Dos ejemplos:

# Redis
export SCCACHE_REDIS=redis://mi-servidor:6379

# Almacenamiento compatible con S3
export SCCACHE_BUCKET=mi-bucket
export SCCACHE_REGION=us-east-1

La parte honesta: no cachea todo

sccache no es magia, y conviene saber qué queda fuera antes de esperar milagros:

• No cachea el enlazado final. Las unidades que invocan al enlazador del sistema —ejecutables (bin), dylib, cdylib y proc-macro— no se cachean. Lo que se reutiliza son las dependencias compiladas como biblioteca, no el último paso que arma tu binario.
• No cachea la compilación incremental. Las unidades compiladas de forma incremental quedan fuera, así que en tu bucle local de cargo build repetido —donde la caché incremental propia de Cargo ya hace su trabajo— sccache puede no ayudar, e incluso estorbar.
• Su ganancia real está en los builds limpios y en CI. Ahí es donde no hay estado incremental que reutilizar y donde compartir artefactos entre máquinas se nota de verdad.

Por eso la recomendación no es "actívalo siempre", sino "actívalo donde compilas desde cero a menudo y comprueba las cifras". Si --show-stats te muestra pocos aciertos en tu flujo, quizá no es la herramienta para ese caso.

Cuándo usarlo / Qué recordar

• Úsalo sobre todo en CI y en equipos, con una caché compartida: es donde recupera más tiempo.
• En local sirve para builds limpios y cambios de rama; para el ciclo incremental diario, la caché de Cargo ya cubre buena parte.
• Actívalo con RUSTC_WRAPPER=sccache o en ~/.cargo/config.toml, y mide con sccache --show-stats antes de sacar conclusiones.
• Recuerda sus límites: no cachea el enlazado final ni la compilación incremental.

Es una pieza más de la caja de herramientas: afina el tiempo de compilación sin tocar tu código. Mídelo, quédate con él donde gane, y quítalo donde no.