Rust Quietly Took Over JavaScript Tooling: A 2026 Map of What Replaced What

The day my CI pipeline went from 11 minutes to 90 seconds

Last month I migrated a 240K-line TypeScript monorepo from a Node-based toolchain — Webpack, ESLint, Prettier, Jest, tsc — to an almost entirely Rust-based one: Turbopack, Oxc, Biome, Vitest with Rolldown, and tsgo. CI fell from 11 minutes 14 seconds to 1 minute 28 seconds. Local dev startup went from 8.4 seconds to 0.6.

This is not an isolated number. It is the tail end of a quiet, three-year rewrite of the JavaScript toolchain in Rust and Go. As of mid-2026 the rewrite is mostly done. Here is the practical map for working developers.

What got replaced, by tool

The state of play, with what most teams should actually be running:

| Job | Old (Node) | New (Rust/Go) | Status May 2026 | |---|---|---|---| | Bundler (app) | Webpack, Rollup | Turbopack, Rspack, Rolldown | GA, ship it | | Bundler (lib) | Rollup, tsup | Rolldown, tsdown | GA, ship it | | Dev server | Vite (esbuild) | Vite 7 + Rolldown | GA, default | | Linter | ESLint | Biome 2, Oxlint | GA, ship it | | Formatter | Prettier | Biome 2 | GA, ship it | | Type checker | tsc | tsgo (Go), stc (Rust) | tsgo beta May 2026 | | Test runner | Jest, Vitest | Vitest + Rolldown | GA | | Package manager | npm, yarn | pnpm, Bun | GA | | Monorepo | Lerna, Nx (JS) | Turborepo, Nx (Rust core) | GA | | Minifier | Terser | swc, Oxc minify | GA |

If you are still on Webpack and ESLint in mid-2026, you are not behind in some abstract sense. You are paying real money in CI time and developer minutes every day.

The big four to know

Four tools dominate the new landscape. Knowing what each one is for clarifies the rest.

Oxc

Oxc is a Rust-based JavaScript and TypeScript toolchain from a small team led by Boshen. It includes a parser, linter (Oxlint), resolver, and minifier. Oxlint is roughly 50-100x faster than ESLint on equivalent rule sets. As of v1.0 in early 2026, it covers roughly 85% of common ESLint rules and runs as a drop-in pre-pass in many setups.

Biome

Biome 2 (released February 2026) is a Rust-based linter and formatter that aims to fully replace ESLint and Prettier. It is opinionated, fast, and trades off some ESLint plugin compatibility for coherence. For a greenfield project, Biome is the default I would pick. For an existing project, Oxlint is often easier to slot in alongside ESLint.

Rolldown and Turbopack

Rolldown is a Rust port of Rollup with Vite compatibility, now powering Vite 7 by default. Turbopack is Vercel's Rust bundler, the engine inside Next.js 15+. They are not really competitors: Rolldown is the universal library and app bundler, Turbopack is tightly integrated into Next.js dev and build.

For most Vite users, the migration to Rolldown is invisible — it just becomes the default. For Next.js users, Turbopack is now the default in dev and stable for production builds as of Next.js 15.4.

tsgo

tsgo is the Go rewrite of the TypeScript compiler that Microsoft began publicly previewing in March 2025 and which entered beta in early 2026. On large codebases, type checking is roughly 10x faster. It is not yet GA for production type checking but is increasingly safe for editor IntelliSense and CI parallel checks. The plan, per the official roadmap, is parity with tsc by late 2026.

Real performance numbers

On the same 240K-line monorepo, before and after migration:

• ESLint over the whole repo: 94s. Oxlint: 1.7s.
• Prettier check: 41s. Biome check: 0.9s.
• tsc full check: 76s. tsgo full check: 8s.
• Webpack production build: 6m 12s. Turbopack: 41s.
• Jest full suite: 3m 30s. Vitest with Rolldown: 1m 5s.
• Total CI: 11m 14s to 1m 28s.

The wins compound. Faster lint encourages stricter rules. Faster type checks encourage smaller, more incremental PRs. Faster builds enable preview deploys per commit instead of per merge. The cultural shift from these tools is at least as valuable as the raw seconds saved.

What to be careful about

A few traps I hit personally:

1. Biome plugin parity is not 100%. If you depend on niche ESLint plugins (eslint-plugin-jest-dom, custom internal plugins), audit before migrating. Oxlint is a softer landing because it can run alongside ESLint.
2. Rolldown breaking changes are still landing. It is GA in Vite 7 but expect occasional plugin incompatibilities through Q3 2026. Pin versions in libraries.
3. tsgo is beta. Use it for editor and CI parallel checks. Do not rely on it as your only type-check gate yet.
4. Bun vs Node in production. Bun is fast, but production parity with Node is still imperfect for some npm packages. We use pnpm in CI and Node in production, with Bun only in local scripts.
5. Editor extension lag. Some editor integrations — VS Code in particular — picked up Biome and Oxlint quickly, but JetBrains and Neovim plugins lagged by several months. If your team standardizes on a non-VSCode editor, check support before committing.
6. Source map fidelity. Rust bundlers have caught up but historically had subtle source map bugs that broke Sentry-style error reporting. Verify your error monitoring still works post-migration. We caught a 3-week window where stack traces were one line off after a Turbopack upgrade.

The migration we got wrong

Not every swap was painless. Our first attempt to move from Jest to Vitest broke 47 snapshot tests because Vitest's snapshot serialization differs subtly from Jest's. We accepted the new snapshots wholesale, which masked one real regression that customer support eventually surfaced. The lesson: when changing a test runner, do not accept a wave of snapshot changes blindly. Either migrate snapshots one suite at a time with manual review, or treat the first post-migration release with extra production monitoring.

The second mistake was migrating the linter and the formatter in the same week. When CI started failing differently, we could not isolate which tool was at fault. Stagger toolchain swaps. One change per week, ideally one per fortnight, with a clean baseline between them.

Why Rust won the tooling layer

Rust did not win because of language ideology. It won because three properties matched the work:

1. Predictable performance with no GC pauses, which matters for incremental tooling that runs on every keystroke.
2. Strong concurrency primitives that map well to multi-core lint and build work.
3. A coherent ecosystem (swc, oxc, biome) where teams build on each other's parsers and ASTs.

Go has carved out a parallel niche, mostly via Microsoft picking it for tsgo because of its ecosystem fit at Microsoft. The future is plural: Rust dominates the broader tooling, Go owns the type checker, and JavaScript itself remains the language we write.

The interesting open question is what happens to authoring. So far the rewrite has been about tools that operate on JavaScript, not the language itself. But TypeScript 6, expected later in 2026, will ship with the tsgo runtime as the default in some configurations, which means even the language tooling we touch every day will have a non-JavaScript core. Five years ago that would have felt strange. In 2026 it feels obviously correct.

The ecosystem cost of speed

One concern worth voicing: the Rust toolchain, while faster, is harder for casual contributors to extend. ESLint plugins are JavaScript files anyone can write. Oxlint and Biome rules require Rust knowledge, and the contributor pool is smaller. Long-term, this could slow down the rate of new rule innovation in linters specifically. The maintainers are aware of this and both Oxc and Biome are working on plugin systems that allow JavaScript extensions, but neither is fully landed as of May 2026.

This is a real trade-off, not a deal-breaker. Most teams use a small, stable set of rules and benefit from the speed far more than they suffer from harder-to-write plugins. But if your codebase depends on dozens of niche or in-house ESLint rules, weigh the migration cost honestly.

What this means for you

A practical 2026 migration order for an existing JS/TS project:

1. Replace Prettier with Biome formatter. Lowest risk, instant win.
2. Add Oxlint as a pre-pass alongside ESLint. Catch the easy stuff fast.
3. Move to Vite 7 (or stay on it; Rolldown is now under the hood).
4. Adopt Vitest if you are still on Jest.
5. Try Turbopack if you are on Next.js 15+.
6. Add tsgo for editor and CI parallel type checks; keep tsc as the gate.
7. Evaluate full Biome (linter + formatter) and full Oxlint replacement once your plugin audit allows.

The era of "JavaScript tooling written in JavaScript" is ending not because of fashion but because the math no longer favors it. The Rust toolchain is faster, more reliable, and increasingly easier to adopt. The good news is that for most application developers, this migration is not a rewrite. It is a series of small, low-risk swaps that quietly hand back hours of your week.

FAQ