How Rust Is Displacing JavaScript in Front‑End Toolchains: Insights from Rspack, Turbopack, and Bun

Five years ago Lee Robinson, then at Vercel, warned that Rust would become the future of the JavaScript toolchain. In a 2026 update titled “Rust Is Eating JavaScript,” he notes that the prediction has materialized in three major front‑end tools: Rspack, Turbopack, and Bun.

Rust replaces the most resource‑hungry parts of the toolchain

Rust is not meant to replace business‑logic code or eliminate JavaScript runtime in browsers. Instead, it targets the most CPU‑, memory‑, and parallelism‑intensive stages of the toolchain, such as parsing JavaScript/TypeScript/CSS, AST transformation, code minification, tree‑shaking, module‑graph construction, incremental caching, file scanning, dependency analysis, and parallel compilation. These stages historically ran in Node.js processes, which become bottlenecks at large scale due to single‑threaded execution, object allocation, and inter‑process communication costs.

By moving these hot paths into native Rust cores while keeping JavaScript APIs, configuration files, and plugin interfaces, tool authors give developers a faster engine without changing the familiar command‑line experience.

Rspack: Rust‑powered compatibility with webpack

Rspack rewrites the bundling core in Rust but strives to stay compatible with webpack’s API, loaders, and plugin ecosystem, avoiding a forced migration for existing projects. This pragmatic approach solves the dilemma of large teams needing faster builds and hot‑module replacement while preserving years of webpack configuration.

Rspack 1.0 launched in August 2024; by version 2.0 (2026) weekly downloads grew from 100 k to 5 M. Rspack 2.0 adds modern ESM output, static analysis, code splitting, and persistent caching while still supporting webpack plugins.

The key insight is that native performance and legacy ecosystem compatibility can advance together, though communication overhead between JavaScript loaders and the Rust core remains a cost that the Rspack team mitigates by optimizing loader composition.

Turbopack: From experiment to Next.js’s default bundler

Turbopack took a different route, designing its architecture around Rust, multi‑core parallelism, and fine‑grained incremental computation from the start. It avoids recomputing unchanged files and limits reprocessing to the affected module subtree.

After a lengthy Alpha phase in Next.js 13, Turbopack reached stable status in Next.js 16 and became the default bundler for new projects. Official benchmarks show a 2‑to‑5× speedup in production builds and up to a 10× improvement in Fast Refresh, based on Next.js’s internal testing across real‑world projects.

These results demonstrate that a Rust‑native core can move from performance experiments to everyday use in a mainstream framework.

Bun: A Zig‑originated runtime rewritten in Rust

Bun originally combined runtime, package manager, test runner, and bundler into a single executable built with Zig. In May 2026, the project announced a rewrite of its core in Rust, citing reduced memory‑related bugs and the safety guarantees of the Rust compiler.

The Rust version passed Bun’s cross‑platform test suite, fixed several memory leaks, and reduced binary size from roughly 8 MB to 3 MB. Performance benchmarks were mixed—some cases matched the original speed, others were slightly faster.

Community reviewers quickly identified a surge of unsafe code introduced during the migration, prompting the Bun team to audit and fix the issues. The episode underscores that switching to Rust does not automatically guarantee safety; careful code review remains essential.

Should front‑end developers learn Rust?

For most business‑logic development, learning Rust is not mandatory; JavaScript and TypeScript remain the primary interfaces for browsers, Node.js, and front‑end frameworks. However, developers working on build tools, compilers, runtimes, database drivers, or high‑performance Node.js extensions should consider Rust, as the ecosystem now offers mature bindings (napi‑rs), WebAssembly support, and pre‑compiled binaries that integrate smoothly with npm.

The broader lesson is to evaluate which logic belongs in the flexible JavaScript layer versus which should be sunk into a native core, to assess whether cross‑language call overhead offsets performance gains, and to balance ecosystem compatibility with architectural redesign.

Five years after Lee Robinson’s initial observation, Rspack, Turbopack, and Bun have demonstrated that Rust can power the most compute‑intensive parts of the JavaScript toolchain while leaving the language itself untouched for business code.

Going forward, developers will continue writing .js, .ts, and package.json files, but the heavy lifting of parsing, bundling, and incremental recompilation will increasingly be delegated to Rust.