TL;DR:

  • Rspack is a Rust-based, webpack-compatible bundler from ByteDance — 5-10x faster than webpack on typical projects, with support for most webpack plugins and configuration syntax
  • Rsbuild, built on top of Rspack, gives you a higher-level build tool similar to Vite but with more complete webpack ecosystem compatibility
  • It’s production-ready for most use cases; the main reason not to migrate is reliance on webpack plugins that haven’t been ported yet

The JavaScript build tooling space has been moving fast for several years. Vite changed how most new projects are started. esbuild and SWC eliminated the argument that JavaScript tooling had to be slow. Rspack entered the picture from a different angle: instead of asking you to reconfigure your project for a new paradigm, it asked what would happen if you rewrote webpack in Rust.

The answer turns out to be: significantly faster builds, with enough webpack compatibility that most real projects can migrate without rewriting their configuration from scratch. That’s a different value proposition from Vite or Turbopack, and it’s why Rspack has found a place on large enterprise webpack projects that Vite couldn’t easily address.

What Rspack Is and Where It Came From

Rspack was developed internally at ByteDance to address build performance problems in very large JavaScript codebases. When your webpack build takes 15-20 minutes, the solution isn’t tuning webpack configuration — it’s replacing the bundler. ByteDance had enough webpack-dependent infrastructure that rebuilding around Vite’s module architecture wasn’t practical. Rewriting webpack’s core in Rust was.

The project was open-sourced in March 2023. Version 1.0 shipped in August 2024, marking the point where the team committed to API stability and production readiness.

The core design principle is webpack compatibility. Rspack implements webpack’s plugin API surface, its loader interface, and its configuration schema at a level of fidelity that means most webpack configurations work with minimal changes. This is different from Vite’s approach, which is architecturally different enough that webpack plugins don’t transfer.

Performance Numbers

Build time comparisons are context-dependent, but the broad finding across independent benchmarks is consistent: Rspack is 5-10x faster than webpack on cold builds, and 10-20x faster for incremental builds (the hot module replacement iteration time developers feel most in day-to-day work).

The gap comes from Rspack’s architecture. The core bundling work runs in Rust with parallelism that JavaScript-based bundlers can’t match. The overhead of calling into JavaScript for loaders and plugins still exists, but the critical path through the bundler itself is dramatically faster.

For reference against Vite: Vite is typically faster than Rspack on development server start time, because Vite’s development mode doesn’t bundle — it serves ES modules directly. For production builds of large projects, Rspack and Vite with Rolldown are comparable. For webpack-migrating teams, the Rspack numbers are the relevant comparison.

Webpack Compatibility in Practice

The compatibility claim deserves honest scrutiny. Rspack is compatible with most webpack plugins and loaders, not all webpack plugins and loaders.

The plugins that work well:

  • css-loader, style-loader, MiniCssExtractPlugin
  • HtmlWebpackPlugin
  • CopyWebpackPlugin
  • BannerPlugin, DefinePlugin, EnvironmentPlugin
  • Most TypeScript loaders
  • Most image and asset loaders
  • BabelLoader (though using Rspack’s built-in SWC transform is faster)

The plugins that may have issues or require alternatives:

  • Plugins that rely on internal webpack hooks that aren’t in Rspack’s compatibility layer
  • Very old webpack v4 plugins that were already deprecated
  • Some more obscure plugins that haven’t been tested against Rspack

The practical migration path for a large webpack project: start with Rspack’s compatibility mode, run the build, see what breaks. The breakage rate on typical enterprise webpack projects with common plugin stacks is low enough that most teams have migrated within a day or two of effort.

Rsbuild: The Higher-Level Option

Rsbuild is a build tool built on top of Rspack that abstracts the configuration complexity. If you’re starting a new project, or if you don’t need webpack’s configuration depth, Rsbuild is closer to the experience of using Vite or Create React App.

Rsbuild handles:

  • Framework presets (React, Vue, Svelte, and others)
  • CSS modules, PostCSS, Less, Sass out of the box
  • TypeScript without additional configuration
  • Hot module replacement configured correctly by default
  • Build optimisation presets

For teams evaluating whether to start a new project with Vite or with Rspack, Rsbuild is the appropriate comparison point. It brings similar ease-of-use while inheriting Rspack’s webpack compatibility for cases where you need to pull in a specific webpack plugin.

Module Federation

One area where Rspack has invested significantly is Module Federation compatibility. Webpack’s Module Federation 1.0 (for sharing modules between separately deployed apps at runtime) is well-supported. Rspack also has early support for Module Federation 2.0, including typed module declarations.

For micro-frontend architectures that have been built around webpack Module Federation, Rspack offers a migration path that Vite doesn’t currently match at the same maturity level.

Who Should Migrate

Strong candidates for Rspack migration:

Projects with webpack build times over two minutes. The productivity cost of slow builds compounds through the day. If your CI builds take 15 minutes and your dev rebuild takes 30 seconds, Rspack is worth the migration effort.

Large webpack codebases with complex configurations. The webpack compatibility means you’re not throwing away existing configuration investment.

Teams evaluating Turbopack. Rspack is more stable and more webpack-compatible than Turbopack currently, particularly outside Next.js contexts. For non-Next projects exploring Rust-based bundling, Rspack is the practical choice.

Cases where migration is less urgent:

Projects already on Vite that are working well. There’s no particular reason to move a working Vite setup to Rspack.

Very small projects where build times aren’t a bottleneck. The migration has a real cost, even if small; don’t pay it if you’re not hitting the problem.

Projects heavily dependent on the specific webpack plugins that haven’t been ported. Check your plugin list against Rspack’s compatibility documentation before committing to the migration.

Getting Started

The Rspack documentation includes a migration guide from webpack that covers the common cases. For projects using Create React App, Rspack provides rsbuild migrate tooling that automates much of the configuration conversion.

The typical migration steps:

  1. Replace webpack with @rspack/core in package.json
  2. Update the config filename to rspack.config.js (or keep webpack.config.js with Rspack’s webpack compatibility mode)
  3. Run the build and address any plugin compatibility issues
  4. Optionally, switch from babel-loader to Rspack’s built-in SWC transform for additional speed gains

The Rspack team maintains an active Discord and responds quickly to plugin compatibility issues filed on GitHub. For open-source projects with legitimate compatibility problems, fixes tend to arrive within a few weeks.

Further Reading