AINEWS
React Compiler, in Rust, Mostly Written by AI
Joseph Savona's experimental PR is a working case study for where AI coding carries weight in serious systems work, and where the human in the loop still matters.
Joseph Savona's experimental PR is a working case study for where AI coding carries weight in serious systems work, and where the human in the loop still matters.
When Joseph Savona, the React Compiler lead engineer, set out to port React's optimization pipeline to Rust, he architected the work by hand. The code that followed was mostly AI.
That is the description Savona wrote in the pull request for the experimental port (#36173), which he opened against the react/react public repository on March 30, 2026. The framing matters: the architecture, the public API shape, and the testing strategy were human decisions. The bulk of the implementation was not. The result is a real, public case study for the rest of the industry to read against the question of where AI coding actually helps in 2026, and where it still does not.
The port is explicit about its limits. Savona calls it "experimental, work-in-progress" and notes that "all fixtures pass, no known gaps but there may be lurking bugs." There are no builds published for the new Rust implementation, so any performance or speed claims about it should be read as the kind of numbers a benchmark author generates from their own machine, not as results that have survived independent runs. The PR is shared early "prior to testing internally at Meta, to get feedback from partners in parallel with continued development." Reading it as a shipped compiler rewrite would be wrong. Reading it as a finished, audited port would also be wrong.
What is in the PR is unusually specific. Test output is pasted in directly: yarn snap 1800/1800 passed (baseline 1799/1800), cargo test --workspace all green across 33 suites, and test-babel-ast.sh reports 1782/1782 round-trip, 1783/1783 scope info, and 1767/1767 rename cases passing. Those numbers are useful as a snapshot of one developer's local run. They are not the kind of result a reader should treat as a verdict on Rust performance, both because the benchmark setup has not been validated independently and because the PR is dated roughly two and a half months before the current discussion, long enough for follow-up work to have shifted the picture.
The shape of the port is itself a story. The Rust compiler takes a Babel AST plus scope information in, and produces a Babel AST out. It is positioned as a candidate for unifying the three frontend integrations the React Compiler currently ships: Babel, SWC, and the newer OXC. Today, each of those integrations has to compute scope information and bindings on its own. The Rust port assumes callers do that work, with a common::nullable_value deserializer and an explicit reflection-of-snapshots output semantic. The bindings-and-references computation is on the roadmap, not in this PR. Anyone reading "Rust React Compiler" as a single drop-in replacement for the existing pipeline is reading past the design.
The Rust toolchain choices are conventional: serde and serde_json for serialization, hermes-parser 0.28 or newer, and the test suite covers TS module-interop forms (TSImportEqualsDeclaration, TSExportAssignment, TSNamespaceExportDeclaration), Flow match syntax, and the usual JSX edge cases. None of that is exotic. What is novel is that most of it was written by AI, on top of a human-set architecture, by an engineer who is willing to say so on a public PR with 246,000 stars watching.
That is the most useful sentence in the PR. The story a wire report would write is "React Compiler being ported to Rust, mostly by AI." The more honest version is that the boundary in serious systems work in 2026 is not "human versus AI" in the abstract. It is "what is being decided" and "what is being generated." Architecture, API surface, and test strategy are decisions. They were human. AST visitors, deserialization plumbing, and routine cross-frontend glue are generation. They were AI. The interesting failure modes the PR itself surfaces are exactly the ones that fall on the wrong side of that line: benchmarks a human did not validate, integration work the AI port cannot yet do without a human in the loop, and possible lurking bugs no fixture can catch. A working toolchain PR is not evidence those failure modes have been resolved. It is evidence that the engineer is aware of them and shipping around them.
The PR is dated March 30, 2026, and there is no follow-up Meta blog, talk, or RFC in the public record that updates the picture. If the team has shipped builds, additional frontends, or third-party adoption since, the material in front of readers is incomplete. For now, the public artifact is a single, unusually candid PR: human architecture, AI-majority code, AI-derived benchmark numbers, and a working test suite that passes on one machine.
What to watch next: whether the bindings-and-references layer lands, whether Babel, SWC, or OXC contributors pick up the integration work, and whether anyone outside Meta runs the port against real-world React codebases and reports back. Those are the questions that will turn a notable PR into a verdict on Rust for the React Compiler. Today, the verdict is not in.