Why your build tool has amnesia — and how we fixed it with a persistent graph and CAS

#webdev #rust #javascript #react

Every few years, the frontend community rallies around a faster build tool.
Grunt gave way to Webpack. Webpack gave way to Parcel, then Rollup, then Vite. Each one measurably faster. Each one celebrated. And yet, there's a problem none of them ever touched: they all start from zero, every single time.

This isn't a performance problem. It's an architectural one.

The real issue: stateless pipelines

When a build process exits — whether that's a dev server restart, a CI run, or a branch switch — everything it computed disappears. The dependency graph it built? Gone. The transforms it ran? Gone. The structural knowledge of your project it accumulated? Gone.

We call this Past Amnesia. And on large projects, it's brutally expensive.

On a large-scale with 25,000+ dependencies, a cold start with today's best tools can cost 40–90 seconds. even vite-8 cost build 2.4 seconds. Not because the machine is slow. Because the tool is reprocessing modules it already analyzed last run, last hour, last week — with no memory of what it already knew.

What we built: Ionify
Ionify is a Rust-powered build engine that approaches this differently. Instead of optimizing the stateless runner, we built a persistent engine.

Persistent Dependency Graph
Module relationships are stored and survive process restarts. When you change a file, the engine re-enters the graph at the changed node — not at zero.

Content-Addressable Storage (CAS)
Every transformed module is stored by the hash of its input. If the input hasn't changed — across restarts, across branches, across machines — the transform is never repeated. The result is retrieved instantly.

Dual-hash isolation
A versionHash ties your graph and CAS to your current configuration. A depsHash partitions optimized dependencies so a single library update doesn't invalidate everything else.

Hybrid transform engine
OXC handles the fast path. SWC provides a resilience fallback.Same pipeline, both engines, no ecosystem compromises.

Unified dev + prod
Same engine, same semantics across both environments. The "works in dev, breaks in prod" class of bugs disappears by design.

The result
sub-100ms warm rebuilds on projects with 11,000+ internal modules. Not a benchmark trick — the natural outcome of a system that stops repeating work it already did.

Why this matters in 2026
Everyone is talking about AI-assisted development. AI generates code in seconds. But if your build pipeline costs 40 seconds every restart, you haven't solved the bottleneck — you've just moved it.

Ionify is the infrastructure layer that lets the rest of your toolchain actually compound. A build engine that gets smarter with every run, instead of forgetting everything when the process exits

Try it