The React Compiler is now a Rust program, and Next.js 16.3 lets you flip it on
Meta merged a Rust port of the React Compiler, most of it written by AI under human-guided architecture. Next.js 16.3 wires it into Turbopack behind an experimental flag, with early tests showing 20 to 50 percent faster route compilation.
The React Compiler, the tool that auto-memoizes components so developers can stop
hand-writing useMemo and useCallback, has been rewritten from TypeScript into
Rust. Meta merged the port in June, and this week the story reached wider
developer attention as Next.js 16.3 shipped an experimental flag that runs the
Rust compiler natively inside Turbopack. For anyone already using the compiler,
the practical change is that the slowest, most Babel-bound part of the build is
being replaced with native code.
What actually shipped
React Compiler engineer Joseph Savona opened PR #36173, labeled an experimental, work-in-progress port, and merged it into the React monorepo on June 9. Two details make it notable beyond the language switch. First, the public interface is deliberately unchanged: the compiler takes a Rust representation of the Babel AST in and hands one back, so each integration (Babel, OXC, SWC) converts to and from its own format and existing configs keep working. Second, per Savona’s own writeup, the architecture was human-guided but the majority of the code was written by AI, with all 1,725 test fixtures passing and intermediate compiler states matching the TypeScript version almost byte for byte.
That verification bar is the part worth holding onto. A compiler is close to a worst case for a machine-assisted rewrite: one wrong transform silently ships broken memoization to every component. The port cleared it by checking the Rust output against the original at each pass, not by trusting that the tests would catch everything after the fact.
Why Rust, and why now
The compiler has been stable in Next.js since the 16.0 release, but only as a Babel transform. On large apps that meant paying JavaScript execution cost on every build, and the SWC plugin path routed through a WebAssembly bridge that serialized the AST, ran the compiler in WASM, and deserialized the result, with a slow cold start on top. Linking a native Rust compiler directly into Turbopack, Vercel’s Rust bundler, removes that entire round trip because the compiler and the bundler are the same binary.
The measured wins line up with that argument. Next.js reports 20 to 50 percent faster route compilation in early tests against large React apps like v0, and Vercel engineer Andrew Imm reported over 40 percent faster compilation when the Rust compiler is linked straight into Turbopack rather than run as a plugin. Independent benchmarking cited by InfoQ puts the drop-in Babel replacement around three times faster than the TypeScript original, and closer to ten times on the isolated transform logic before serialization overhead eats into it. The numbers vary because the bottleneck being removed varies, but they point the same way.
What it means for working developers
If you run the React Compiler on a Next.js app, you can try the native path today
by setting reactCompiler: true and the experimental
turbopackRustReactCompiler flag in next.config. The API is the same, so this
is a build-speed change rather than a code change, and the honest framing is that
it is experimental: worth enabling on a branch to measure against your own app,
not something to assume in a production pipeline yet. Vercel has signaled deeper
direct-into-Turbopack integration is targeted for a later release, so the gains
should widen as the plugin boundary disappears.
The broader signal is that the React Compiler is moving out of the JavaScript toolchain it was born in. For years the argument against adopting it was build overhead; if a native compiler makes memoization effectively free at build time, the calculus for turning it on across a large codebase changes.
The pattern behind the port
This is the second major JavaScript-ecosystem project in a month to be ported to Rust with AI doing the bulk of the typing and humans owning the architecture and review. Bun’s runtime made the same jump from Zig, and in both cases the reusable lesson was not “AI can now do rewrites” but “AI can now do rewrites when you build the verification harness around it.” The React port’s fixture-by-fixture output matching is that harness in a different shape.
The open questions are the same ones that follow any generated-code milestone: how maintainable a machine-written Rust compiler is for the team that has to extend it, and whether the experimental flag graduates to a default or stalls. Over the next quarter the signals to watch are whether the direct Turbopack integration lands in a stable release, whether the reported compilation wins hold up outside Vercel’s own apps, and whether non-Turbopack bundlers pick up the native compiler through the OXC and SWC integration points. Stackmaven will check back on or around October 21.