Rust ate.
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 Vite | Before Vite 8 | Vite 8 (2026-03) on |
|---|---|---|
| Transform TS, JSX | esbuild | Oxc |
| Pre-bundle node_modules when the dev server starts | esbuild | Rolldown |
| Production build | Rollup | Rolldown |
What each framework uses by default: Vite, except Next.js
Almost every framework defaults to Vite, and only Next.js uses its own Turbopack.
| Framework | Default build tool |
|---|---|
| Next.js | Turbopack (default for dev and build since v16; add --webpack to use webpack) |
| Remix | Vite (stable since v2.7.0, 2024) |
| React Router v7 | Vite (framework mode; Remix merged into it) |
| Vue (create-vue) | Vite (Evan You made both) |
| Nuxt | Vite (webpack / rspack optional) |
| SvelteKit | Vite |
| Astro | Vite |
| Angular (v17+) | esbuild for the build, Vite for the dev server |
| SolidStart | Vite (via Vinxi) |
| Qwik | Vite |
| Create React App | webpack + 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:
| Setup | Strip types (TS→JS) | Type check | You run |
|---|---|---|---|
| Next.js | SWC, built in | next build runs tsc for you | nothing |
| Vite | built in; esbuild originally, Oxc since Vite 8 (2026-03) | not included | tsc --noEmit (Vue projects often use vue-tsc -b && vite build) |
| Bun | built in | not 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 default | tsc --noEmit originally, now bun check works too |
| Babel + Webpack (old me) | @babel/preset-typescript | not included | tsc --noEmit separately |
| Just tsc (small lib) | tsc | tsc, same run | tsc, 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
- SWC author DongYoon Kang (kdy1): https://github.com/kdy1
- SWC 20–70x faster than Babel: https://swc.rs/
- Next.js 12 defaults to SWC (2021-10): https://nextjs.org/blog/next-12
- DongYoon Kang joins Vercel (Next 11.1, 2021-08): https://nextjs.org/blog/next-11-1
- Turbopack (Tobias Koppers / Vercel / Rust / SWC): https://vercel.com/blog/turbopack
- Turbopack stable for
next dev(Next 15, 2024-10): https://nextjs.org/blog/next-15 - Turbopack default for builds (Next 16, 2025-10): https://nextjs.org/blog/next-16
- esbuild (Go, Evan Wallace): https://esbuild.github.io/
- Vite (dev=esbuild, prod=Rollup): https://vite.dev/guide/why
- Rolldown (Rust port of Rollup): https://voidzero.dev/posts/announcing-rolldown-1-0
- Vite 8 defaults to Rolldown (2026-03): https://vite.dev/blog/announcing-vite8
- Vite 8 replaces esbuild with Oxc and Rolldown: https://vite.dev/guide/migration
- Bun 1.4.3
bun check(2026-10): https://bun.com/blog/bun-v1.4.3 - SWC minify default in Next.js (since v13): https://nextjs.org/docs/architecture/nextjs-compiler
- Fast tools don't type-check, you need tsc: https://esbuild.github.io/content-types/
- Bun 1.0 (2023-09): https://bun.com/blog/bun-v1.0
- Bun core Zig → Rust (PR #30412, 2026-05): https://www.theregister.com/devops/2026/05/14/anthropics-bun-rust-rewrite-merged-at-speed-of-ai/ (current language breakdown confirmed via GitHub's language stats: https://api.github.com/repos/oven-sh/bun/languages)
- Oxc: https://oxc.rs/
- Build tool benchmarks (many tools, maintained by the Rspack team): https://github.com/rstackjs/build-tools-performance
- Remix goes Vite (v2.7.0): https://remix.run/blog/remix-vite-stable
- React Router v7 modes (framework mode = Vite): https://reactrouter.com/start/modes
- Vue create-vue (Vite): https://github.com/vuejs/create-vue
- Nuxt default builder (Vite): https://nuxt.com/docs/getting-started/introduction
- SvelteKit on Vite: https://svelte.dev/docs/kit/introduction
- Astro on Vite (Astro 6): https://astro.build/blog/astro-6/
- Angular build system (esbuild + Vite): https://angular.dev/tools/cli/build-system-migration
- SolidStart (Vite via Vinxi): https://docs.solidjs.com/solid-start/getting-started
- Qwik on Vite: https://qwik.dev/docs/advanced/vite/
- Create React App deprecated (2025-02): https://react.dev/blog/2025/02/14/sunsetting-create-react-app