React Compiler goes Rust, and Next.js 16.3 can already use it

The React team has rewritten the React Compiler in Rust, and the payoff is starting to show up in real build times. The Rust port landed in the React monorepo in early June (PR #36173), and Vercel wired it into Turbopack a few weeks later. In Next.js 16.3 you can now opt into the native compiler and skip the old Babel path entirely.

Quick recap for anyone who hasn't touched it: the React Compiler (once called React Forget) automatically memoizes your components and hooks, so you stop hand-writing useMemo and useCallback. It has been stable in Next.js since 16.0. The catch was how it ran. As a Babel transform it added JavaScript execution overhead on every build, and on large apps that became a real bottleneck while Turbopack's Rust pipeline sat idle waiting on it.

What actually got faster

The Rust rewrite changes the economics. The React team reports the port runs about 3x faster as a Babel plugin, and up to 10x on the isolated transformation logic. The bigger win comes when the compiler stops being a plugin at all. Linked directly into Turbopack, Vercel's Andrew Imm measured over 40% faster compilation on v0, their own large Next.js app, partly because the earlier SWC plugin path suffered from a slow WebAssembly cold start. The official Next.js figures land at 20 to 50% faster route compilation across their test apps.

One honest caveat before you get excited: this is experimental, and the React team labelled the port itself a work in progress. The architecture was human-guided but, by the author's own account, mostly written by AI. All the compiler's test fixtures pass and the output matches the TypeScript version for 99.9% of Meta's codebase. But 99.9% is not 100%, and it is opt-in for a reason.

How we'd roll it out

When we build cloud-native apps for enterprise clients, a compiler or bundler swap is exactly the kind of change that looks free and then eats a sprint. So treat this as a measurement exercise, not a faith exercise.

Turn it on in a branch, not in your main build lane. In Next.js 16.3 the flags are explicit: set reactCompiler: true and experimental.turbopackRustReactCompiler: true, and remember it only affects the Turbopack path, not --webpack. Then benchmark your own app. The 20 to 50% range is Vercel's number on Vercel's apps. Your gain depends on how compiler-heavy your components are and how cold your CI caches start.

The part we'd watch hardest is output parity. A compiler that memoizes slightly differently can change render behaviour in ways your unit tests miss. From our PHP and Docker work we've learned to pin toolchain versions in CI and diff build output between the old and new path before shipping. Do the same here: run your full end-to-end suite on the Rust path, compare bundle output, and keep the Babel path as a one-flag rollback until you trust it.

The bigger signal

There's a second-order trend worth naming. This is part of a steady move of frontend tooling into Rust. SWC now builds on the official Rust compiler, Oxc ships it as crates, and Rspack 2.1 added native support. Not every attempt has been clean, the Rolldown maintainer pulled their Rust React Compiler integration to tidy it up first, so the transition isn't finished. But the direction is set. If your build tooling is a pile of custom Webpack loaders and dynamic requires, that debt is going to get more expensive to carry.

Mobile teams shouldn't tune this out either. In our native and React Native projects the same pattern holds: the compiler runs there too, and predictable build times matter even more when your CI is already juggling native toolchains. And on the security side, from our pentesting engagements the lesson is boring but real. Every new build dependency is new supply-chain surface. An experimental, AI-assisted compiler in your pipeline earns a dependency review, not a blind install.

One thing to do today

Even if you never flip the Rust flag: if you're on Next.js and not using the React Compiler at all yet, that's the bigger missed win. Enable reactCompiler on a branch, delete a batch of manual useMemo and useCallback calls, and measure the render and build impact. The Rust port just makes that path cheaper to adopt later, once it graduates out of experimental.

If chasing build times or untangling a crate of custom bundler config sounds familiar, let's talk. We help web and mobile teams ship faster without betting production on an experimental flag.