Claude Fable 5 surpasses GPT-5.5 as AI code validation grows crucial

React’s compiler is being rewritten in Rust, and the numbers are already making every React dev sit up: the work-in-progress port is 3x faster than the Babel plugin baseline, with transformation logic clocking in at a full much faster improvement. Even at this early stage, it passes all 1,725 test fixtures. For teams fighting sluggish CI times or waiting on cold starts, this is a tectonic shift — a speed gain and a signal: React’s toolchain is moving from interpreted JS to native code. Here’s what’s changing, how Rust delivers that win over Babel, what works now, and what to watch as OXC and other modern toolchains go native-first.

What is the React compiler Rust rewrite and why it matters

The React compiler Rust rewrite is an active porting effort to replace major portions of the existing JavaScript compiler with high-performance Rust code. In plain terms: the same tool, but running close to the metal, trading JS’s dynamic overheads for Rust’s compiled, memory-safe speed. The result? Already, in preview, this port is 3x faster as a Babel plugin drop-in — and when measuring just the core code transformation logic, the gap stretches to much faster.

Why does this matter? For anyone maintaining or extending React’s internals, or for library authors and larger teams, the compiler is not just a background detail. It governs how JSX, hooks, and advanced patterns become runnable JS. Traditionally, Babel has been the engine beneath most React build workflows — capable, but constrained by the JavaScript runtime, its own single-threaded semantics, and legacy plugin layers.

Joseph Savona, leading this port, reports that not only does the Rust rewrite clear every one of the 1,725 test fixtures (validating correctness), but the team is prioritizing ecosystem compatibility. Early integration with tool maintainers like OXC and SWC points toward a native future for the entire ecosystem — and a developer experience unshackled from JS’s runtime costs.

Bottom line: this is not an isolated optimization. It’s a replatforming of React’s core build path, from the top-level framework down to every local feedback loop.

How does Rust improve React compiler speed compared to Babel?

The core question: why does moving from Babel’s JS (and Node) to Rust enable such outsized performance? The difference comes from how Rust compiles and executes code.

First, Rust is a statically compiled language: every type, allocation, and operation is checked ahead of time and translated to machine code. This cuts out the dynamic interpretation overhead that slows down Babel’s JS code — no more just-in-time compilation, no more runtime type checks. The React team measured the transformation layer alone at much faster faster than the baseline JS version.

Second, Rust’s memory model favors safe, predictable ownership and lifetimes, removing huge classes of bugs (and letting the compiler be smarter about reuse and locality).

Third, Rust enables concurrency. Babel (and the JS engine it runs on) is bottlenecked by the event loop and, at best, worker threads that share little. With Rust, the compiler pipeline can parallelize parsing, transformation, and output, using real threads with shared access to immutable data. Your big app’s hundreds of files? They can be parsed and processed at once.

Here are the practical results from the article:

- 3x faster performance as a Babel plugin (drop-in replacement)
- much faster faster transformation logic (measured in isolation)

These aren’t edge-case, best-case numbers. They reflect cold starts and real-world codebases, not synthetic microbenchmarks.

The upshot for any React dev: babel-plugin-level replacement today nets a 3x wall time win. The code transformation core — what every advanced code mod or metaframework hits — is now an order of magnitude faster. This resets expectations across the ecosystem.

What are the current capabilities and limitations of the Rust-based React compiler?

Where does the Rust port land on completeness and stability? Joseph Savona’s report gives some hard numbers: the port passes all 1,725 test fixtures — real-world samples, edge cases, and regression suites. Functionally, the logic is sound and the compatibility story begins strong.

But perfection is never instant. The rewrite is “work-in-progress,” and integration with the broader tool ecosystem is ongoing. The main focus now is collaborating with maintainers of modern toolchains like OXC and SWC, so the port isn’t just a drop-in CLI swap, but natively embedded in the fastest, evolving build systems.

What’s covered:

• All public fixtures for correctness
• Babel plugin mode already supported (3x speedup)
• Standalone transformation pass logs a much faster win

What’s pending:

• smooth integration with OXC (the next-gen toolchain aiming to supplant Babel/SWC in the future)
• Full-feature parity with existing Babel/JS plugins, especially for custom plugin authors
• Long-tail bug fixes and compatibility edge cases with very advanced or esoteric React usage

If you’re expecting a stable, production-static major-version release, you’ll want to track the changelogs and ongoing PRs. Bleeding-edge devs and infra maintainers, on the other hand, can get involved now — and should, if they want to help define the final API and ergonomics as integration matures.

How do developers use the new Rust-based React compiler in their projects today?

Here’s the most direct answer: you can start using the React Rust compiler port now, as an experimental Babel plugin replacement. The team is actively partnering with tool maintainers to allow an even more native integration (OXC, SWC, etc.), but Babel plugin mode is how you start.

Try the port
At this stage, you’d:

1. Clone or install the work-in-progress Rust compiler from the upstream repo (follow the latest instructions for experimental ports — this is not yet npm-install-stable).
2. Swap your current Babel plugin configuration to point at the Rust port. This may be a one-line config change, or a devDependency re-point, depending on your toolchain shape.
3. Run your build/test pipeline and validate output. Expect 3x faster plugin times and see transformation logs for evidence.

A typical config change might look like:

// babel.config.js
module.exports = {
  plugins: [
    // Replace this:
    // '@react/babel-plugin-compiler'

    // With this (synthetic example)
    'react-compiler-rust'
  ],
};

Or, if using a CLI workflow:

# run the Rust-powered compiler instead of JS-driven Babel
react-compiler-rust src/ --out-dir dist/

Experimental: not yet production-locked

• You should expect early bugs, plugin compatibility differences, and regular breaking updates.
• If your stack is heavily customized, test coverage is your lifeline: keep regression suites green.
• For teams building new React infra or coming from a greenfield, this is a chance to participate in shaping an emerging standard.

Watch for OXC/SWC collaboration:

• The biggest gains will come as the compiler becomes natively integrated with next-gen JS toolchains like OXC.
• The explicit mention: “actively partnering with tool maintainers to integrate this into OXC, SWC, and other ecosystems.”

The call to action: try it as a Babel plugin today, and track integration PRs for the full native experience.

What impact will the Rust rewrite have on the React ecosystem and developer experience?

The most practical effect is speed: faster CI builds, snappier incremental builds, and less time waiting for cold starts or distributed pipelines. But the second-order effects are bigger.

• CI/CD acceleration: For large teams, a 3x plugin time reduction multiplies across merges and branch deploys. much faster core transformation speeds cut big monorepo transformations from minutes to seconds.
• Local dev feedback loop: Faster builds mean faster feedback on hook/test runs, which compounds into happier, higher-velocity teams.
• Plugin ecosystem shift: Native compilers (Rust, OXC, SWC) will incentivize library authors to target these tools, de-emphasizing manually written Babel plugins or JS-based hacks. The net: a more uniform build ecosystem, with less accidental complexity.
• Rust momentum: A native, widely-adopted Rust codebase at the heart of React’s toolchain will inevitably encourage other projects to reconsider their JS baseline. Expect waves of new Rust-based tools, better interop, and a cross-pollination of best practices.
• Future-proofing: As more layers (parsers, transforms, bundlers) go native, teams escape limits imposed by JS-only stacks and open the door to new levels of static analysis, real multithreading, and memory safety.

For React devs, this is not just a tooling win but a signal: it’s time to expect serious, native performance from your JS stack.

What this enables for React devs

A much faster native speedup changes how you plan, not just how fast your builds run. Combined with a work-in-progress push toward OXC and SWC, the rewrite is laying groundwork for a toolchain where Rust-native performance is the baseline, not the outlier. For now, you can try the rust-powered compiler as a Babel plugin swap and benchmark your own codebase. In the coming months, expect tight coupling with modern toolchains — and a developer experience driven less by JavaScript’s ceilings, more by what the platform actually enables.

For those who’ve hit the wall with Babel plugin perf or want to future-proof their React infra, now is the time to watch this project, test the preview, and join the ecosystem’s shift to native speed. The hard parts — test coverage, initial integration — are already shipping. The rest is a matter of adoption.

If you want actionable steps: swap your Babel config, measure your speed, and follow the React/Rust/OXC convergence as it unfolds. This is where React’s optimization story gets rewritten for the next decade.