For years Vite ran on two bundlers wearing a trench coat: esbuild for dev transforms and Rollup for production builds. It worked, but the seam between them caused subtle dev-versus-prod differences and put a ceiling on how fast a production build could go. Vite 8, stable since March 2026, closes that seam: it ships a single Rust bundler called Rolldown that handles both.

The numbers are not incremental. Rolldown-backed builds are commonly 10 to 30 times faster than the Rollup path. Linear reported a production build dropping from 46 seconds to 6; GitLab went from two and a half minutes to twenty-two seconds. If your CI spends real money on build minutes, this is the rare upgrade that pays for itself immediately.

Rolldown, Oxc, and the toolchain behind it

Rolldown is one piece of a larger effort. The transform and minify work that esbuild used to do is now handled by Oxc — a Rust parser, resolver, transformer, and minifier from the same team. Rolldown and Oxc are the first two components of a unified JavaScript toolchain, all written in Rust, all sharing one parser instead of each tool re-parsing your code. That shared foundation is why the pieces are so fast together and why the same team also ships the Oxlint linter on top of it.

One governance note worth knowing: in mid-2026 Cloudflare acquired VoidZero, the company behind Vite, Vitest, Rolldown, and Oxc, and set up an ecosystem fund with a commitment to keep everything open source. If you were nervous about a critical build tool sitting inside one company, that is the state of play.

The migration itself

For a typical app the upgrade is genuinely a version bump. Rolldown is API-compatible with Rollup for the vast majority of the plugin surface, so most configs move over untouched.

npm install -D vite@8

# build as usual; Rolldown is the bundler now, no config needed
npx vite build

# time it against your previous build to see the delta
time npx vite build

Your vite.config.ts usually needs no changes at all — the bundler swap happens underneath the same public API.

import { defineConfig } from "vite";
import react from "@vitejs/plugin-react";

export default defineConfig({
  plugins: [react()],
  build: {
    // Rolldown reads the same options Rollup did
    rollupOptions: {
      output: { manualChunks: { vendor: ["react", "react-dom"] } },
    },
  },
});

Where it bites

Two categories of pain. First, Rollup plugins that reach into internals rather than using the documented hooks — a plugin that depends on Rollup's exact AST types or private module graph may need a Rolldown-aware update. Check your heaviest plugins before assuming a clean upgrade. Second, output determinism: chunk hashing and splitting can differ slightly from Rollup, which matters if you have tooling that pins asset names or a long-lived CDN cache keyed on them. Neither is common, but both are worth a diff of your dist/ output before you ship.

If you use Vitest, it moves in lockstep — the same toolchain powers your tests, so the speedup shows up there too.

Is it worth doing now

Yes, for almost everyone. Vite 8 is stable, Rolldown 1.0 has a locked API with backward-compatibility guarantees, and the downside is a config diff you can review in an afternoon. The upside is a build that is fast enough to stop being a thing you wait on. For a frontend team, few upgrades this year will feel as immediately good as watching a slow production build finish before you have switched tabs.