Vite 8 Swapped Rollup for Rolldown — Here's What Actually Breaks

Three weeks ago Vite 8 went stable and nobody on my team noticed until CI times halved overnight. That's the kind of release this is — you upgrade, your builds get wildly faster, and the interesting part is figuring out what broke.

#What Actually Changed

The build tool used to run two separate engines under the hood. esbuild handled dev transforms, Rollup handled production bundling. This split worked fine until it didn't — subtle behavioral differences between dev and prod were a constant source of "works on my machine" bugs. Version 8 kills both and replaces them with Rolldown, a single Rust-based bundler built by VoidZero (Evan You's company, founded late 2024).

The numbers are real. On a 19,000-module benchmark, the new bundler completed in 1.61 seconds versus Rollup's 40.10 — a 25x improvement. Linear reported production builds dropping from 46 seconds to 6. Beehiiv saw a 64% improvement on a mid-sized codebase. For small projects under 100 modules, expect 2-5x gains. Anything above 500 modules gets you into 10-30x territory.

#The Upgrade Is Mostly Painless

For most projects, the migration is anticlimactic:

npm install vite@8
npm run build

A compatibility layer auto-converts your existing rollupOptions and esbuild config to their Rolldown and Oxc equivalents. If you haven't done anything exotic with your config, you might not change a single line.

But "mostly" is doing heavy lifting in that sentence.

#Three Things That Will Actually Bite You

CommonJS imports. Rolldown is stricter about module boundaries than its predecessor. If you're importing a CJS package that worked fine before, you might get runtime errors now. The temporary escape hatch:

// vite.config.ts
export default defineConfig({
  legacy: {
    inconsistentCjsInterop: true
  }
})

Don't leave that flag on forever. It's a migration crutch. Track down the problematic packages and either find ESM alternatives or add proper interop wrappers. The Node ecosystem has had years to move to ESM — most libraries have by now, and the stragglers tend to have forks or replacements.

Chunk splitting syntax changed. If you were using manualChunks inside rollupOptions, that config shape is deprecated. The replacement lives under rolldownOptions with a declarative API:

// Before (Vite 7)
build: {
  rollupOptions: {
    output: {
      manualChunks(id) {
        if (/\/react(?:-dom)?/.test(id)) return 'vendor'
      }
    }
  }
}

// After (Vite 8)
build: {
  rolldownOptions: {
    output: {
      codeSplitting: {
        groups: [
          { name: 'vendor', test: /\/react(?:-dom)?/ }
        ]
      }
    }
  }
}

I actually prefer the new shape. The old callback-based approach was flexible but turned into spaghetti on any project with more than two vendor chunks. Declarative grouping is easier to read and harder to mess up.

CSS minification default flipped. Lightning CSS now handles minification instead of esbuild. Probably fine for you, but if your pipeline relies on specific esbuild CSS output characteristics (snapshot tests, anyone?), opt back with build.cssMinify: 'esbuild'.

#The Win Nobody Talks About

Raw speed gets the headlines, but the real upgrade is consistency. Dev and production builds now run through the same bundler — same module resolution, same tree-shaking behavior, same chunk boundaries. That entire class of bugs where something works in vite dev but breaks in vite build? Dramatically smaller attack surface.

Oxc also replaces esbuild for TypeScript transforms. If you were calling transformWithEsbuild anywhere in custom tooling, switch to transformWithOxc or install esbuild as an explicit peer dependency. The @vitejs/plugin-react v6 already handles this internally — it dropped Babel entirely and leans on Oxc, which is a nice bonus you get for free during the upgrade.

#Should You Pull the Trigger?

They're already on 8.0.3 as of March 26, patching edge cases around CSS entry styles and sourcemap handling for non-ASCII characters. The cadence tells you the team knows real-world configs are messy and they're actively sanding down the rough spots.

#Keep an Eye on Full Bundle Mode

The experimental feature worth tracking is Full Bundle Mode. Instead of serving individual modules during development (the standard unbundled approach), it pre-bundles everything into a smaller set of files. The claimed gains: 3x faster dev server startup, 40% faster full reloads, 10x fewer network requests. If those numbers hold in production-scale apps, that's a fundamental shift in how the dev server works — not just a build-time optimization but a dev-experience one.

Between this and the Vite+ announcement at ViteConf Amsterdam — a unified toolchain aiming to replace your linter, formatter, test runner, and bundler in one shot — VoidZero is clearly betting that JavaScript toolchain consolidation runs through Rust. Given what Rolldown just delivered on build performance alone, that bet is looking increasingly hard to argue against.