Rust ate.

frontendbuild-toolsbundlertransformerrustvitenextjs

I started learning frontend in 2018. Back then people were still fighting over React vs Vue vs Angular, each with its own fans.

The framework itself was fine, since the official docs cover how to write and assemble your HTML. The annoying part was the pile of build config underneath: the webpack config, one loader after another, figuring out which babel presets to add. Learning frontend back then was mostly reading official docs, and the moment some special loader showed up you'd start over. So annoying. Oh, and plugins, install as needed.

Then Next.js showed up. It wrapped that whole layer. No more webpack config, no more ordering loaders, create-next-app and it just runs. So good. From then on build was a black box to me, and I avoided touching it whenever I could.

Until SWC and Turbopack started showing up all over Next.js ecosystem articles, and I figured maybe I should actually sort out how this whole thing evolved. You can't let Next.js hand you a worry-free life and then just... live worry-free forever.

build (next build, or whatever build) has three roles

And they're exactly the three things I used to configure by hand:

  • parse + transform: turn my TS / JSX into JS the browser can run. Used to be Babel.
  • bundle: resolve all the imports, walk the graph, stitch it into a few files. Used to be Webpack.
  • minify: shrink the output. Used to be Terser.

The few years I wasn't watching the black box, all three became Rust LOL.

From Button.tsx to app.382f3f.js

From Button.tsx to the shipped file, it goes through:

Button.tsx
  │  parse + transform     (SWC / esbuild / Oxc / Babel)
  │  strip TS types, JSX → JS, lower new syntax
  ▼
Button.js   (plain JS, no types)
  │  bundle                (Turbopack / Vite / Rolldown)
  │  follow imports, walk the dep graph, merge
  ▼
one big module graph
  │  minify                (SWC / esbuild / oxc / terser)
  │  strip whitespace, rename vars, drop dead code
  ▼
app.382f3f.js    ← 382f3f is a content hash, for cache-busting

(off to the side, NOT in this pipeline)
tsc --noEmit  →  checks types, emits nothing

The 382f3f is a hash computed from the file's contents. Change the code and the hash changes, so the filename changes, so the browser downloads the new file instead of using the old cached one.

parse + transform: SWC

SWC's author is a Korean developer, DongYoon Kang, known online as kdy1, nicknamed Donny. He started writing this Babel alternative in Rust as early as 2017. It does the same parse + transform, only multi-threaded by default. The gap between 20x and 70x is core count: their own claim is 20x faster than Babel on a single thread, 70x on four cores.

In August 2021 the Next.js 11.1 announcement mentioned that Kang had joined Vercel; just two months later, Next.js 12 swapped the default Babel for SWC.

bundle: Turbopack

Turbopack was written by Webpack's author, Tobias Koppers, who's also at Vercel now. So the original author wrote webpack's successor himself, in Rust, and built it directly on SWC. Turbopack for next dev went stable in Next.js 15 (October 2024), and since Next.js 16 (October 2025) it's the default for next build too. To keep using webpack, add --webpack.

minify: SWC again

Since v13, Next.js even does minification with SWC by default. Those minify settings I used to tweak to save a few KB, the framework just decides for me now.

Oh, and Vite's everywhere now

Vite (2020) uses esbuild for dev (that one's written in Go, by Figma's Evan Wallace) and Rollup for the production build. Rollup later got rewritten in Rust as Rolldown, and Vite 8 (March 2026) ships it as the default. The esbuild it used during development was replaced too:

Job inside ViteBefore Vite 8Vite 8 (2026-03) on
Transform TS, JSXesbuildOxc
Pre-bundle node_modules when the dev server startsesbuildRolldown
Production buildRollupRolldown

What each framework uses by default: Vite, except Next.js

Almost every framework defaults to Vite, and only Next.js uses its own Turbopack.

FrameworkDefault build tool
Next.jsTurbopack (default for dev and build since v16; add --webpack to use webpack)
RemixVite (stable since v2.7.0, 2024)
React Router v7Vite (framework mode; Remix merged into it)
Vue (create-vue)Vite (Evan You made both)
NuxtVite (webpack / rspack optional)
SvelteKitVite
AstroVite
Angular (v17+)esbuild for the build, Vite for the dev server
SolidStartVite (via Vinxi)
QwikVite
Create React Appwebpack + Babel, deprecated in 2025, now points you at Vite / Parcel / Rsbuild

Angular is different: it builds with esbuild and serves with Vite. Earlier I said Vite used esbuild for dev before Vite 8; that's esbuild inside Vite. Angular takes only Vite's dev server and calls esbuild directly for the build instead of Vite's Rollup, so here the two are separate pieces side by side. And no, Next.js + Vite was never a thing, Next ships its own bundlers only. Turbopack and Parcel were never combined either; separate projects that don't touch.

Everyone plugs into Vite, probably because it isn't tied to any particular framework.

What about benchmarks?

By 2026 these tools are all fast enough that speed isn't the main reason to pick one; ecosystem, compatibility and maintenance matter more. And most of these benchmarks are published by one tool's own team, so check who made them before reading the numbers. To look at the numbers yourself:

  • rstackjs/build-tools-performance: the most comprehensive, regularly updated comparison (Rspack, Vite, Rolldown, esbuild, webpack, Rollup, Parcel, Farm). Maintained by the Rspack team.
  • esbuild's own benchmark: esbuild vs webpack / Rollup / Parcel. Esbuild-favorable; the test setup is described in the FAQ, so you can check it (three.js ×10: esbuild 0.39s, Parcel 14.9s, Rollup+Terser 34.1s, webpack 41.2s).

Vite itself is rarely measured on its own, because it hands transforming and bundling to the tools in the table above.

Babel handles TypeScript, so why run tsc too?

Looking at project setups back then, something always felt off, and I couldn't say what: Babel already handles TypeScript, so why is there a tsc hanging around next to it?

Put simply, stripping types and checking types are two different jobs:

  • Strip types (TS → JS): turn TS into JS that runs, dropping the types. Babel, SWC, esbuild and Oxc all do this.
  • Check types: verify the types are correct. For a long time only tsc did this, until Bun shipped its own type checker, bun check, in October 2026. It doesn't run by default, though.

So if your setup doesn't include type checking, you have to run tsc separately yourself:

SetupStrip types (TS→JS)Type checkYou run
Next.jsSWC, built innext build runs tsc for younothing
Vitebuilt in; esbuild originally, Oxc since Vite 8 (2026-03)not includedtsc --noEmit (Vue projects often use vue-tsc -b && vite build)
Bunbuilt innot included at first; since v1.4.3 (2026-10) there's bun check, and run, build and test take --check, but it's off by defaulttsc --noEmit originally, now bun check works too
Babel + Webpack (old me)@babel/preset-typescriptnot includedtsc --noEmit separately
Just tsc (small lib)tsctsc, same runtsc, does both, but no bundling

tsc on its own does two jobs, it type-checks and emits .js. tsc --noEmit is the same check with the output turned off. Modern setups use --noEmit because a faster tool already produced the .js; only tsc's check is needed, not its slower output.

Next.js is the one that spoils you: it wraps all of it, so you just see next build :)

then Bun

Bun is another runtime going head to head with Node. It started out written in a language called Zig, and hit 1.0 in 2023. And it's now migrating from Zig to Rust itself, with the rewritten core merged into main in May 2026.

then

There's a project called Oxc, by Boshen, taking it a step further: instead of every tool parsing the source over again, parse once and share a single AST. Parser, linter (oxlint), and transformer are already out, and Rolldown already uses Oxc's parser underneath. If it works, today's situation of SWC and Oxc each having their own parser might someday get unified again.

The chronicle

~2015    Babel + Webpack + Terser era (JS processing JS)
2017     SWC started (DongYoon Kang), nobody using it yet
2018     Terser replaces UglifyJS as default minifier
2020     esbuild (Go) appears; Vite appears (dev=esbuild, prod=Rollup)
2021-08  Kang joins Vercel (Next 11.1)
2021-10  Next.js 12: SWC replaces Babel
2022     SWC minify lands in Next (default in v13)
2023-09  Bun 1.0 (still Zig back then)
2023-10  Rolldown announced (Rust port of Rollup)
2024-02  Remix goes Vite
2024-10  Next.js 15: Turbopack stable for next dev
2025-02  Create React App deprecated
2025-10  Next.js 16: Turbopack the default for builds too
2026-03  Vite 8: Rolldown as default, esbuild replaced by Oxc + Rolldown
2026-05  Bun's core goes Zig → Rust
2026-10  Bun 1.4.3: built-in type checker, bun check

So

What actually happened inside that black box? The whole layer moved from JavaScript to native binaries, got redesigned, and started using multiple cores, so it got a lot faster. Where the speed comes from, and how much each part contributes, is measured in another post.

As for whether "Rust is faster" is actually true, I ran a benchmark to see. Sometimes it was a tie, twice Node actually won, but mostly Rust was around three times faster. The 20-70x figures on SWC's site turned out, when measured, to come mostly from four cores and two differently-built programs, not the Rust language. The whole thing, with every chart, is its own post: How much faster is Rust than Node? I measured seven scenarios. Each reason measured on its own is here: Rust vs V8.

References