Why we rewrote our build pipeline in Rust

Eighteen months ago we were staring at a 47-second cold build time on a repository with 180,000 lines of TypeScript. The business cost was real: every developer lost roughly 40 minutes per day waiting. The opportunity cost was worse — people stopped iterating as freely because the feedback loop felt punishing.

The case for Rust (and against it)

We did not jump straight to Rust. We spent three months trying to make the existing TypeScript build faster. We moved to esbuild, then to Vite, then to a custom bundler written in Go. Each helped, but none got us below 12 seconds. The problem was not the bundler — it was the type-checking pass, which had to run the full TypeScript compiler over the entire graph.

The decision to rewrite in Rust came down to a single constraint: we needed a type-checker that could cache aggressively and run incremental checks in under 100ms. No existing tool did this. We had to build it.

What we got wrong on the first try

Our first attempt failed for a reason that should have been obvious in retrospect: we tried to replicate TypeScript semantics exactly. TypeScript's type system is famously unsound — it has intentional holes, structural subtyping, and decades of pragmatic design decisions that make it both powerful and unpredictable to reimplement.

We spent six weeks building a type checker that passed 94% of our test suite. That last 6% took another four months and nearly killed the project.

The breakthrough came when we stopped trying to be a full TypeScript compiler and instead became a fast path validator. We check the 80% of TypeScript patterns that appear in our codebase, and fall back to the official compiler for the long tail.

The patterns that stuck

Three architectural patterns made the Rust rewrite viable:

• Content-addressed caching — every compilation unit is keyed by the hash of its source and its dependency hashes. Cache hits are nanoseconds.
• Incremental dependency graphs — we only recheck files whose transitive dependency hash changed, not everything that imported a changed file.
• Parallel type inference — functions without cross-module dependencies are typed concurrently across all available cores.

The result: 47 seconds to 4.2 seconds on a cold build. 800ms on an incremental build. We have been running this in production for eight months and have not had a correctness regression.