For years, Vite ran on a quiet compromise. In development it used esbuild for blazing-fast transforms; in production it switched to Rollup for its mature plugin ecosystem and superior output. Two bundlers, two sets of behaviour, and a long tail of subtle differences between what you saw locally and what shipped. Vite 8 ends that split. It replaces both engines with a single Rust-based bundler called Rolldown, and the results are hard to ignore: builds that ran in minutes now finish in seconds.
This guide walks through what Rolldown is, why it matters, and how to migrate a real project without breaking your plugins.
What changed in Vite 8
Vite 8 shipped stable on March 12, 2026, and Rolldown reached its own 1.0 stable on May 7, 2026. The headline is architectural: one bundler now powers both dev and build. Rolldown is written in Rust, uses the Oxc toolchain for parsing and minification, and exposes a Rollup-compatible plugin API so your existing ecosystem keeps working.
The performance numbers come from real migrations, not synthetic benchmarks:
- Linear: production build dropped from 46s to 6s — an 87% reduction.
- GitLab: went from 2.5 minutes on Vite 7 to 22 seconds, and 43x faster than their original Webpack setup.
- Ramp: 57% faster builds. Beehiiv: 64% faster. Mercedes-Benz.io: up to 38%.
Rolldown is broadly described as 10-30x faster than Rollup, with the gap widening as your project grows. For large monorepos, this is the difference between a coffee break and a glance away from your editor.
Why a single Rust bundler matters
The dual-bundler model had a structural problem: dev and prod could disagree. A module that tree-shook fine in Rollup might behave differently under esbuild's dev transform, and you would only discover it after deploying. Unifying on Rolldown means what you run locally is what you ship.
Rust is the enabler here. Bundling is CPU-bound work — parsing, resolving, transforming, and serializing thousands of modules. Native code with real multithreading simply does this faster than JavaScript can, which is why the whole front-end toolchain is migrating to Rust and Go. Rolldown is part of VoidZero's broader stack alongside the Oxc linter (oxlint), the Oxc formatter, and tsdown for library builds.
Migrating an existing project
The migration is designed to be boring, which is the highest compliment you can pay a build tool. Start by upgrading:
npm install vite@^8 --save-devVite 8 auto-converts your existing esbuild and rollupOptions configuration into their Rolldown and Oxc equivalents, so most projects build on the first try. A minimal config looks identical to what you already have:
// vite.config.ts
import { defineConfig } from 'vite'
import react from '@vitejs/plugin-react'
export default defineConfig({
plugins: [react()],
build: {
target: 'es2022',
},
})Where you previously reached for build.rollupOptions, you now have build.rolldownOptions with the same shape. Output and input options carry over directly:
export default defineConfig({
build: {
rolldownOptions: {
output: {
manualChunks: {
vendor: ['react', 'react-dom'],
},
},
},
},
})Most Rollup plugins work unchanged thanks to the compatible plugin API. The Node baseline is unchanged from Vite 7 — Node 20.19+ or 22.12+ — so your CI images likely need no edits.
Advanced chunking that actually scales
One of Rolldown's most practical wins is its chunking model. Beyond the familiar manualChunks, it supports webpack-style chunk rules through advancedChunks, letting you split by size, module count, or path patterns. Framer used this to cut their chunk count by 67%.
export default defineConfig({
build: {
rolldownOptions: {
output: {
advancedChunks: {
groups: [
{
name: 'vendor',
test: /node_modules/,
minSize: 50_000,
},
{
name: 'ui',
test: /src\/components\/ui/,
},
],
},
},
},
},
})This matters for real-world loading performance. Fewer, smarter chunks mean fewer round trips — a meaningful gain when your users are on mobile networks far from your edge, a daily reality across the MENA region where the round trip to a Frankfurt or Bahrain edge node is never free.
Using Rolldown standalone
You do not need Vite to benefit from Rolldown. It ships as a standalone bundler with a CLI and TypeScript config support, which makes it a strong choice for bundling libraries, server code, or CLI tools.
npm install rolldown --save-dev// rolldown.config.ts
import { defineConfig } from 'rolldown'
export default defineConfig({
input: 'src/index.ts',
output: {
dir: 'dist',
format: 'esm',
},
})npx rolldown -c rolldown.config.tsRolldown does aggressive dead-code elimination, honouring @__PURE__ and @__NO_SIDE_EFFECTS__ annotations as well as the sideEffects field in package.json. It inlines TypeScript const enums and constants, and ships built-in plugins (such as replacePlugin) that replace dependencies you used to pull in separately. For library authors, tsdown wraps Rolldown with sensible defaults for generating types and multiple output formats.
Experimental full-bundle dev mode
Vite's dev server traditionally served unbundled native ES modules, which is fast to start but can flood the browser with requests in large apps. Vite 8 adds an experimental full-bundle dev mode that bundles in development too. Early results show roughly 3x faster dev server startup, 40% faster full reloads, and 10x fewer network requests. It is opt-in for now, but it points at where the default is heading.
A note on the moving target
The ecosystem is still settling. In late June 2026, the team pulled an experimental Rust-based React Compiler integration from Rolldown after it added around 5MB to the binary and raised fair questions about shipping framework-specific code inside a general-purpose bundler. The lesson for teams: pin your versions, read the changelog before upgrading, and keep framework-specific transforms in framework plugins where they belong.
There is also a size trade-off to budget for. Vite 8 installs around 15MB larger than Vite 7, mostly from Lightning CSS (~10MB) and Rolldown (~5MB). On a developer machine this is irrelevant; in a tightly constrained container image it is worth knowing.
Should you upgrade?
For most projects, yes. The migration path is genuinely smooth, the plugin ecosystem carries over, and the build-time savings are large enough to change how your team works — faster CI, faster local builds, fewer "works on my machine" surprises from the old dual-bundler split. The pragmatic move is to upgrade a non-critical project first, watch your CI numbers, then roll it out across your codebase.
The era of waiting on the bundler is ending. Vite 8 and Rolldown make the build step fast enough that it stops being something you plan your day around — and that is exactly what a build tool should be.