Rspack vs Vite vs Turbopack: Build Speed Benchmarks Compared

Vite vs Turbopack vs Rspack is the defining build-tool comparison of 2026. Vite 8 replaced its entire bundling pipeline with the Rust-based Rolldown engine, Rspack hit version 2.0 with modern defaults and React Compiler support, and Turbopack became the default bundler for both development and production builds in Next.js 16. I pulled together benchmark data from official sources, independent tests, and the numbers these projects publish on their own homepages to answer the question every frontend team is asking: which one actually wins?

• Rspack wins cold dev startup at 1.36s versus Vite's 6.50s — a 4.8x gap that matters most on large monorepos.
• Vite 8 wins production builds thanks to Rolldown, with real-world reports of 7–13x faster bundling versus Vite 7's Rollup path.
• Turbopack is Next.js-only — Next.js 16 (October 2025) made it stable and the default for both next dev and next build, but you can't use it outside Next.js.
• Rspack and Rolldown are complements, not competitors — Rspack speaks the webpack API, Rolldown speaks the Rollup API, and they target completely different migration paths.
• Vite is the safest default for new projects in 2026, with ~130 million weekly npm downloads and the broadest framework support.

Pick your build tool by what you're migrating FROM, not what benchmarks fastest in isolation.

The 2026 Build Tool Landscape: Vite vs Turbopack vs Rspack

Three developments made older JavaScript build tool comparisons obsolete.

The key difference in rspack vs vite is migration path: Rspack targets the webpack API, while Vite 8 targets the Rollup API via Rust-based Rolldown. In benchmarks, Rspack wins cold dev startup at 1.36s vs Vite’s 6.50s, but Vite 8 wins production builds (Rolldown 1.61s for 19,000 modules vs Rspack 4.07s). Vite is also the safest 2026 default with broad framework support.

Turbopack vs Vite: they rarely compete for the same project. Turbopack runs only inside Next.js, where it has been the default bundler for both next dev and next build since Next.js 16 (October 2025). Vite 8, which moved to the Rust-based Rolldown bundler in March 2026, is the framework-agnostic default for React, Vue, Svelte and Solid apps. Building a Next.js app? Use Turbopack. Anything else? Start with Vite.

First, Vite 8 shipped on March 12, 2026. It gutted both esbuild (used for dev transforms) and Rollup (used for production bundling) and replaced them with a single Rust-based bundler called Rolldown, plus Oxc for TypeScript and JSX transforms. This eliminated Vite's historic split personality — one engine for dev, another for prod — and collapsed everything into a unified Rust pipeline.

Second, Rspack 2.0 landed on April 22, 2026, followed by Rspack 2.1 on June 26. The Rspack Team at ByteDance shipped modern defaults, a cleaner API surface, and — critically — support for the Rust-based React Compiler. Rspack 2.1 also added import.meta.glob and Source Phase Imports, closing feature gaps that had kept Vite-native developers away.

Third, Turbopack finished the job. As Maia Teegarden, Tim Neutkens, and Tobias Koppers announced in October 2024, Turbopack dev went stable in Next.js 15. Next.js 16 (October 2025) then made Turbopack stable for production builds and the default bundler for new apps, with file-system caching for next dev in beta; Next.js 16.1 (December 2025) made that dev cache stable and on by default. It still runs only inside Next.js.

Meanwhile, Andrés Clúa reported that Vite has approximately 130 million weekly npm downloads, and Cloudflare invested in VoidZero — the company behind Vite, Rolldown, and Oxc. The ecosystem momentum is overwhelmingly in Vite's direction.

If you're coming from our Astro vs Next.js or Cloudflare Workers vs Vercel comparisons, this post picks up where framework choice ends and build infrastructure begins.

Benchmark Results at a Glance: The Comparison Table

Before diving into methodology and nuance, here's the head-to-head summary. These numbers come from Rspack's official homepage benchmark (large app with thousands of modules) and the Rolldown.rs benchmark (19,000 modules):

*Turbopack numbers are relative percentages reported by Vercel on their own codebase (vercel.com), not absolute times on a standardized benchmark. Direct apples-to-apples comparison is not possible.

The table tells a clear story. Rspack dominates cold dev startup. Vite wins HMR and production builds. Turbopack is fast inside Next.js but unavailable anywhere else. And webpack 5 is dramatically slower than all three Rust-based alternatives.

What Is Vite 8? Rolldown Replaced esbuild and Rollup

Vite (French for "fast") started in 2020 as Evan You's answer to webpack's slow dev server. Its original trick was clever: use the browser's native ES modules during development (no bundling needed) and only bundle for production using Rollup. For dev-time TypeScript and JSX transforms, it used esbuild.

This two-engine approach worked well but created a fundamental problem. Code that behaved one way in dev could behave differently in production because two completely different tools were processing it. Plugin authors had to account for both engines. And production build speed was bottlenecked by Rollup, which is written in JavaScript.

Vite 8 fixed this by replacing both engines with Rolldown — a Rust-based bundler with Rollup-compatible APIs and esbuild feature parity. As Vishwajeet Kondi documented, VoidZero also integrated Oxc (a Rust-based parser and transformer) to handle TypeScript and JSX.

The practical impact lands almost entirely on production builds. According to the benchmark published by var.gg, Linear cut its production build from 46 seconds to 6 seconds after upgrading to Vite 8. Vite's own documentation claims 10–30x faster builds versus the old Rollup path, though larger real-world projects tend to report 3x–8x improvements.

The Rolldown.rs benchmark tells the same story with precision: bundling 19,000 modules (10k React JSX components + 9k iconify JS files, with minification and source maps), Rolldown finishes in 1.61 seconds. That's faster than esbuild (1.70s), Rspack (4.07s), and dramatically faster than the old Rollup + esbuild pipeline (40.10s). That's a 24.9x improvement over the previous Vite production path.

The dev server experience? Largely unchanged. HMR still feels instant. The real win is that dev and prod now run on the same engine, eliminating the behavioral inconsistencies that plagued Vite for five years.

If you've been tracking Rust's takeover of JavaScript tooling, Vite 8 is the biggest single proof point. The pattern is consistent: every core JS tool rewritten in Rust produces a speed jump large enough to make the old version look broken.

If you care about the broader “native compiler” trend beyond bundlers, I ran a similar apples-to-apples performance recipe for TypeScript in TypeScript 7 Native Compiler Benchmark: My TS6 vs TS7 Recipe [2026]. It’s a good companion read when you’re trying to separate toolchain hype from measurable CI and edit-compile gains.

What Is Turbopack? And What It Still Can't Do

Turbopack is Vercel's Rust-based successor to webpack, built by Tobias Koppers — the original creator of webpack. It was announced in October 2022 with bold claims about being 700x faster than webpack and 10x faster than Vite. Those specific claims have been walked back, but the core technology is real.

Here's what Turbopack delivers as of Next.js 16:

• Dev server inside Next.js 15+: stable. Up to 76.7% faster local server startup, 96.3% faster Fast Refresh (HMR), and 45.8% faster initial route compilation compared to webpack — all measured on Vercel's own codebase.
• Production builds: stable since Next.js 16 (October 2025), which made Turbopack the default for next build. Vercel cites 2–5x faster production builds than webpack; apps with custom webpack setups can opt out with next build --webpack.
• Disk caching: stable for dev. Next.js 16 shipped file-system caching for next dev in beta, and Next.js 16.1 (December 2025) made it stable and on by default; caching for next build is still being stabilized. Rspack shipped incremental builds enabled by default back in June 2025 (v1.4).
• Framework support: Next.js only. You cannot use Turbopack with React (outside Next.js), Vue, Svelte, Solid, or any other framework.

This is a critical distinction that most comparison articles bury. Turbopack is a bundler for Next.js, not a general-purpose build tool. If you're evaluating build tools for a Vue app, a Svelte project, a component library, or anything outside the Next.js ecosystem, Turbopack is not an option.

The vendor lock-in question is real. Turbopack is developed by Vercel, for Vercel's framework, deployed on Vercel's platform. If you're comfortable with that stack, the dev experience is genuinely excellent. If you want optionality, look elsewhere.

What Is Rspack 2.0? The Webpack Successor You Probably Missed

Rspack is ByteDance's Rust-based webpack replacement. Unlike Turbopack (which shares webpack's creator but not its API), Rspack is explicitly designed as a webpack-compatible drop-in replacement. Your existing webpack config, plugins, and loaders work with minimal changes.

The Rspack Team shipped two major releases in 2026:

Rspack 2.0 (April 22, 2026) introduced modern defaults — ES2017+ output by default, a cleaner API surface, and optimized build outputs. It's a breaking change from 1.x, but the migration path is well-documented.

Rspack 2.1 (June 26, 2026) added the Rust-based React Compiler, import.meta.glob (a feature Vite users have had for years), Source Phase Imports, persistent cache cleanup, and multiple performance optimizations.

The benchmark numbers from Rspack's own homepage are striking:

• Dev startup: 1.36s (vs Vite's 6.50s — that's 4.8x faster)
• Production build: 3.35s (vs Vite's 1.98s — Vite still wins here)
• HMR: 160ms (vs Vite's 130ms — Vite wins by a narrow margin)

Rspack's dev cold start advantage comes from its architecture. While Vite relies on the browser's native ESM imports during dev (which means the browser makes hundreds or thousands of individual HTTP requests on first load), Rspack bundles everything upfront using parallel Rust compilation. On small projects, Vite's approach is faster. On large monorepos with thousands of modules, Rspack's approach scales better.

For teams running large webpack codebases — especially at companies like ByteDance, which uses Rspack across hundreds of internal projects — the migration story is compelling. You keep your webpack ecosystem investment while getting Rust-level build speeds.

Rspack also released next-rspack in April 2025, a community-driven plugin bringing Rspack support to Next.js as a webpack-compatible alternative. This gives Next.js teams a third option: Turbopack (the default), webpack (opt-out), or Rspack (webpack-compatible).

Rspack vs Rolldown: What's the Difference?

This is one of the most confused comparisons in the JavaScript ecosystem right now, and it's the question I see most often in search queries. Rspack and Rolldown are both Rust-based bundlers, but they have fundamentally different design goals.

Rspack speaks the webpack API. It's designed for teams migrating from webpack who want to keep their existing configs, plugins, and loaders. Think of it as "webpack, rewritten in Rust."

Rolldown speaks the Rollup API. It's designed as the bundler powering Vite 8+, compatible with the Rollup plugin ecosystem. Think of it as "Rollup, rewritten in Rust."

They are not competing. They target completely different migration paths:

If you're migrating FROM webpack, Rspack is your path. If you're migrating FROM Rollup or already using Vite, Rolldown is already working for you inside Vite 8. If you're starting fresh with no legacy, Vite (powered by Rolldown) is the default choice for most teams.

Based on the benchmark data I maintain at kunalganglani.com/llm-benchmarks, I've learned that vendor benchmarks always need context — the same way LLM benchmarks vary wildly depending on what you measure. Build tool benchmarks are no different. Rspack's homepage benchmark uses a large-app scenario that favors its bundling approach. Rolldown's benchmark uses a 19k-module synthetic test. Neither is wrong, but neither tells the whole story for your specific project.

That same instinct to benchmark rather than trust vendor claims is what led me to document Openrig: Build a 3-Agent Claude Code + Codex Network, where I wired up Claude Code, Codex CLI, and a Pi node and measured what the coordination actually costs in practice.

Cold Start Speed: Where Rspack Dominates

Cold start — the time from npm run dev to seeing your app in the browser — is where Rspack has its biggest advantage.

Rspack's architecture bundles everything upfront on the server side using parallel Rust compilation. The result: 1.36 seconds for a large app. Vite's native ESM approach takes 6.50 seconds on the same benchmark because the browser must request and process hundreds of individual modules.

Turbopack claims up to 76.7% faster cold starts than webpack on Vercel's codebase. If we apply that to webpack's 21.40s benchmark time, that suggests roughly 5 seconds — somewhere between Rspack and Vite. But Vercel hasn't published absolute cold start numbers on a standardized benchmark, so direct comparison is impossible.

Here's when cold start actually matters: if you're restarting your dev server multiple times per day (switching branches, clearing caches, rebooting after config changes), that 5-second difference between Rspack and Vite adds up. If you start your dev server once in the morning and leave it running, HMR speed matters far more.

For large webpack monorepos where cold starts currently take 20+ seconds, Rspack's 1.36s is transformative. That's a 15.7x improvement with webpack API compatibility.

HMR Speed: Vite's Quiet Strength

Hot Module Replacement (HMR) — the time between saving a file and seeing the change reflected in your browser — is where developers spend 90% of their build-tool interaction time. A 200ms HMR feels instant. A 500ms HMR feels sluggish. Anything over 1 second breaks flow state.

Vite: 130ms. Rspack: 160ms. webpack: 2,780ms.

The gap between Vite and Rspack on HMR is narrow enough to be irrelevant in practice — both feel instant. The gap between either Rust-based tool and webpack is enormous. If you're still on webpack, switching to either Vite or Rspack will feel like upgrading from dial-up to fiber.

Turbopack claims up to 96.3% faster Fast Refresh than webpack on Vercel's codebase. Applying that to webpack's 2,780ms gives roughly 103ms — which would be the fastest of the three. But again, this is a relative claim on a specific codebase, not a standardized benchmark. In practice, all three Rust-accelerated tools deliver sub-200ms HMR, which is functionally instant.

The real HMR differentiator isn't speed — it's consistency. Vite's HMR has been battle-tested across millions of projects. Rspack's HMR benefits from incremental builds enabled by default since v1.4. Turbopack's HMR is fast, and since Next.js 16.1 its dev file-system cache is on by default, so restarts reuse earlier compilation work instead of starting cold.

Production Build Speed: Vite 8's Breakthrough

This is where Vite 8's Rolldown engine makes the biggest real-world difference.

The Rolldown benchmark tells the raw story: 19,000 modules bundled in 1.61 seconds with minification and source maps. For context, that same workload takes Rspack 4.07 seconds (2.5x slower) and the old Rollup + esbuild pipeline 40.10 seconds (24.9x slower).

Real-world production build improvements with Vite 8 vary by project size. Linear reportedly cut their production build from 46 seconds to 6 seconds — a 7.7x improvement. Vite's documentation claims 10–30x faster builds. Independent benchmarks from var.gg show 3x–8x on larger, more complex projects.

Rspack's production build at 3.35 seconds (on their benchmark) is respectable — still 8.4x faster than webpack's 28.10 seconds. For webpack migration scenarios, that's a massive win with near-zero config changes.

Turbopack does build for production now: Next.js 16 made it the default for next build, and Vercel reports 2–5x faster production builds than webpack. Vercel publishes relative gains on its own apps, not absolute times on a shared benchmark, so there is no number to set beside Rolldown's 1.61s or Rspack's 4.07s.

For CI/CD pipelines where build speed directly translates to developer productivity and infrastructure costs, Vite 8's Rolldown engine is the clear winner. A build that finishes in 6 seconds instead of 46 saves real money at scale.

Framework Support: Which Tool Works Where?

This is the decision matrix that no other comparison article provides. Your framework choice constrains which build tools are even available to you:

If you're building a Next.js app, your real choice is between Turbopack (the default since Next.js 16), webpack (opt-out via --webpack, slower), and Rspack via next-rspack (fast, webpack-compatible). Vite does not support Next.js.

If you're building anything else — a React SPA, a Vue app, a Svelte project, a component library — Vite is the default choice with the largest ecosystem. Rspack is the alternative if you have existing webpack infrastructure you can't abandon.

This framework lock-in is why I think Turbopack's positioning is increasingly awkward. It's tied to a single framework controlled by a single company. Vite and Rspack are both framework-agnostic, open-source, and usable anywhere. Similar dynamics played out in the vibe coding space — tools that lock you into one vendor's ecosystem create risk that compounds over time.

Webpack Migration: Rspack vs Vite for Legacy Projects

If you're sitting on a large webpack codebase and wondering which modern tool to migrate to, the answer depends on how much change you can absorb.

Choose Rspack if:

• You have a complex webpack config with custom plugins and loaders
• You need to migrate incrementally without rewriting build configuration
• Your team has deep webpack expertise
• You're running a Next.js app with a custom webpack config you can't move to Turbopack
• You want the fastest possible cold dev startup (1.36s vs 6.50s)

Choose Vite 8 if:

• You're willing to rewrite your build configuration from scratch
• You're starting a new project or doing a major refactor anyway
• You prioritize production build speed and HMR
• You want the largest plugin ecosystem (~130 million weekly npm downloads)
• You're using Vue, Svelte, or Solid (where Vite is the ecosystem standard)

Rspack's webpack compatibility isn't theoretical. ByteDance migrated hundreds of internal projects from webpack to Rspack. The Rspack Team maintains compatibility with the webpack plugin and loader ecosystem, and their 2.0 release modernized the defaults while keeping the migration path intact.

Rolldown (inside Vite 8) speaks the Rollup plugin API, which means your existing webpack plugins won't work. The migration is more of a rewrite than a swap. But Rolldown's Rollup compatibility means the massive Rollup plugin ecosystem transfers cleanly.

This is one of those things where the boring answer is actually the right one. Don't chase benchmarks — chase the migration path with the lowest risk for your specific codebase. Running this blog's GSC-driven SEO automation pipeline taught me that tooling migrations are only worth the switching cost if you can measure the outcome. The same principle applies to build tools: benchmark your actual project, not a synthetic test.

What's Coming: Vite+ Beta and the Unified Toolchain Future

VoidZero launched Vite+ (beta) — a unified frontend toolchain CLI called vp that bundles Vite, Vitest, Rolldown, Oxc, linting, formatting, type checking, runtime management, and package management into a single tool.

As Vishwajeet Kondi documented, this positions Vite as more than a build tool. It's becoming a full toolchain platform — the JavaScript equivalent of cargo for Rust or go for Go.

With Cloudflare's investment in VoidZero, the financial backing is there. The technical pieces (Rolldown for bundling, Oxc for parsing/transforming, Vitest for testing) are already in use individually. Vite+ is the packaging layer that unifies them.

Meanwhile, Rspack is building its own unified toolchain through the Rstack ecosystem: Rsbuild (build tool), Rslib (library development), Rspress (static sites), Rsdoctor (build analyzer), Rstest (testing), and Rslint (linting). It's a parallel effort with the same ambition — one coherent toolchain instead of a dozen independent tools.

Turbopack's roadmap is narrower. Production builds went stable in Next.js 16, dev file-system caching went stable in Next.js 16.1, and caching for next build is next. The Turbopack team is talented — Tobias Koppers literally created webpack — but the tool remains tied to a single framework.

For teams making decisions today, this future context matters. Betting on Vite means betting on VoidZero's unified toolchain vision backed by Cloudflare. Betting on Rspack means betting on ByteDance's Rstack ecosystem. Betting on Turbopack means betting on Next.js. If you're weighing ecosystem bets like this, the same thinking applies as when evaluating AI agent frameworks — the tool with the broadest community support usually wins long-term.

Which Build Tool Should You Use for Your Project?

Here's the decision matrix by project type:

New React SPA, Vue, Svelte, or Solid project: Use Vite 8. It's the ecosystem default with the broadest support, fastest production builds, and the strongest community. 130 million weekly downloads isn't an accident.

Large existing webpack monorepo: Use Rspack 2.x. The webpack API compatibility means you can migrate incrementally without rewriting your build config. The 4.8x cold start improvement over Vite is a real advantage at monorepo scale.

Next.js app: Use Turbopack. It has been the default for both next dev and next build since Next.js 16, so dev and production run on one pipeline with no extra config.

Next.js app with a heavy custom webpack config: Use Rspack via next-rspack. You keep webpack plugin and loader compatibility with Rust-level speed for both dev and production.

Component library or npm package: Use Vite 8 (via Rolldown) or Rslib (via Rspack). Both produce optimized production bundles. Vite has the edge on tree shaking quality for library output.

Legacy project where you can't change anything: Stay on webpack 5. It's slow (21.40s cold start, 28.10s build) but it works, it's battle-tested, and it'll be supported for years. Migrate when you're ready, not because a benchmark told you to.

The build tool wars of 2026 are fundamentally different from the webpack vs Gulp debates of 2016. All three modern contenders — Vite, Turbopack, and Rspack — deliver sub-200ms HMR and dramatically faster builds than webpack. The differences between them are real but narrow compared to the gap between any of them and webpack.