Rolldown and Vite 8: What Changed

Vite 8 shipped in March 2026 with the biggest architectural change since Vite 2. Rolldown, a Rust-based bundler, now replaces both esbuild (which handled dev transforms) and Rollup (which handled production builds). If you're running a Vue project on Vite, this affects your dev server, your production builds, and the gap between them. In this post, we'll walk through what actually changed and what you need to do about it.

You can read the official announcement on voidzero.dev.

What Rolldown Replaces

Before Vite 8, the build pipeline used two separate tools:

• esbuild handled dependency pre-bundling in dev mode and TypeScript/JSX transforms
• Rollup handled the production build (bundling, code splitting, tree shaking)

This worked well, but the two tools had different behaviors. Code that worked in dev could break in production because the bundlers handled edge cases differently. Module interop, code splitting boundaries, and import resolution could all behave slightly differently between the two.

Rolldown replaces both. One bundler for dev, one bundler for production. The same Rust-based tool handles pre-bundling, transforms, and the final build.

What You'll Notice

Faster Builds

The production build is where the difference is most visible. Rolldown is 10-30x faster than Rollup, and the gap widens with project size. Some real numbers from companies that adopted it early: Linear cut builds from 46 seconds to 6 seconds. Ramp saw a 57% reduction. Beehiiv saw 64%.

For a typical Vue app with 50-100 components, you're looking at builds that used to take 8-12 seconds finishing in 1-3 seconds.

Faster Dev Startup

Dependency pre-bundling (the step where Vite processes your node_modules into ES modules) is faster too. Rolldown handles this instead of esbuild now, and since it shares the same module graph with the rest of the pipeline, there's less duplicate work.

On a fresh npm run dev with a mid-size Vue project, you'll see the pre-bundling step complete noticeably faster. Subsequent starts (where the cache is warm) were already fast and stay fast.

Smaller Bundles

Rolldown ships with dead code elimination and smart constant inlining enabled by default. Your production bundles should be smaller without any config changes. The DCE is more aggressive than Rollup's because Rolldown can analyze the full module graph in a single pass.

Upgrading

If your project is on Vite 7, upgrading to Vite 8 is straightforward:

      npm install vite@latest @vitejs/plugin-vue@latest

    

Your vite.config.ts doesn't need changes. The Vue plugin works the same way:

      // vite.config.ts
import { defineConfig } from 'vite';
import vue from '@vitejs/plugin-vue';

export default defineConfig({
  plugins: [vue()],
});

    

Rolldown is now the default. There's no opt-in flag.

Plugin Compatibility

Rolldown supports the same plugin API as Rollup. If your project uses Rollup plugins, they should work without changes. The most common Vue-related plugins are compatible:

      // vite.config.ts
import { defineConfig } from 'vite';
import vue from '@vitejs/plugin-vue';
import Components from 'unplugin-vue-components/vite';
import AutoImport from 'unplugin-auto-import/vite';

export default defineConfig({
  plugins: [
    vue(),
    Components(),
    AutoImport({
      imports: ['vue', 'vue-router'],
    }),
  ],
});

    

If you have a custom Rollup plugin that uses standard hooks (resolveId, load, transform, renderChunk), it should work as-is. Plugins that rely on internal Rollup APIs or undocumented behavior may need updates, but this is rare.

Dev/Prod Consistency

This is the change that matters most day-to-day, even if it's the least visible. Before Vite 8, you could write code that worked in dev but broke in production because esbuild and Rollup resolved modules differently or handled edge cases in import chains differently.

With Rolldown handling both, the module resolution, code splitting, and transform pipeline are identical in dev and production. If it works in dev, it works in production. This eliminates an entire category of "works on my machine" bugs.

The Broader Toolchain: Oxc and Vite+

Rolldown is part of a larger effort. It's built on Oxc, a Rust-based JavaScript parser and transformer. The same foundation powers:

• Rolldown for bundling
• Oxlint for linting
• Oxfmt for formatting

All of these share one parser, one resolver, and one module interop layer. This means they don't conflict with each other the way separate tools (ESLint + Prettier + webpack) sometimes do.

VoidZero also announced Vite+, which combines Vite, Vitest, tsdown, Oxlint, and Oxfmt into a single CLI. For Vue projects, this means your entire toolchain (dev server, tests, build, linting, formatting) could run on a shared Rust core. It's early, but worth watching.

What About Nuxt?

If you're using Nuxt, you get Rolldown automatically. Nuxt uses Vite under the hood, so upgrading Nuxt to a version that depends on Vite 8 gives you the same benefits. Nitro (the server engine) also benefits from faster builds.

Check your Nuxt version's Vite dependency to confirm you're on Vite 8:

      npx nuxi info

    

Things to Watch

Rolldown 1.0 is stable as of May 2026, but a few things are still evolving:

• Minification is in alpha. Rolldown can minify, but most projects still use the default (which falls back to a separate minifier). This will improve in upcoming releases.
• Output heuristics (chunking, inlining) will keep improving. Option defaults may shift between minor versions to produce smaller bundles.
• Experimental features are not covered by semver guarantees. Stick to documented options for production use.

Key Takeaways

• Vite 8 replaces both esbuild and Rollup with Rolldown, a single Rust-based bundler
• Production builds are 10-30x faster than Rollup
• Dev and production now use the same bundler, eliminating an entire class of inconsistency bugs
• Rollup plugin API is supported, so most existing plugins work without changes
• Upgrading is npm install vite@latest with no config changes needed
• Nuxt projects get this automatically through Vite

Conclusion

The move to Rolldown is the kind of infrastructure change that mostly just makes things faster and more predictable. You don't need to learn a new API or rewrite config. The biggest win is something you'll stop noticing: builds that used to make you wait, and dev/prod differences that used to make you debug.

I hope this post has been helpful. Happy coding!