A futuristic factory processing JavaScript modules at high speed

Rolldown: The Rust-Powered Bundler That Speaks Rollup

The Orange Cat
The Orange Cat

If you have ever waited for a production build to finish and wondered why bundling still feels slow in 2026, Rolldown has an answer for you. Built in Rust by VoidZero Inc. (founded by Evan You, the creator of Vue and Vite), rolldown is a JavaScript and TypeScript bundler designed to be 10-30x faster than Rollup while keeping its beloved plugin API intact. It is the designated future bundler for Vite, and with Vite 8 beta already shipping it as the default, the future is arriving fast.

Why Another Bundler

The JavaScript ecosystem has no shortage of bundlers, but each one trades something off. Rollup has an elegant plugin system but can be slow on large projects. esbuild is lightning fast but has a limited plugin API. webpack is feature-rich but complex. Rolldown aims to combine the best parts: Rollup-level plugin compatibility with Rust-level performance, plus built-in TypeScript and JSX support without extra configuration.

The real motivation comes from Vite itself. Until now, Vite used esbuild for the dev server and Rollup for production builds. This dual-bundler architecture occasionally caused subtle inconsistencies between development and production. Rolldown eliminates that split entirely, giving Vite a single bundler for both environments.

What It Brings to the Table

  • Rollup-compatible plugin API that lets most existing Rollup plugins work with minimal or zero changes
  • Built-in TypeScript and JSX transforms powered by Oxc, so you never need a separate transpilation plugin
  • Native CommonJS and ESM interop without the usual @rollup/plugin-commonjs dance
  • Code splitting with automatic and manual strategies, plus granular control via configuration
  • Multiple output formats including ESM, CJS, and IIFE
  • Built-in watch mode with file polling support
  • Dead code elimination and smart constant inlining enabled by default
  • Bundle analyzer built right in with markdown output

Getting Started

Install rolldown as a dev dependency in your project:

npm install -D rolldown

Or if you prefer yarn or pnpm:

yarn add -D rolldown
pnpm add -D rolldown

Platform-specific native binaries are installed automatically. Rolldown supports Linux (x64/arm64), macOS (x64/arm64), Windows (x64), and even has a WASM fallback for unsupported platforms.

Your First Bundle

The Config File Approach

The most straightforward way to use Rolldown is with a configuration file. Create a rolldown.config.ts in your project root:

import { defineConfig } from 'rolldown';

export default defineConfig({
  input: 'src/main.ts',
  output: {
    file: 'dist/bundle.js',
    format: 'esm',
  },
});

Then run it from the command line:

npx rolldown -c

That is all it takes. Rolldown picks up your TypeScript entry point, transforms it, and outputs a bundled ESM file. No babel plugin, no TypeScript plugin, no extra configuration.

The CLI Shortcut

For quick one-off bundles, skip the config file entirely:

npx rolldown src/main.ts --file dist/bundle.js

Going Programmatic

When you need bundling as part of a larger build script, the programmatic API gives you full control:

import { rolldown } from 'rolldown';

async function buildProject() {
  const bundle = await rolldown({
    input: 'src/main.ts',
  });

  await bundle.write({
    file: 'dist/bundle.js',
    format: 'esm',
  });

  console.log('Build complete');
}

buildProject();

There is also a simplified build function if you want everything in one call:

import { build } from 'rolldown';

await build({
  input: 'src/main.ts',
  output: {
    file: 'dist/bundle.js',
    format: 'esm',
  },
});

Leveling Up Your Builds

Multiple Entry Points and Code Splitting

Real-world applications rarely have a single entry point. Rolldown handles multiple entries and automatic code splitting out of the box:

import { defineConfig } from 'rolldown';

export default defineConfig({
  input: {
    app: 'src/app.ts',
    admin: 'src/admin.ts',
    worker: 'src/worker.ts',
  },
  output: {
    dir: 'dist',
    format: 'esm',
  },
});

Rolldown automatically extracts shared modules into separate chunks, so users downloading the app page and then navigating to the admin page do not re-download common dependencies.

Parallel Build Configurations

Need to output both ESM and CJS from the same source? Rolldown supports array configurations for parallel builds:

import { defineConfig } from 'rolldown';

export default defineConfig([
  {
    input: 'src/index.ts',
    output: {
      file: 'dist/index.mjs',
      format: 'esm',
    },
  },
  {
    input: 'src/index.ts',
    output: {
      file: 'dist/index.cjs',
      format: 'cjs',
    },
  },
]);

Watch Mode for Development

During development, you want instant rebuilds when files change. Rolldown has a built-in watcher:

import { watch } from 'rolldown';

const watcher = watch({
  input: 'src/main.ts',
  output: {
    file: 'dist/bundle.js',
    format: 'esm',
  },
});

The watcher monitors your source files and triggers incremental rebuilds automatically.

The Rollup Migration Path

If you are currently using Rollup, migrating to Rolldown is designed to be straightforward. The configuration format is intentionally compatible, so in many cases you can rename your config file and swap the package name. Most Rollup plugins work without changes because Rolldown implements the same hook system: resolveId, load, transform, renderChunk, and the rest.

The biggest difference is what you no longer need. Plugins like @rollup/plugin-typescript, @rollup/plugin-commonjs, and @rollup/plugin-node-resolve become unnecessary because Rolldown handles TypeScript transforms, CJS/ESM interop, and Node module resolution natively. That means fewer dependencies, less configuration, and fewer places for things to go wrong.

Where It Stands Today

Rolldown is currently at version 1.0.0-rc.7 with weekly release candidate updates. It passes over 900 Rollup tests and 670 esbuild tests, which speaks to its compatibility and correctness. Built-in minification is still in alpha, but dead-code-elimination-only minification is enabled by default as of rc.7.

The project has over 150 contributors, nearly 13,000 GitHub stars, and pulls in around 4.3 million weekly npm downloads. With Vite 8 beta already using it as the default bundler, adoption is accelerating rapidly.

Wrapping Up

Rolldown represents a significant step forward for the JavaScript bundling story. By combining Rust performance with Rollup compatibility, it avoids the usual tradeoff of choosing between speed and ecosystem support. For Vite users, it means a unified bundler that behaves the same in development and production. For everyone else, it means a fast, modern bundler with a proven plugin ecosystem ready to use. Whether you are starting a new project or looking to speed up an existing build pipeline, rolldown is worth putting on your radar.