Announcing Rolldown 1.0

TL;DR: Rolldown, the high-performance Bundler for JavaScript, reached 1.0 stable and production readiness. It features speed, Rollup plugin compatibility, and unique bundler features. Upgrading from the latest RC does not need any code changes.

Rolldown reaches 1.0 ​

Rolldown is a Rust-based high-performance JavaScript bundler. It can be used standalone and is powering Vite since its latest major version Vite 8. Now Rolldown itself hits the 1.0 stable milestone.

Rolldown adheres to semantic versioning meaing the ^1.0.0 API is now locked:

• Option names, types, and plugin hook signatures stay backward-compatible.
• No planned breaking changes to Rolldown's public API.

Except for features marked experimental.

Built with Vite in mind ​

One of Rolldown's main goals was to unify Vite's original 2-bundler setup. The previous configuration worked, but it meant two transformation pipelines, two plugin systems, and a growing layer of glue code. It also limited Vite's future capabilities.

Rolldown solved this as a bundler by combining the best parts of existing bundlers. esbuild's speed and Rollup's plugin API. In addition, the bundler provides features neither had. (More on this below)

Swapping Vite's bundler was a 2 year journey. How we got here:

• April 2024: First public 0.10.1 release.
• December 2024: 1.0.0-beta.1, scoping the eventual 1.0 surface area.
• May 2025: rolldown-vite, a temporary package, shipped as a technical preview to prepare for the swap and gather feedback from the community.
• December 2025: Vite 8 beta shipped with Rolldown as the default bundler.
• January 2026: Rolldown 1.0 RC marked API stability.
• March 2026: Vite 8 stable shipped, making Rolldown the underlying bundler for every Vite user.
• May 2026: Rolldown 1.0 stable.

Vite 8 is now Rolldown's main entry point. Meaning new Rolldown features and improvements directly benefit Vite users.

Why switch to Rolldown ​

Rolldown is a native bundler that combines speed and flexibility through it's plugin API. On top of that, it has unique features that improve the bundling experience and output quality.

• esbuild-like speed
• Rollup plugin-compatibility
• Additional bundler features

Companies like Framer and PLAID are already using Rolldown in production.

esbuild-like speed ​

Rolldown is 10x-30x faster than Rollup (the gap widens as project size grows) and on par with esbuild. Performance is a feature. Rolldown is written in Rust and leverages Oxc to handle the language work like parsing and minification.

Highlights:

• Ramp reduced their build time by 57%
• Mercedes-Benz.io cut their build time down by up to 38%
• Beehiiv reduced their build time by 64%

Full benchmarks: rolldown/benchmarks.

Rollup plugin-compatibility ​

Rolldown needed a Rollup-compatible plugin API to be a drop-in replacement for Vite. Otherwise, developers would have to make massive code changes to migrate to the latest Vite, which is a terrible experience. It also ensures users can continue using their existing plugins. Most Vite plugins work out of the box on Vite 8.

With Rolldown being written in native Rust, there was performance improvement opportunities in the plugin API too:

• Hook filters keep JavaScript plugins out of the hot path. Plugins that declare an id, code, or moduleType filter skip the Rust-to-JS hop when the filter doesn't match, so adding plugins doesn't linearly slow your build. For plugins that don't ship filters yet, withFilter wraps them on the consumer side.
• Built-in plugins replace common Rollup-ecosystem dependencies in Rust. replacePlugin and esmExternalRequirePlugin drop into existing configs without the JavaScript hop.

The Plugin API reference covers the full API surface.

Additional bundler features ​

• Smaller default bundles. Aggressive dead code elimination with @__PURE__, @__NO_SIDE_EFFECTS__, and sideEffects controls; smart constant and TypeScript const enum inlining; and DCE-only minification that strips dead code without mangling identifiers.
• More chunking control. Granular code splitting with webpack-style chunk rules, the same feature behind Framer's 67% chunk reduction.

For the full list, see Notable Features.

Using Rolldown ​

Standalone ​

$ vp add -D rolldown

$ npm install -D rolldown

$ pnpm add -D rolldown

$ yarn add -D rolldown

$ bun add -D rolldown

import { defineConfig } from 'rolldown'

export default defineConfig({
  input: 'src/main.ts',
  output: { dir: 'dist' },
})

$ vpx rolldown -c

$ npx rolldown -c

$ pnpm rolldown -c

$ yarn rolldown -c

$ bunx rolldown -c

Via Vite ​

Rolldown is the default bundler from Vite 8 on. You can use build.rolldownOptions in your vite.config.ts to pass Rolldown-specific options. Like configuring your own chunking rules.

// vite.config.ts
import { defineConfig } from 'vite'

export default defineConfig({
  build: {
    rolldownOptions: {
      output: {
        // Granular chunk splitting
        codeSplitting: {
          groups: [{ name: 'vendor', test: /node_modules/ }],
        },
      },
    },
  },
})

Since RC ​

Rolldown went through a long release candidate phase as we prioritized fixing real-world bugs, both before and after the Vite 8 release. We prioritized fixing real-world bugs between RC and 1.0. Upgrading from the latest RC needs no code changes.

In addition to the bug fixes, we also shipped smaller features that help solve underlying problems or make direct improvements:

• Watch mode (experimental) was rebuilt on a new native file-system watcher that is reliable, allows for faster bundling, and includes WASM support.
• Native MagicString (experimental) filled out its API surface and can serve as a drop-in replacement for the JavaScript version. It provides better transformation performance and fewer dependencies.

If you've been on the latest RC or Vite 8 version, you've already had most of these for weeks.

What's Next ​

1.0 is the start. We're already working on exciting improvements including:

• Vite full bundle mode. When Vite was created, unbundled ESM was the right tradeoff. No tool was both fast and had the HMR and plugin capabilities needed to bundle during dev. But as codebases grew, developers began to experience slow page loads due to the high number of unbundled network requests. Rolldown changes that by bundling the whole app for dev like production instead of serving per-file ESM. Preliminary numbers are showing 3x faster dev startup, 40% faster full reloads, 10x fewer network requests.

• Stabilize lazy barrel optimization. Traditionally barrel modules forced bundlers to compile every module. Even if only some are used. Needless to say, this was inefficient. It bloated both build times and output size. Rolldown released an experimental version of lazy barrel optimization that analyzes exports and only modules that are actually used.

Acknowledgements ​

Rolldown 1.0 represents the collective effort of about 200 contributors. Thank you to everyone who has contributed code, reported issues, reviewed PRs, or helped spread the word. Special thanks to the early production adopters whose feedback shaped the RC and made 1.0 possible.

We owe a great debt to the projects that inspired Rolldown:

• Rollup by Rich Harris and Lukas Taegert-Atkinson, for the plugin API that became the lingua franca of the JavaScript ecosystem.
• esbuild by Evan Wallace, for showing what native-speed bundling could feel like.

Call for Contributors ​

Rolldown is built in the open, and we want more people building it with us. The codebase covers bundler internals, real-world Rust at scale, and the chance to work on production-grade technology millions of apps depend on.

A few areas where help is especially valuable today:

• Documentation. Help identify content gaps in Rolldown's documentation and make it easier for developers to use.
• Plugin compatibility testing. Try Rolldown on real codebases, file issues with reproductions, and help us close ecosystem gaps.
• Good first issues. Labelled and triaged on GitHub, ready for you to pick up.

Whether you're a bundler expert or first-timer contributor, we value your contribution. Start with the contribution guide.

Join the Community ​

• Discord - Chat with the team and other users
• GitHub - Star the repo, report issues, contribute
• Documentation - Guides, API reference, and in-depth chapters
• X & Bluesky - Follow for ecosystem updates

We can't wait to see what you build on Rolldown 1.0.