Evan Lee Salim
In a move that signals a tectonic shift in the JavaScript ecosystem, Meta has officially merged a Rust-based port of the React Compiler into its primary repository. Formerly known by its internal codename "React Forget," the compiler is a transformative tool designed to liberate developers from the manual burden of useMemo and useCallback by automating component memoization. By moving from a TypeScript-based implementation to Rust, the React team is not merely seeking incremental improvements; they are aiming for a fundamental leap in performance, build times, and architectural synergy with the modern Rust-based frontend toolchain.
The Evolution of React Forget: A Chronology of Change
The journey of the React Compiler began as an ambitious attempt to solve the "re-render problem" that has plagued React developers for over a decade. The original TypeScript implementation served as a proof-of-concept, validating that an automated compiler could safely and effectively manage memoization without introducing regressions in complex UI trees.
However, as the compiler matured, the limitations of its TypeScript foundation became apparent. While functional, the performance overhead of running a compute-intensive transformation tool within a JavaScript-based environment—specifically as a Babel plugin—created a bottleneck.
The transition to Rust did not happen overnight. The React team initiated a massive, experimental refactoring effort, utilizing large language models (LLMs) to assist in the "mechanical" aspects of the translation. This decision has since become a focal point of industry debate. Following the rewrite, the project entered a period of rigorous testing, ensuring that the Rust version achieved parity with the TypeScript original. By mid-2025, the team confirmed that all 1,725 existing test fixtures passed, with intermediate states matching the legacy implementation almost byte-for-byte—a feat achieved through sophisticated memory management techniques like arena allocation and index-based data structures.
Performance Metrics: The Rust Advantage
The primary driver for this rewrite is raw speed. When running as a drop-in Babel plugin, the Rust version demonstrates approximately 3x faster execution than its TypeScript predecessor. In more granular testing—specifically regarding isolated transformation logic—that figure climbs to a staggering 10x improvement. While serialization overhead in real-world applications often tempers these peak numbers, the gains remain undeniably significant.
The most transformative performance leaps, however, occur when the compiler moves beyond the "plugin" architecture. Because the React Compiler previously operated as a Babel transform, bundlers were forced to pay a "tax" on every build. By linking the Rust compiler directly into Turbopack, Vercel’s high-performance Rust bundler, the team eliminated the overhead associated with cross-language communication.
Vercel engineer Andrew Imm reported that this integration resulted in over 40% faster compilation times when tested against "v0," the company’s own large-scale Next.js application. These gains are particularly vital given that earlier attempts to run the compiler via SWC plugins often suffered from long WebAssembly cold starts. According to official reports from the Next.js team, developers can expect 20% to 50% faster route compilation across test suites, with support arriving in Next.js 16.3.
Official Responses and Industry Reception
The move has sent ripples through the frontend community, with reactions ranging from enthusiastic support to cautious skepticism.
The React Compiler working group has been transparent about the experimental nature of the port, labeling it a work-in-progress even as it lands in the main repository. For the average developer, the transition is intended to be seamless. The public API remains consistent with existing Babel configurations, meaning that upgrading should, in theory, be a drop-in replacement. For teams looking to adopt the technology, the React documentation provides an extensive guide on incremental adoption, allowing developers to exclude non-compliant code and migrate at their own pace.
However, the use of LLMs in the rewriting process has sparked intense debate on platforms like Hacker News. One developer noted the potential for "cognitive debt," questioning whether a codebase written largely by AI—and subsequently maintained by humans—could eventually become opaque and unmanageable. "Is the LLM foundation solid enough to build upon?" the user asked. "Or does this cause projects to become unmaintainable because no person understands the implementation anymore?"
Others raised technical concerns regarding the quality of the generated code. A common critique is that LLMs often favor "quick fixes" to satisfy the Rust borrow checker—such as over-relying on RefCell or interior mutability—rather than refactoring to idiomatic, safe Rust. This, critics argue, risks pushing potential compile-time failures into runtime, effectively negating some of the safety guarantees that Rust is famous for.
The Broader Context: Rust’s Dominance in Frontend Tooling
The React Compiler’s shift is part of a broader, industry-wide migration toward Rust-based infrastructure. We are currently witnessing a consolidation of the JavaScript toolchain, with projects like SWC migrating to the official Rust compiler, Oxc (the Oxidation Compiler) vending its own crates, and Rspack 2.1 shipping native, high-performance support.
Yet, this transition has not been without friction. The integration process is complex, and not every attempt has landed smoothly. Boshen, the maintainer of the Rolldown bundler, publicly noted that the team had to withdraw its Rust React Compiler integration from Rolldown and Vite. The goal, according to Boshen, was to "de-slopify" the implementation first, despite initial benchmarks showing a 2x improvement. This underscores a critical reality: speed is useless if the underlying architecture becomes fragile or difficult to debug.
Implications for the Future of React
The implications of this move for the React ecosystem are twofold. First, it cements the "Compiler-first" future that React leadership has been advocating for over the past year. By offloading the complexity of memoization to a native-speed compiler, React is effectively raising the performance floor for all applications, regardless of the developer’s expertise in manual optimization.
Second, it marks a shift in how Meta approaches tool development. By leveraging LLMs for the heavy lifting of code translation, the team has significantly shortened the development cycle for this rewrite. If successful, this could set a new precedent for how large-scale open-source projects handle language migrations.
However, the long-term success of this initiative hinges on the maintainability of the codebase. If the Rust port proves to be a "black box" that requires specialized expertise to navigate, the project may struggle to attract the necessary community contributions to evolve. The React Compiler working group is currently tracking these developments through the React GitHub monorepo, where the ongoing dialogue between core maintainers and the community will be the true test of this new approach.
As the industry watches, the "Rustification" of the React Compiler will serve as a high-stakes case study. If it succeeds, it will prove that the combination of LLM-assisted development and memory-safe systems programming can breathe new life into legacy ecosystems. If it falters, it will serve as a cautionary tale about the perils of sacrificing long-term maintainability for short-term performance gains. For now, the move represents a bold, calculated gamble—one that, if it pays off, will make React faster and more efficient than its architects ever imagined possible.
Pevita Pearce
Raul Delapena Setiawan
