# Waarom rust-cache je Rust-CI niet snel maakt (tauri: van 246 s naar 53 s)

> Swatinem/rust-cache cachet je dependencies, niet de crates van je workspace, en zet incrementele compilatie uit. Dus op de nieuwe VM van GitHub compileert elke warme job je eigen crates opnieuw. Een target/ die bewaard blijft op een machine die blijft, lost het op: de CI-job van tauri ging van 246 s naar 53 s op Skipbox, voor een vaste $39 per maand.

Swatinem/rust-cache, de cachestep in de meeste Rust-CI, slaat je dependencies op en laat de crates van je workspace bewust weg. Hij zet ook `CARGO_INCREMENTAL=0`. Op de runners van GitHub start elke job op een nieuwe VM, dus elke warme job, volledige cache hit en al, compileert je eigen crates opnieuw. Geen enkele instelling van rust-cache haalt dat weg. Wat wel helpt, is een `target/` die er van de vorige job nog staat: Cargo slaat dan elke crate over die niet is veranderd.

Skipbox bewaart hem voor je. Je job draait op de dedicated machine van je account, die de checkout en `target/` van Cargo tussen jobs bewaart. De CI-job van tauri duurde 246 s op GitHub en daar 53 s, zonder vanaf de eerste warme run ook maar één van zijn crates te compileren, zonder enige wijziging aan zijn workflow behalve `runs-on: skipbox`, voor een vaste $39 per maand.

- De CI-job van tauri: 246 s op GitHub, 53 s op Skipbox (4,6× sneller). Elke run is openbaar
- Met `target/` bewaard compileerde Cargo geen enkele crate van tauri: zijn buildtijd ging van 62 s naar minder dan 2 s
- 20.000 minuten per maand op 4 vCPU: $222 op GitHub, $39 op Skipbox

**GitHub Actions voor een vaste prijs, onbeperkte minuten** Skipbox draait je GitHub Actions-jobs op je eigen dedicated machine: $39 per maand, hoeveel minuten je ook draait. Docker-layers en dependencycaches blijven tussen jobs bewaard, dus de volgende job start meteen.

Een runner met 4 vCPU, 20.000 minuten per maand: GitHub $222 → Skipbox $39. Je bespaart elke maand $183.

Overstappen kost één regel: `runs-on: skipbox`.

[Gratis 7-daagse proefperiode starten](https://app.skipbox.dev/sign-in?ref=g-rust-cache-slow-rust-ci-nl)

## Wat rust-cache bewaart, en wat hij weglaat

Uit de [README van rust-cache](https://github.com/Swatinem/rust-cache#cache-details) en zijn broncode:

- **Wat hij cachet:** `~/.cargo` (de registry, git-dependencies, geïnstalleerde binaries) en `./target` met de builduitvoer van je dependencies.
- **Wat hij weglaat:** de crates van de workspace zelf worden niet gecachet. Vóór de save verwijdert zijn opruimstap alles in `target/` wat geen dependency is, dus de artifacts van je crates worden uit `target/` zelf verwijderd.
- **Incrementele compilatie:** de restore-step exporteert `CARGO_INCREMENTAL=0` voor de rest van de job.
- **Wanneer hij opslaat:** alleen als er nog geen cache met de key van de job is. De key komt van de toolchain, de omgeving, en je `Cargo.lock` en `Cargo.toml`. Je bronbestanden horen er niet bij.

Op een nieuwe VM komt dat op één ding neer. Een warme job zet je dependencies terug en compileert dan de crates van je workspace en alles wat erop is gebouwd, helemaal, elke keer.

## Het mechanisme, in de logs van tauri

De `test`-job van tauri draait vijf `cargo test`-steps op Ubuntu, met rust-cache. Dit zijn zijn warme runs, elk een volledige cache hit (`full match: true` in het log):

| Warme run | `Compiling`-regels | Buildtijd van Cargo | Job |
|---|---|---|---|
| [GitHub](https://github.com/skipbox-dev/tauri/actions/runs/43234522982) | 32 | 118 s | 271 s |
| [Skipbox, nieuwe VM](https://github.com/skipbox-dev/tauri/actions/runs/43291768486) | 32 | 62 s | 146 s |
| [Skipbox, dedicated machine, 1e warme run](https://github.com/skipbox-dev/tauri/actions/runs/43340142076) | **0** | **ongeveer 1,5 s** | **53 s** |
| [Skipbox, dedicated machine, 2e warme run](https://github.com/skipbox-dev/tauri/actions/runs/43340289959) | **0** | **ongeveer 1,9 s** | **53 s** |

De 32 regels zijn de eigen crates van tauri, en twee plugins die erop zijn gebouwd. De dependencies verschijnen nooit: die komen uit de cache. De buildtijd van Cargo is de `Finished … in`-tijden van de vijf steps bij elkaar opgeteld.

De nieuwe VM heeft de CPU's van de dedicated machine en dezelfde cache, en compileerde dezelfde 32 crates als GitHub: zijn `target/` bevatte alleen wat de cache terugzette. Op de dedicated machine toont de eerste warme run al geen enkele `Compiling`-regel. Cargo controleerde alleen dat er niets was veranderd, en elke `Finished` duurde 0,2-0,7 s.

De eerste warme run van de dedicated machine compileerde vroeger alle 32 crates opnieuw ([een job van 114 s](https://github.com/skipbox-dev/tauri/actions/runs/43307552081)), omdat de save van rust-cache na de koude run ze uit `target/` had verwijderd. Sinds 13 november 2026 maken dedicated machines ongedaan wat de restore en save van rust-cache van de schijf verwijderen, zodra de step eindigt. De cache die hij opslaat, is dezelfde, en je crates blijven in `target/`.

## Jobtijden: drie Rust-projecten, zes andere

De eigen CI-jobs van echte projecten op een vastgezette commit, de steps byte voor byte; alleen de trigger en `runs-on` zijn gewijzigd. Eén koude run, daarna twee warme, aan elke kant:

- **GitHub:** `ubuntu-24.04`, de standaardrunner van een openbare repository: 4 vCPU, 16 GB.
- **Skipbox, nieuwe VM:** een nieuwe VM per job uit de productie-image van de runner, 4 vCPU en 8 GB, caches teruggezet via de cache van Skipbox.
- **Skipbox, dedicated machine:** dezelfde grootte op dezelfde host-CPU's, tussen jobs bewaard, met het bewaren en wissen dat dedicated machines sinds 13 november 2026 doen: de checkout en `target/` blijven, en wat rust-cache verwijdert, wordt teruggezet.

De runs van Skipbox draaiden op een Skipbox-host, in een labproject dat gescheiden is van de machines van klanten. De tijden lopen van de start tot het einde van elke job, uit de API van GitHub. Elk getal is de mediaan van de twee warme runs. De koude runs van de dedicated machine duurden [285 s](https://github.com/skipbox-dev/tauri/actions/runs/43339483384) voor tauri, [161 s](https://github.com/skipbox-dev/ripgrep/actions/runs/43340538466) voor ripgrep en [442 s](https://github.com/skipbox-dev/helix/actions/runs/43336739720) voor helix.

| Project | GitHub | Skipbox, nieuwe VM | Skipbox, dedicated machine | GitHub ÷ dedicated machine |
|---|---|---|---|---|
| tauri | 246 s ([220](https://github.com/skipbox-dev/tauri/actions/runs/43233861304), [271](https://github.com/skipbox-dev/tauri/actions/runs/43234522982)) | 210 s ([273](https://github.com/skipbox-dev/tauri/actions/runs/43290912312), [146](https://github.com/skipbox-dev/tauri/actions/runs/43291768486)) | **53 s** ([53](https://github.com/skipbox-dev/tauri/actions/runs/43340142076), [53](https://github.com/skipbox-dev/tauri/actions/runs/43340289959)) | **4,6×** |
| ripgrep | 200 s ([194](https://github.com/skipbox-dev/ripgrep/actions/runs/43220584380), [206](https://github.com/skipbox-dev/ripgrep/actions/runs/43221108547)) | 156 s ([155](https://github.com/skipbox-dev/ripgrep/actions/runs/43292759363), [156](https://github.com/skipbox-dev/ripgrep/actions/runs/43293273127)) | **40 s** ([39](https://github.com/skipbox-dev/ripgrep/actions/runs/43340925562), [40](https://github.com/skipbox-dev/ripgrep/actions/runs/43341036341)) | **5,0×** |
| helix | 330 s ([293](https://github.com/skipbox-dev/helix/actions/runs/43227916673), [366](https://github.com/skipbox-dev/helix/actions/runs/43228816343)) | 350 s ([439](https://github.com/skipbox-dev/helix/actions/runs/43287815770), [260](https://github.com/skipbox-dev/helix/actions/runs/43289134146)) | **224 s** ([222](https://github.com/skipbox-dev/helix/actions/runs/43337749813), [226](https://github.com/skipbox-dev/helix/actions/runs/43338273330)) | **1,5×** |

ripgrep bouwt binnen de Docker-image van cross. cross maakt `target/` zelf aan en markeert hem met "created by cross". Dedicated machines zagen die `target/` vroeger aan voor iets anders dan die van Cargo en verwijderden hem na elke job, dus Cargo compileerde bij elke run elke crate opnieuw (een job van 108 s). Nu blijft de `target/` van cross staan: de warme runs tonen geen enkele `Compiling`-regel, en elke `Finished` duurt 0,04-0,05 s. GitHub downloadt ook de image van cross bij elke run (30 s in de tweede warme run); de dedicated machine houdt hem op de schijf.

Ook helix draait 1,5× sneller. Van zijn crates bouwt alleen helix-term (en xtask, dat ervan afhangt) opnieuw, omdat het buildscript van helix-term bij elke job draait: 16 s in het `test`-profiel en 61 s in het `integration`-profiel. Geen andere crate compileert. Het grootste deel van de job van helix zijn de tests: de integratietestsuite alleen al draait 112 s. Zijn setupstep, toolchain en terugzetten van de cache, duurde 9-10 s tegenover 41-46 s op GitHub.

De andere talen:

| Project | Taal | GitHub | Skipbox, dedicated machine |
|---|---|---|---|
| [astro](https://github.com/skipbox-dev/astro/actions) | Node.js | 528 s | **30 s** |
| [vite](https://github.com/skipbox-dev/vite/actions) | Node.js | 141 s | 100 s |
| [prometheus](https://github.com/skipbox-dev/prometheus/actions) | Go | 335 s | 273 s |
| [cli](https://github.com/skipbox-dev/cli/actions) | Go | 163 s | 137 s |
| [pytest](https://github.com/skipbox-dev/pytest/actions) | Python | 416 s | 365 s |
| [guava](https://github.com/skipbox-dev/guava/actions) | Java | 818 s | 651 s |

astro is hetzelfde verhaal als `target/`, met Turborepo: de dedicated machine bewaart de cache van turbo (turbo 2), dus zijn warme runs spelen alle 40 buildtaken en de testtaak daaruit af in plaats van ze te draaien ([31 s](https://github.com/skipbox-dev/astro/actions/runs/43351547473), [28 s](https://github.com/skipbox-dev/astro/actions/runs/43351638436)).

`ubuntu-latest` van een privé-repository heeft 2 CPU's en 8 GB: de helft van de cores van de GitHub-runs hierboven.

## Controleer je eigen CI

1. Open een warme run van je Rust-job, een waarvan de rust-cache-step `full match: true` logt.
2. Tel in de build- en teststeps de `Compiling`-regels. Dependencies uit de cache tonen er geen. Elke crate van je workspace toont er één, en elke crate die erop is gebouwd ook.
3. Tel de `Finished … in`-tijden van de steps op. Dat is wat je eigen crates elke run kosten, en wat een bewaarde `target/` bespaart als ze niet zijn veranderd.

## Wat je op de runners van GitHub kunt doen

- **`cache-workspace-crates: true`** (rust-cache v2.8.0 en later). Je crates gaan ook in de cache. Maar een run waarvan de key bestaat, slaat de save over, en de key verandert niet met je broncode, dus de gecachte crates zijn zo oud als de laatste save. Incrementele compilatie blijft uit, en de cache groeit binnen de 10 GB per repository van GitHub.
- **sccache.** Het cachet elke compilatie op zijn invoer, dus een ongewijzigde library-crate komt terug uit de opslag. Crates die de linker aanroepen, kunnen niet worden gecachet: binaries, `dylib`-, `cdylib`- en proc-macro-crates compileren elke keer, en elke hit is een download.
- **Een self-hosted runner die `target/` bewaart.** Jij draait de machine: patchen, opruimen tussen jobs zonder `target/` te verwijderen, en `clean: false` instellen op actions/checkout, waarvan de standaard `git clean -ffdx` `target/` samen met elk ander genegeerd bestand verwijdert.

## Skipbox bewaart target/ voor je

Elk abonnement komt met de dedicated machine van je account, die tussen jobs bewaard blijft. Sinds 13 november 2026 bewaart hij je checkout, met de tijden van zijn bestanden, en `target/` van Cargo:

- De clean van actions/checkout draait zoals gewoonlijk, behalve dat hij de `target/`-mappen van Cargo met rust laat.
- rust-cache blijft in je workflow. Zijn restore schrijft de oudere artifacts uit de cache niet meer over de nieuwere op de schijf heen.
- Wat de save en restore van rust-cache uit `target/` en `~/.cargo` verwijderen, zet de machine terug zodra de step eindigt. De opgeslagen cache is dezelfde, en vanaf de job na de koude run worden crates die niet zijn veranderd niet gecompileerd.
- De `target/` die cross aanmaakt (gemarkeerd met "created by cross") blijft ook staan.
- actions/checkout herschrijft `.git/HEAD` bij elke job. Zolang het nog dezelfde commit noemt, krijgt het bestand zijn oude tijd terug, dus een buildscript dat `.git/HEAD` in de gaten houdt (vergen doet dat), draait daar niet alleen om opnieuw.

De machine bewaart ook Docker-images, packagecaches en geïnstalleerde tools, dus de rest van de job wordt mee sneller. Een job kiest zijn grootte met zijn label:

| Label | Machine | Abonnement |
|---|---|---|
| `skipbox` | 4 vCPU · 16 GB | S, $39 per maand |
| `skipbox-8x16` | 8 vCPU · 16 GB | M, $79 per maand |
| `skipbox-16x32` | 16 vCPU · 32 GB | L, $149 per maand |

De minuten zijn onbeperkt. Bij 20.000 minuten per maand op 4 vCPU rekent GitHub $222; Skipbox S is $39, $183 minder.

## Overstappen kost één regel

```yaml
jobs:
  test:
    runs-on: skipbox # was ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: dtolnay/rust-toolchain@stable
      - uses: Swatinem/rust-cache@v2
      - run: cargo test --workspace
```

1. Log in bij Skipbox met GitHub.
2. Installeer de GitHub-app van Skipbox en kies de repository's.
3. Wijzig `runs-on` en push.

## Beveiliging

- De machine is alleen van je account. Er draaien geen jobs van een ander bedrijf op.
- Na elke job worden de credentials, processen en containers van de runner gewist, en ook de git-credentials, hooks en niet-gevolgde bestanden in de bewaarde checkout. Met Schone VM per job krijgt elke job in plaats daarvan een nieuwe machine.
- Code van mensen zonder schrijfrechten (zoals pull requests vanuit forks) draait op een nieuwe wegwerpmachine, zonder bewaarde `target/`.

De details staan in [zo worden jobs geïsoleerd](https://docs.skipbox.dev/nl/isolation).

## Probeer het op je Rust-job

De proefperiode is gratis voor 7 dagen of 3.000 jobminuten, wat het eerst komt, en er is geen kaart voor nodig. Zet je Rust-job op `runs-on: skipbox`, draai hem twee keer, en leg de `Compiling`-regels van de tweede run naast die van GitHub.

## Veelgestelde vragen

### Cachet Swatinem/rust-cache de crates van mijn workspace?

Nee, standaard niet. Volgens zijn README worden de crates van de workspace zelf niet gecachet, en zijn save-step verwijdert hun builduitvoer uit target/ voordat hij de cache uploadt. Hij cachet ~/.cargo en de builduitvoer van je dependencies, en zet CARGO_INCREMENTAL=0 voor de rest van de job. Dus op een nieuwe GitHub-VM compileert elke warme run de crates van je workspace opnieuw, zelfs bij een volledige cache hit. In de CI van tauri op GitHub waren dat 32 Compiling-regels bij elke warme run.

### Moet ik cache-workspace-crates: true instellen?

Het zet je crates ook in de cache (rust-cache v2.8.0 en later), maar de cachekey komt van je toolchain, je omgeving en je Cargo.lock en Cargo.toml, niet van je broncode. Een run waarvan de key al bestaat, slaat de save over, dus de gecachte kopie van je crates is zo oud als de laatste save en loopt met elke commit verder achter op je code. Incrementele compilatie blijft uit. Kijk in het log van een warme run: tonen je crates nog Compiling, dan helpt het niet.

### Lost sccache trage Rust-CI op GitHub Actions op?

Het helpt bij library-crates waarvan de invoer niet is veranderd. sccache kan geen crates cachen die de linker aanroepen (bin-, dylib-, cdylib- en proc-macro-crates), en elke hit is een download uit zijn cacheopslag. Een target/ die tussen jobs bewaard blijft, heeft geen download nodig: een crate die Cargo als ongewijzigd ziet, wordt helemaal niet gecompileerd.

### Moet ik mijn workflow wijzigen om target/ op Skipbox te bewaren?

Nee. Wijzig runs-on in skipbox en laat rust-cache en actions/checkout zoals ze zijn. Je dedicated machine bewaart de checkout en target/ van Cargo tussen jobs, en de clean van checkout laat de target/-mappen met rust. Als de save van rust-cache je crates uit target/ verwijdert, zet de machine ze terug, en zijn restore schrijft geen oudere artifacts meer over nieuwere heen. Dus vanaf de eerste warme run worden crates die niet zijn veranderd niet gecompileerd.

### Hoeveel kost het om te proberen?

Niets. De proefperiode is 7 dagen of 3.000 jobminuten, wat het eerst komt, zonder kaart. Zet je Rust-job op runs-on: skipbox, draai hem twee keer, en vergelijk de Compiling-regels en buildsteps van de tweede run met die van GitHub.

Bijgewerkt op 2026-11-19 · https://skipbox.dev/nl/guides/rust-cache-slow-rust-ci
