Rolldown: Vite's Rust Bundler Replacing Rollup

For years Vite has been two bundlers wearing one coat. In development it leans on esbuild for lightning-fast dependency pre-bundling, and for the production build it hands everything to Rollup. That combination is what made Vite feel instant during dev while still producing well-optimized output for shipping. It also quietly created a seam right down the middle of the tool.

Rolldown is the Vite team's answer to that seam: a single Rust-based bundler, built on the Oxc toolchain, designed to do both jobs. It ships today as rolldown-vite, a drop-in replacement package you can try on your existing Vite project before it becomes the default. This post covers why the two-bundler design existed, what Rolldown unifies, the performance goals, and exactly how to try it.

Why Vite used two bundlers — and why that hurt

The split was pragmatic. esbuild, written in Go, is extraordinarily fast at transforming and pre-bundling dependencies, which is perfect for a dev server that needs to start in milliseconds. Rollup, by contrast, produces smaller, more optimized bundles with a mature plugin ecosystem and better tree-shaking, which is what you want for production. Each tool was picked for the phase it was best at.

The cost is consistency. In dev, Vite serves largely unbundled ES modules transformed by esbuild; in production it emits a bundled build from Rollup. Two separate transformation pipelines mean two plugin systems and a growing layer of glue code to keep them in sync — and the different runtime behavior between unbundled dev and bundled prod is exactly where bugs hide until they surface only after you ship.

What Rolldown unifies

Rolldown collapses the two pipelines into one. Written in Rust and built on Oxc — VoidZero's high-performance JavaScript toolkit that provides the parser, resolver, transformer, minifier, and sourcemap support — it handles pre-bundling, transformation, minification, and the final bundle from a single foundational layer. The practical wins are concrete:

• One bundler for dev and production, so what you test is far closer to what you ship.
• One plugin system instead of two, removing the glue code that kept esbuild and Rollup aligned.
• A Rollup-compatible API and plugin interface, so much of the existing ecosystem carries over.

Rolldown deliberately keeps Rollup's API and plugin interface while pulling esbuild-style capabilities into its scope, so it is not asking the ecosystem to start over. The Rust core is where the speed comes from; the Rollup-compatible surface is what makes adoption realistic rather than a rewrite.

The performance goals on large apps

Rolldown's whole reason to exist is speed at scale, and the VoidZero team has published real migration numbers rather than synthetic microbenchmarks. Vite 8 quotes up to 10–30x faster builds overall while keeping plugin compatibility, and individual projects reported large drops in both time and memory:

• GitLab: production build from about 2.5 minutes down to 40 seconds, with memory use cut dramatically.
• Excalidraw: roughly 22.9 seconds down to 1.4 seconds — about 16x faster.
• PLAID Inc.: about 1 minute 20 seconds down to 5 seconds.
• Appwrite: from 12-plus minutes to around 3 minutes, with a roughly 4x memory reduction.
• Particl: over 60 seconds down to about 6 seconds — roughly a 10x speedup.

The memory story matters as much as the wall-clock time. Large monorepos routinely blow through CI memory limits during the Rollup build, and Rolldown's Rust core keeps the footprint far smaller — which for some teams is the difference between a build that finishes and one that gets killed by the runner.

How to try rolldown-vite

You do not need Vite 8 to try Rolldown. rolldown-vite is published as a separate package that follows Vite's major and minor version numbers, so you can alias it into an existing Vite 7 project. The recommended migration path for larger apps is deliberately staged: move to rolldown-vite on Vite 7 first to shake out any Rolldown-specific issues, then upgrade to Vite 8 where it becomes the built-in default.

The switch is a package.json alias. Point vite at the rolldown-vite package, then reinstall — no config file changes needed to start:

{
  "devDependencies": {
    "vite": "npm:rolldown-vite@latest"
  }
}

// npm or Bun — force it through transitive deps too:
{
  "overrides": {
    "vite": "npm:rolldown-vite@latest"
  }
}

// Yarn:
{
  "resolutions": {
    "vite": "npm:rolldown-vite@latest"
  }
}

// pnpm:
{
  "pnpm": {
    "overrides": {
      "vite": "npm:rolldown-vite@latest"
    }
  }
}

Use a plain dependency alias for a simple app; use overrides, resolutions, or the pnpm overrides block when other packages depend on vite transitively and you need every copy resolved to rolldown-vite. After reinstalling, run your dev server and production build as usual and compare output.

Rollup plus esbuild versus Rolldown at a glance

The table simplifies a nuanced picture — Rollup and esbuild are both excellent at what they were chosen for — but it captures the direction of travel: from two specialized tools stitched together to one fast bundler that does both jobs with a familiar API.

Should you switch today?

If you run a large app where production build time or CI memory is a real bottleneck, trying rolldown-vite on a branch is worth an afternoon — the numbers on big codebases are the point of the project. For small apps the current esbuild-plus-Rollup setup is already fast enough that you may not notice, so there is no urgency to move before Vite 8 makes it the default anyway.

Either way, Rolldown is where Vite is heading. Treating it as the future default rather than an experiment means the migration is not whether but when — and doing a staged trial now, on Vite 7, is the low-risk way to be ready before the switch is made for you.