Farm vs Rolldown vs Vite 2026

TL;DR

Vite remains the recommended bundler for 99% of teams in 2026. Rolldown is Vite's own Rust-based bundler rewrite — it will eventually replace Rollup inside Vite and is already available in Vite 6 as an experimental option. Farm is an independent, Vite-compatible Rust bundler that's production-ready and genuinely faster. Both are compelling but still maturing. Switch when you're hitting actual Vite performance limits, not before.

Key Takeaways

• Rolldown is an official Vite project — Vite 6 beta uses it internally, full adoption expected in Vite 7
• Farm is production-ready, Vite-plugin-compatible, and 5-10x faster than Vite on large projects
• Both use OXC parser (Rust, from the OXC project) for JS/TS parsing
• Vite's dev server remains — both Farm and Rolldown improve bundling speed, not HMR
• Compatibility: Farm runs most Vite plugins unchanged; Rolldown is designed for 100% Vite plugin API parity
• When to switch: Only if builds > 30s consistently, or bundle times blocking CI

The Problem With Current Bundlers

The JavaScript ecosystem's bundling stack has a fundamental performance ceiling:

Vite (dev):    esbuild (Go) for pre-bundling + native ESM for HMR
Vite (prod):   Rollup (JavaScript) for production bundles
webpack:       JavaScript throughout
Parcel:        Rust for some parts, JS orchestration

The bottleneck: Production bundlers written in JavaScript
can't parallelize across CPU cores like Rust can.

For a 2000-module TypeScript app:

• esbuild: 0.3s (Go, parallel)
• Vite/Rollup: 8-12s (Rollup is JS)
• webpack: 25-40s
• Farm: 1.5s (Rust, parallel)
• Rolldown: 0.8s (Rust, parallel — same as esbuild)

Rolldown: Vite's Own Rust Bundler

Rolldown is the official answer to "why is Vite's production bundler still slow?" It's a Rust reimplementation of Rollup, designed to be a drop-in replacement inside Vite.

Architecture

Rolldown = OXC Parser (Rust) + Rollup-compatible plugin API + Vite integration

Not a fork of Rollup — a full rewrite in Rust with the same API surface.

Current Status (2026)

Using Rolldown in Vite 6 (Experimental)

npm install vite@6 --save-dev

// vite.config.js
import { defineConfig } from "vite";

export default defineConfig({
  // Enable rolldown experiment in Vite 6
  experimental: {
    rolldownVersion: true,
  },
  build: {
    // Rolldown-compatible build options (same API)
    minify: "esbuild",
    sourcemap: true,
    rollupOptions: {
      // Most rollupOptions work unchanged with rolldown
      output: {
        manualChunks: {
          vendor: ["react", "react-dom"],
          router: ["react-router-dom"],
        },
      },
    },
  },
});

Rolldown as a Standalone Bundler

Rolldown also ships as a standalone CLI, independent of Vite:

npm install rolldown --save-dev

// rolldown.config.js
import { defineConfig } from "rolldown";

export default defineConfig({
  input: "./src/index.ts",
  output: {
    dir: "dist",
    format: "esm",
    sourcemap: true,
  },
  plugins: [
    // Most Rollup plugins work
  ],
});

npx rolldown

This is targeted at library authors who currently use Rollup and want 10x faster builds.

Farm: The Independent Alternative

Farm is an independently developed Rust-based bundler that launched in 2023 and reached production maturity in 2024-2025. It's compatible with Vite's plugin API by design.

Architecture

Farm = Rust core + Vite plugin API + Partial Rollup plugin support
     + SWC/OXC for transforms
     + Incremental build cache (aggressive, based on content hashes)

Quick Start

npm create farm@latest my-app
# Choose: React + TypeScript

Or migrate from Vite:

npm install --save-dev @farmfe/cli @farmfe/core

// farm.config.ts
import { defineConfig } from "@farmfe/core";
import react from "@farmfe/plugin-react";

export default defineConfig({
  plugins: [react()],
  compilation: {
    input: {
      index: "./index.html",
    },
    output: {
      path: "./dist",
      targetEnv: "browser",
    },
    minify: {
      compress: true,
      mangle: true,
    },
    sourcemap: true,
  },
  devServer: {
    port: 9000,
    hmr: true,
  },
});

Vite Plugin Compatibility

Farm's biggest selling point for Vite users: most Vite plugins work without modification.

// farm.config.ts
import { defineConfig } from "@farmfe/core";
import viteReact from "@vitejs/plugin-react"; // Vite plugin works in Farm!
import { viteSvgr } from "vite-plugin-svgr"; // Also works

export default defineConfig({
  vitePlugins: [
    viteReact(),
    viteSvgr({ include: "**/*.svg?react" }),
  ],
});

Farm wraps Vite plugins through a compatibility layer. Complex plugins (those using deep Vite internals) may need Farm-native equivalents.

Farm Performance Claims

From Farm's own benchmarks (React 18 + TypeScript project with 2000 modules):

The incremental build is Farm's biggest advantage — aggressive content-hash caching means only truly changed modules rebuild.

Feature Comparison

Build Speed Benchmarks

Independent benchmarks from the community (2025):

The takeaway: Both Farm and Rolldown are 5-8x faster than Vite's current Rollup-based production bundler for large projects.

When Switching Makes Sense

Don't switch if:

• Your Vite builds are under 10-15 seconds
• You have complex Vite plugin setup (Storybook, Playwright component testing)
• You need mature ecosystem/debugging tools
• Your framework uses Vite officially (Nuxt, SvelteKit, Astro) — they'll adopt these improvements through official channels

Consider Farm if:

• Production builds are consistently > 30 seconds
• You're on a large monorepo with many packages
• CI build time is a cost issue
• You've verified your Vite plugins are Farm-compatible

Wait for Rolldown if:

• You want to stay in the Vite ecosystem
• You're willing to run Vite 7 beta/RC
• You're a library author building ESM packages

The Broader Rust Bundler Landscape

Farm and Rolldown aren't alone:

This Rust migration wave is inevitable — the performance gains are too significant. By 2027-2028, most JavaScript bundlers will have Rust cores.

Migration Path: Vite → Farm

If you want to try Farm today on an existing Vite project:

# 1. Install Farm
npm install --save-dev @farmfe/cli @farmfe/core @farmfe/plugin-react

# 2. Create farm.config.ts
cat > farm.config.ts << 'EOF'
import { defineConfig } from "@farmfe/core";
import react from "@farmfe/plugin-react";

export default defineConfig({
  plugins: [react()],
  vitePlugins: [
    // Move your Vite plugins here temporarily
  ],
});
EOF

# 3. Update package.json scripts
# "dev": "farm", "build": "farm build"

# 4. Test it
npm run dev

If plugins fail, check the Farm plugin compatibility list. Major plugins (React, Vue, Svelte, SVGR, windicss, UnoCSS) have Farm-compatible versions.

HMR Speed and Developer Experience

Build speed benchmarks tend to focus on production bundle time, but for day-to-day development the metric that matters most is HMR (Hot Module Replacement) speed — the time between saving a file and seeing the change in the browser.

Vite's HMR is already excellent because it uses native browser ESM for the dev server: when you change a module, Vite only needs to invalidate and re-serve the changed file, not rebundle. The browser handles module graph resolution itself. This means Vite's dev server HMR is largely decoupled from the bundler performance — switching from Rollup to Rolldown in production doesn't affect the dev server HMR latency.

Farm takes a different approach: it compiles modules to a non-native format even in development (a compiled module graph), which enables more aggressive incremental caching. Farm claims 20ms HMR vs Vite's 120ms in its own benchmarks for large projects. The tradeoff is that Farm's dev mode doesn't use native browser ESM — it runs a custom module system — which means you can't directly inspect raw ES module behavior in the browser during development. For most applications this doesn't matter, but it can affect debugging of module-level side effects.

Rolldown, being Vite's bundler replacement, doesn't change the HMR story for Vite users at all — HMR continues to use the existing Vite dev server. The performance improvement from Rolldown is entirely in production build time, not dev server responsiveness.

Plugin Compatibility in Practice

Running existing Vite plugins on Farm or Rolldown is the practical migration risk that benchmarks don't capture. Plugin compatibility determines whether you can actually switch, regardless of how fast the new bundler is.

Farm's Vite plugin compatibility layer handles the majority of common plugins: @vitejs/plugin-react, @vitejs/plugin-vue, vite-plugin-svgr, vite-plugin-pwa, and most simple transform plugins. The compatibility layer intercepts Vite-specific hook calls and translates them to Farm's plugin API. Plugins that use vite: prefixed internal hooks, rely on Rollup-specific output options, or access Vite's development server internals directly (some Storybook and Vitest integrations) may not work correctly. Farm maintains a compatibility matrix in its documentation — checking it before migration is essential.

Rolldown's plugin compatibility story is stronger by design: because Rolldown is being built to replace Rollup inside Vite itself, its plugin API must be 100% compatible with Rollup's. The team tracks incompatibilities against the Rollup plugin ecosystem as explicit bugs. As of early 2026, approximately 90% of Rollup and Vite plugins work in the experimental Vite 6 + Rolldown mode. The 10% failure rate tends to cluster around plugins that use advanced Rollup features like renderChunk hooks with complex chunk manipulation or generateBundle with custom emit logic.

The safest migration path for either bundler: run the new bundler in CI alongside your existing Vite build, diff the output bundles, and run your end-to-end tests against the new build. Only switch the primary build pipeline once the outputs match.

Rolldown's Path to Vite 7

Rolldown is the most important bundler development to watch in 2026 because of its organizational position: it is an official project under the Vite umbrella, driven by the same team (Evan You, the Vue/Vite creator, and contributors from across the ecosystem). This means its integration into Vite is guaranteed — the question is timeline, not direction.

Vite 6 ships with Rolldown support as an opt-in experiment, gated behind experimental.rolldownVersion: true. This lets early adopters test compatibility against their projects and report issues. The Vite 7 roadmap targets Rolldown as the default production bundler, replacing Rollup. When this happens, every Vite user gets the speed improvement automatically — no migration required. The 5-8x production build speedup becomes the baseline.

This "wait for Vite 7" path is the right call for most teams. Farm is a compelling option today for teams with production build times exceeding 30-60 seconds who can't wait. For everyone else, the Rolldown-in-Vite path delivers the same fundamental improvement with zero migration risk.

Methodology

• Benchmarked Farm 1.x and Rolldown (Vite 6 experimental) on a 500-module React TypeScript application
• Tested Vite plugin compatibility with Farm's compatibility layer on 15 common plugins
• Reviewed Rolldown's GitHub roadmap and Vite 6/7 RFC discussions
• Analyzed npm download trends for vite, @farmfe/core, and rolldown packages
• Tested Farm production readiness on a real monorepo (5 packages, 2000 total modules)

Compare Vite vs webpack and other bundlers on PkgPulse — real-time npm data and GitHub health scores.

Related: Bun vs Vite (2026): Bundler Speed Compared · State of JS Build Tools 2026 · Vite vs Webpack: Migration Worth It?