I rebuilt a mid-sized app last month expecting the usual: npm install, go make coffee, come back, wait for the bundler, question my career.
Instead the install finished before I'd stood up, and the production build that used to take ~40 seconds finished in about two.
Nothing about my code changed. The tools underneath it had been quietly swapped out for Rust, and I hadn't fully clocked how far it had gone. If you've been heads-down shipping, here's the state of the JS toolchain in 2026 — because the defaults have moved.
The quiet takeover
For a decade the JavaScript toolchain was… JavaScript, linting JavaScript, bundling JavaScript. That era is ending, fast:
| Job | Old default (JS) | 2026 default (Rust/Go) | Reported speedup |
|---|---|---|---|
| Bundling | Webpack / Rollup | Rolldown (powers Vite 8) | 10–30x vs Rollup |
| Lint + format | ESLint + Prettier | Biome | ~56x |
| Install | npm / yarn | Bun / pnpm | ~26x installs |
| Transpile / typecheck | Babel / tsc | Oxc / SWC, native TS | large |
Vite already sits at ~98% developer satisfaction, and Vite 8 moved its bundling to Rolldown (Rust) — so the most popular dev server in the world is now Rust underneath whether you opted in or not.
And the language story rhymes: TypeScript passed both Python and JavaScript to become the most-used language on GitHub in 2025. The ecosystem is consolidating on typed JS, built by Rust.
Why it's Rust, specifically
It's not fashion. It's the shape of the work. Linting, bundling, and parsing are:
- Embarrassingly parallel — every file can be processed at once, and Rust's fearless concurrency actually uses your cores
- Allocation-heavy in a GC language — a JS linter fights the garbage collector; a Rust one doesn't have one to fight
- Cold-start sensitive — a native binary starts instantly; a Node tool pays startup tax on every invocation
So the hot paths of your toolchain were the worst possible fit for JavaScript, and the best possible fit for Rust. The surprise isn't that it happened. It's that it took this long.
The honest downsides (because the benchmarks won't tell you)
I'm not going to sell you a frictionless migration. Real edges I hit:
- Plugin ecosystems don't teleport. Rolldown is Rollup-compatible-ish, but a niche Rollup/Webpack plugin you depend on may not have a home yet. Check your plugins before you celebrate.
- Biome doesn't cover every ESLint rule. If your team leans on exotic ESLint plugins, you'll either lose rules or run both — and running both erases the speed win.
- Error messages regressed, then recovered. Early Rust-tool errors were terser and less friendly than the JS tools' decade of polish. It's getting better, but budget for some "wait, what does this mean."
- "26x faster install" is a benchmark, not your Monday. Your real install is dominated by network and post-install scripts. You'll feel it, just not always at the headline multiple.
The pragmatic 2026 default
If you're starting something new and want the current fast path without living on the bleeding edge:
- Vite (8+) for the app — you get Rolldown for free
- Biome for lint + format if your rule set is mainstream; keep ESLint only for the plugins Biome can't replace yet
- Bun or pnpm for installs
- TypeScript, not plain JS — it's the baseline now, not the upgrade
You don't have to rewrite anything. You mostly have to notice that the defaults changed and stop reaching for the 2019 stack out of muscle memory.
The wild part is how invisible it all is. Your code is still TypeScript. Your framework still looks the same. But the machine turning it into a bundle is Rust now — and it's the least glamorous, most impactful upgrade the frontend's had in years.
What's still on your critical path that Rust hasn't eaten yet — and what broke when you tried to switch? Drop the tool that's still holding your build hostage. 👇
I write about building real things and the tools that make or break them. Follow me here if that's your lane. 👋
Top comments (0)