Vite 8: Rust Takes Over the JavaScript Build Toolchain

Vite just replaced both esbuild and Rollup with a single Rust-based bundler — and the build times are almost offensive.

When Vite launched, it made a pragmatic bet on two bundlers: esbuild for speed during development, and Rollup for optimized production builds. That bet served the ecosystem well for years.

On March 12, 2026, Vite 8 resolved that into one.

Vite 8 ships with Rolldown as its single, unified, Rust-based bundler — replacing both esbuild and Rollup under the hood. The team describes this as the most significant architectural change since Vite 2.

The benchmark numbers are almost offensive.

Why Two Bundlers Was Always a Problem

Vite’s dual-bundler architecture was elegant in theory but messy in practice. Having two separate bundling pipelines meant:

  • Inconsistent behavior between dev and production builds — bugs that only appeared after deployment
  • Duplicate plugin systems — plugins had to handle both esbuild and Rollup APIs
  • Growing glue code to keep behavior aligned between the two
  • Fundamental limitations on optimizations that require a single unified pipeline

If you’ve ever shipped a bug that worked perfectly in vite dev but broke in vite build, you’ve met this problem firsthand.

Rolldown fixes this at the root.

What Is Rolldown?

Rolldown is a Rust-based bundler built by the VoidZero team — the company founded by Evan You (creator of Vue.js and Vite) specifically to build the next generation of JavaScript tooling in Rust.

Its design goals are three things:

Performance — written in Rust, Rolldown operates at native speed. In benchmarks, it is 10-30× faster than Rollup, matching esbuild’s performance level.

Compatibility — Rolldown supports the same plugin API as Rollup and Vite. Most existing Vite plugins work out of the box with Vite 8. No rewriting your plugin configuration.

Advanced features — a single unified bundler unlocks capabilities that were difficult or impossible with the dual-bundler setup: Full Bundle Mode, flexible chunk splitting, module-level persistent caching, and Module Federation support.

The Benchmark Numbers

Preliminary results show 3× faster dev server startup, 40% faster full reloads, and 10× fewer network requests — especially impactful for large projects where the unbundled dev approach hits scaling limits.

Real-world production build improvements reported during the beta phase:

  • A mid-sized React application (~180K lines TypeScript, 60 routes): 8.5× faster build
  • Teams have reported numbers ranging from 4× to 20× depending on project complexity
  • The bigger and more complex the project, the bigger the relative win

Vite is now being downloaded 65 million times a week, and the ecosystem continues to grow with every release.

What Is Oxc?

Rolldown is built on top of Oxc — also written in Rust. Oxc is a utility toolkit that includes:

  • Parsing (JavaScript and TypeScript)
  • Linting (Oxlint — 600+ rules, up to 100× faster than ESLint)
  • Formatting (Oxfmt — 100% Prettier compatibility, 36× faster)
  • Transpiling TypeScript and JSX
  • Module resolution
  • Minification

This makes Vite 8 the entry point to a vertically integrated toolchain where the same team owns and optimizes every layer from parsing to bundling:

Vite 8 (build tool)
  └── Rolldown (bundler, written in Rust)
        └── Oxc (parser, transformer, minifier, written in Rust)

This alignment ensures consistent behavior across the entire stack and opens optimizations that were previously out of reach — for example, using Oxc’s semantic analysis to perform better tree-shaking in Rolldown.

What Actually Changed in Vite 8

1. Rolldown replaces esbuild + Rollup

For development: Rolldown handles dependency optimization (previously esbuild’s job). For production: Rolldown handles bundling (previously Rollup’s job).

The build.rollupOptions config key is renamed to build.rolldownOptions, and optimizeDeps.esbuildOptions is now deprecated in favor of optimizeDeps.rolldownOptions. Vite 8 ships a compatibility layer that automatically converts your existing esbuild and rollupOptions configuration to the corresponding Rolldown options — so many projects will work without any config changes at all.

2. Oxc replaces esbuild for minification

// vite.config.js — the new default (Oxc minifier)
export default {
  build: {
    minify: true  // Now uses Oxc instead of esbuild
  }
}

// Switch back to esbuild minifier (deprecated, will be removed)
export default {
  build: {
    minify: 'esbuild'
  }
}

3. @vitejs/plugin-react v6 drops Babel

The React plugin now uses Oxc for React Refresh transforms by default. Babel is no longer a dependency. Installation is smaller, cold-start is faster.

# Before: pulled in Babel as a dependency
npm install @vitejs/plugin-react   # v5

# After: Babel-free, Oxc-powered
npm install @vitejs/plugin-react   # v6

If you need the React Compiler, v6 provides a reactCompilerPreset helper as an explicit opt-in path — not the default.

4. Vite DevTools

Vite 8 introduces experimental DevTools for build analysis and debugging — available when using Rolldown. From your browser you can:

  • Inspect the module graph
  • Analyze transform timelines (see exactly which plugin is slow)
  • Debug HMR updates in real time
// Enable DevTools in vite.config.js
export default {
  experimental: {
    devtools: true
  }
}

5. WebAssembly support in SSR

Vite 8 adds Wasm support in server-side rendering environments. You can now import and use .wasm modules in SSR code without a custom plugin.

6. Browser console forwarding

Browser console.log calls are now forwarded to the dev server terminal. When debugging a full-stack app, you see both server logs and browser logs in the same terminal window.

Full Bundle Mode (Experimental — Coming Soon)

This is the next big thing. Full Bundle Mode bundles modules during development — similar to how production builds work — rather than using the native ESM unbundled approach Vite has always used in dev.

Why does this matter? For small and medium projects, unbundled dev is fast. For large projects with thousands of modules, the dev server can get slow on initial startup and full reloads due to the sheer number of network requests.

Preliminary results show 3× faster dev server startup, 40% faster full reloads, and 10× fewer network requests. This makes production-like bundling during development finally practical — because Rolldown is fast enough.

How to Upgrade to Vite 8

For most projects, upgrading is straightforward. Vite 8 ships a compatibility layer that auto-converts existing esbuild and rollupOptions configuration to their Rolldown equivalents.

Direct upgrade (simple projects):

npm install vite@8

Run vite dev and vite build. If everything works, you’re done.

Gradual migration (large/complex projects):

Step 1 — First migrate to rolldown-vite on Vite 7 to isolate any Rolldown-specific issues:

# package.json
{
  "dependencies": {
    "rolldown-vite": "latest"  // replaces vite
  }
}

Step 2 — Fix any incompatibilities found with rolldown-vite.

Step 3 — Switch to Vite 8:

npm uninstall rolldown-vite
npm install vite@8

Config changes to review:

// vite.config.js — Before (Vite 7)
export default {
  build: {
    rollupOptions: {           // ← Deprecated in v8
      output: {
        manualChunks: { ... }
      }
    }
  },
  optimizeDeps: {
    esbuildOptions: { ... }   // ← Deprecated in v8
  }
}

// vite.config.js — After (Vite 8)
export default {
  build: {
    rolldownOptions: {         // ← New name
      output: {
        manualChunks: { ... }
      }
    }
  },
  optimizeDeps: {
    rolldownOptions: { ... }   // ← New name
  }
}

Plugin compatibility:

Most Vite plugins work out of the box. Areas that need attention:

  • Plugins using niche Rollup plugin hooks or advanced transformation features
  • Complex CSS module configurations
  • Legacy browser support via @vitejs/plugin-legacy (update it — new version supports Vite 8)
  • Projects using --outFile or AMD/UMD modules

Things That Don’t Change

It’s worth being explicit about what Vite 8 does not change — because the migration is less disruptive than it might sound:

  • The vite.config.js API — same configuration structure, same plugin hook signatures
  • Your plugins — the compatibility layer handles most cases automatically
  • HMR behavior — same development experience, just faster
  • The TypeScript experience — unchanged
  • Framework integrations (Vue, React, Svelte, Solid) — all supported, same as before

The bundler changed. The developer experience didn’t.

The Bigger Picture: VoidZero’s Unified Rust Toolchain

Rolldown and Oxc aren’t isolated projects. They’re the first pieces of a larger effort by VoidZero to build a unified, Rust-based JavaScript toolchain where the same team owns every layer:

ToolRoleReplaces
ViteBuild toolwebpack (for many projects)
RolldownBundleresbuild + Rollup
OxcParser/Transformer/MinifierBabel, esbuild transforms
OxlintLinterESLint
OxfmtFormatterPrettier
VitestTest runnerJest

The key insight: when all these tools are built by the same team, on the same Rust foundation, they can share infrastructure. Oxc’s AST can be reused by Rolldown. Rolldown’s module graph can feed Vitest. The whole stack becomes more consistent and faster than any collection of independently developed tools could be.

Should You Upgrade Now?

Yes, upgrade now if:

  • You’re starting a new project — use Vite 8 from day one
  • Your production builds take more than 60 seconds
  • You have a simple configuration (standard React or Vue stack, no exotic plugins)

Test carefully if:

  • You use plugins with niche Rollup hooks or advanced transformation features
  • You have complex CSS module configuration
  • You target legacy browsers

Wait if:

  • You’re in the middle of a critical release cycle
  • Your organization has a formal dependency vetting process that hasn’t evaluated Vite 8

Final Thoughts

Vite 8 is the most significant architectural change to the JavaScript build toolchain in years — and arguably the most important Vite release since version 2.

The dual esbuild/Rollup setup served us well. But it always had a ceiling: two separate pipelines, two separate plugin systems, inconsistencies between dev and production, and fundamental limits on what optimizations were possible.

A single Rust-based bundler removes that ceiling. The build times are dramatically faster. The behavior is more consistent. The plugin ecosystem works as before. And Full Bundle Mode — coming soon — will make even large projects feel instant in dev.

The Rust toolchain revolution in JavaScript is no longer a future thing to keep an eye on. It is the present default for anyone building on modern infrastructure.

Upgrade to Vite 8. Run your build. Be surprised by the number.

The JavaScript toolchain just got a Rust engine.

Leave a Reply

Your email address will not be published. Required fields are marked *