Vite vs Turbopack vs Rspack Benchmarked [2026]

Vite vs Turbopack vs Rspack is the defining build-tool comparison of 2026. All three shipped transformative updates this year: 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 stabilized for development inside Next.js. 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?

Key takeaways:

• 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 dev-only — its production build (next build --turbo) is still not stable, making it impossible to recommend as a full build tool.
• 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 things happened between March and June 2026 that made every existing JavaScript build tool comparison article obsolete.

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... didn't ship a production build. As Maia Teegarden, Tim Neutkens, and Tobias Koppers announced back in October 2024, Turbopack dev is stable inside Next.js 15+. But next build --turbo remains unstable, and there's still no disk caching. For a tool that's been in development since 2022, that's a significant gap.

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.

→ Related: Hotwire vs Next.js in 2026: Is Server-Centric HTML the End of SPA Bloat? [Compared]

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 for development inside Next.js but can't build your production bundle. 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.

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.

As of mid-2026, here's what Turbopack actually delivers:

• 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: NOT stable. next build --turbo is still experimental. If you're using Turbopack for dev, you're still falling back to webpack for production builds.
• Disk caching: NOT available. Every cold start rebuilds from scratch. 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 development accelerator 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: webpack (legacy), Turbopack (dev-only), or Rspack (full pipeline, 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.

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 in 2026 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, while fast, lacks disk caching, meaning every restart throws away all compilation work.

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 has no production build to benchmark. Period. next build --turbo is experimental. If you're using Turbopack for dev in Next.js, your production builds still run through webpack. This is Turbopack's single biggest limitation in 2026.

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 webpack (slow, stable), Turbopack (fast dev, no prod build), and Rspack via next-rspack (fast, webpack-compatible, full pipeline). 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 and want to avoid Turbopack's dev-only limitation
• 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 harder to read. Vercel has been working on production build support for over two years. Disk caching is on the roadmap but unshipped. The Turbopack team is talented — Tobias Koppers literally created webpack — but the gap between "dev stable" and "production stable" has been wide for a long time.

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 Vercel shipping production builds before the other two tools make it irrelevant. 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 Actually Use in 2026?

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, dev experience priority: Use Turbopack for dev with webpack for production. The dev experience is genuinely fast. Just know you're running two different build pipelines and can't use Turbopack for next build yet.

Next.js app, full pipeline priority: Use Rspack via next-rspack. You get Rust-level speed for both dev and production, webpack compatibility, and no vendor lock-in to Vercel's experimental tooling.

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.