Cook Cloud · early access

One cache for every build in your repo.

cook is an open-source build system that puts Cargo, CMake, pnpm, codegen and the scripts/ directory into one dependency graph with one content-addressed cache. Cook Cloud shares that cache with your whole team and CI, and explains every miss.

Get early access
$curl -fsSL https://getcook.sh | sh
$ cook ship
✓ @cap/env#build          hit   team cache · 12ms
✓ @cap/web#build          hit   team cache · 31ms
✓ rust-bins               hit   team cache · 48ms
● sprite-sheet            run   images/enemy.svg changed
✓ sprite-sheet            done  1.1s · pushed to team cache

4 units · 3 restored · 1 rebuilt · 1.2s total

$ cook why rust-bins
key   7f3a…c91e  hit
  rust:sources   1,204 files        unchanged
  seal compiler  rustc 1.93.0       unchanged
  built by ci-runner-04 · 2h ago · restored for 11 teammates

Receipts

Measured on real repos, not promised.

We added a Cookfile to two large open-source projects. Every number here is reproduced by a script in the public repo. Run it yourself.

Cap, a 20k-star pnpm monorepo with 11 Turbo tasks and 48 Rust crates. Two edits to @cap/env, which almost everything depends on.
EditTurborepocook
Add a comment7 of 11 tasks, ~47s1 task, ~1s
Add a real exportsame 7 tasks, ~47s2 tasks, ~30s

Why the gap is 47×

Turbo dirties every downstream task when a package's inputs change. cook keys downstream work on what it actually consumes. A comment that compiles away produces the same artifact, so everything downstream is a cache hit.

427nodes in the Doom 3 graph: compiler to playable map
1key per unit, built only from what you declared
0mystery misses: every one has a printed cause

How it works

Describe artifacts. Own the key. Share the store.

cook keeps the recipe ergonomics of just and the dependency graph of make, swaps macro-heavy configuration for a Lua-backed DSL, and runs exactly the work required by what changed.

1

Write a Cookfile

Each cook step declares a target. A per-input placeholder fans out, one unit per file, in parallel; a static target gathers. You never write the loop or the join.

recipe sprite-sheet
    gather "images/*.svg"
    cook "build/$<in.stem>.png" {
        rsvg-convert $<in> -o $<out>
    }
    cook "build/spritesheet.png" {
        magick montage $<in> -tile x1 $<out>
    }
2

You own the key

cook never quietly folds your machine, locale or toolchain into the cache key. Keys are reusable across machines by default. Need the compiler in the key? Say so.

tools compiler
    cc

recipe app
    gather "src/*.c"
    seal compiler
    cook "build/$<in.stem>.o" {
        cc -c $<in> -o $<out>
    }
3

Point the team at one store

Local cache and shared store use the same key. Start with a directory on a NAS. When you outgrow it, flip one flag and the same client talks to Cook Cloud.

# .cook/cloud.toml
[cloud]
enabled  = true
project  = "cap"
endpoint = "https://api.usecook.com"

# token comes from the environment, never the repo
export COOK_CLOUD_API_KEY=…

Cook Cloud

The shared cache your laptops and CI already know how to talk to.

The client ships in every cook binary today. Cook Cloud is the hosted store behind it: content-addressed artifacts, verified on every download, and the cook why story extended across your whole team.

Hosted artifact store

Content-addressed, deduplicated across projects, every artifact verified against its hash as it streams down. CI restores what a laptop built this morning, and vice versa.

Team-wide cook why

On a miss, see exactly which declared determinant differs between your key and the artifact a teammate cached. No more "works on my machine" archaeology.

Cache hit-rate and time saved

Per project, per recipe, per person. Know which recipes never hit and which determinant is the usual culprit. Fix the Cookfile, watch the number move.

Scoped API keys

Per-project tokens, read-only tokens for forks and PR builds, revocable instantly. Secrets live in the environment, never in the Cookfile.

Every ecosystem, one graph

cook_cc, cook_pnpm and cook_dotnet put native, JavaScript and .NET builds in one DAG. Cargo stays Cargo. Your codegen and asset pipelines join the same cache.

Bring your own store

The wire protocol is open and already in the client. Enterprise plans run the same store on your infrastructure, speaking the same five endpoints.

Pricing

cook is free forever. Pay for the shared cache.

Planned pricing. Nothing is billed during early access, and early-access teams keep their rate.
Free

Solo & open source

$0

The full build system, plus a small hosted cache for one project.

  • Everything in cook, Apache-2.0
  • 1 project · 5 GB cache
  • cook why on your machine
  • Community support
Join the list
Team

Teams & CI

$15 per seat / month

Share one cache across every laptop and runner. Stop paying for builds twice.

  • Unlimited projects · 250 GB included
  • CI runners don't count as seats
  • Team-wide cook why and hit-rate dashboards
  • Scoped and read-only API keys
  • Email support
Reserve seats
Enterprise

Your infrastructure

Custom

Run the store yourself, keep artifacts in your account, and let us write the first Cookfile.

  • Self-hosted store, same protocol
  • SSO / SAML, audit log
  • Migration from make, CMake, Turbo or Nx
  • SLA and a named engineer
Talk to us

Early access

Get on the list.

Tell us what you build with today. We onboard teams in the order they sign up, and we will reach out before anything is ever billed.