Vite vs Turbopack vs Rspack vs Farm: Which Bundler Should You Start a New Project With in 2026?

The bundler landscape has fragmented in the best possible way. Two years ago you were choosing between webpack (slow) and Vite (fast). Now there are four serious contenders — Vite, Turbopack, Rspack, and Farm — each with a legitimate claim on your next project, and each fighting for the title of best frontend bundler in 2026.

I benchmarked all four on an identical mid-size React/TypeScript application: 150 components, ~80,000 lines of TypeScript, 40+ npm dependencies, CSS Modules throughout, and a monorepo structure with two packages. The kind of app where bundler choice actually shows up in your day.

Vite vs Turbopack vs Rspack vs Farm: The Real Numbers

All runs on an M3 MacBook Pro with a warm filesystem cache. Node 22, pnpm 9.

A few things the table doesn't show: Vite's HMR edge is genuinely impressive for a non-Rust bundler — Evan You's Rolldown integration is paying off. Turbopack's production build requires the --turbopack flag in Next.js 15 and remains opt-in for complex configs. Farm's cold start is fast enough that you'll notice it the very first time you run it.

Vite: Still the Right Default

Vite 6 with Rolldown is a different beast from Vite 3. Production builds are now Rust-powered (Rolldown replaced Rollup internally), which closes most of the speed gap with Rspack. The HMR remains best-in-class because Vite decouples the dev server from bundling entirely.

The ecosystem advantage is decisive. Vite plugins cover everything. Vitest shares your Vite config directly — no separate test bundler to configure. Storybook 9 defaults to Vite. Every React meta-framework except Next.js either uses Vite or supports it natively.

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

export default defineConfig({
  plugins: [react()],
  build: {
    rollupOptions: {
      output: {
        manualChunks: {
          vendor: ['react', 'react-dom'],
          charts: ['recharts'],
        },
      },
    },
  },
})

Nothing surprising. That's the point. Use Vite for any new React, Vue, Svelte, or plain TypeScript project that isn't locked to Next.js. The production build speed gap vs Rspack is now small enough that it won't be your bottleneck on any reasonable CI pipeline.

Turbopack: Fast, But Read the Small Print

Turbopack is Vercel's Rust-based bundler, built specifically to power Next.js. Sub-500ms cold starts, snappy HMR, and deeply integrated with the Next.js build pipeline.

The caveats are real. Turbopack isn't a standalone bundler you configure yourself — it's a Next.js implementation detail. You opt in with next dev --turbopack (now the default in Next.js 15) and write a next.config.ts, not a Turbopack config. Webpack plugins don't work. Some CSS-in-JS setups and SVG import strategies need reworking. The docs don't mention how often this trips up teams migrating from older Next.js versions — I've seen it burn an entire afternoon.

Outside of Next.js, Turbopack doesn't exist for you yet. If that is your stack, stop fighting it and embrace the default.

Rspack: The webpack Alternative That Actually Works

Rspack is the most pragmatic option on this list. It's a webpack-compatible Rust bundler from ByteDance, and compatible is the operative word — webpack configs migrate with minimal changes, webpack loaders work, and most webpack plugins work.

// rspack.config.mjs
import { defineConfig } from '@rspack/cli'

export default defineConfig({
  entry: './src/index.tsx',
  module: {
    rules: [
      {
        test: /\.tsx?$/,
        use: 'builtin:swc-loader',
        type: 'javascript/auto',
      },
    ],
  },
})

The builtin:swc-loader replaces ts-loader and babel-loader with a single Rust-based transform. That's where most of the speed comes from. No separate transpiler config to maintain.

Rspack's sweet spot is large existing webpack projects that are too big to rewrite. Migration can be done incrementally — you won't need to port everything at once. If you're working in a monorepo with shared package configs, Rspack slots in naturally because it matches webpack's mental model exactly.

For greenfield projects, Rspack is a harder sell. You're buying into webpack's config complexity without the ecosystem forcing your hand. Vite's config is cleaner when you have a choice.

Farm: The Dark Horse

Farm is the newest entrant and posts the fastest cold-start numbers by a noticeable margin. Written entirely in Rust, it uses a Vite-compatible plugin API — many Vite plugins work without changes — and takes a different approach to incremental compilation that keeps subsequent rebuilds fast.

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

export default defineConfig({
  plugins: [react()],
  compilation: {
    input: { index: './index.html' },
  },
})

The similarity to Vite's API is intentional. Farm explicitly targets Vite users who want more speed without switching mental models.

The catch: Farm is version 1.4 and the community is still small. You will hit edges. The docs don't mention some config interactions, and when you hit a weird CSS Modules issue at 11pm there may not be a Stack Overflow answer. I spent 20 minutes tracking down a composes quirk that turned out to be buried in a GitHub issue comment from three months ago. That's the tax on being early.

Farm is worth watching and worth trying on a side project. Not quite ready to be the default recommendation for a team project in 2026.

Decision Matrix: Pick by Project Type

The Verdict

Start new projects with Vite. The ecosystem is unmatched, the config is clean, and Rolldown has closed the production build speed gap enough that it won't be your bottleneck.

If you're on Next.js, Turbopack is your bundler — you don't choose it, you just stop fighting it.

If you're migrating an existing webpack project, Rspack is the right call. A weekend migration beats a three-week rewrite.

Farm is impressive. Check back in six months.

The vite vs turbopack debate has a boring answer: it depends on your framework. The more interesting question is whether you're defaulting to the right bundler for your stack — and most teams aren't yet taking advantage of Turbopack for Next.js, which is leaving cold-start performance on the table every day.