React Compiler Is On by Default, Ending Manual Memoization

The React Compiler, the tool formerly known as React Forget, now analyzes your components at build time and inserts memoization for you, and it is moving to on-by-default. In early-adopter apps it cuts unnecessary re-renders by roughly 25 to 40 percent, and it does it without a single useMemo, useCallback, or React.memo written by hand. After a decade of developers manually caching values to keep React fast, the framework has automated the most tedious performance chore in front-end work.

• The React Compiler auto-memoizes components at build time, so you stop writing useMemo, useCallback, and React.memo by hand.
• Early adopters report 25 to 40 percent fewer unnecessary re-renders with no code changes beyond enabling it.
• It works as a build-step plugin that reads your component's dependencies and inserts caching automatically.
• The catch: it only works if your components follow the Rules of React, so purity and correct dependencies finally pay off directly.

What problem does this actually solve?

React re-renders aggressively by default. When a component's state changes, React re-runs that component and its children, rebuilding values and functions even when the inputs did not change. For most apps that is fine, but in large trees it causes wasted work: expensive calculations repeat, and child components re-render because a parent handed them a freshly created function that is technically a new value every time. For ten years the fix was manual memoization, wrapping values in useMemo, functions in useCallback, and components in React.memo. It worked, but it was error-prone, verbose, and easy to get subtly wrong, and a missing or incorrect dependency array was one of the most common sources of React bugs.

RelatedDjango 6.0 Goes Async-First With Background Tasks

The compiler removes the chore entirely. It understands your code well enough to insert precisely the caching a meticulous engineer would write, in exactly the right places, every time. The boilerplate disappears, and so does a whole category of dependency-array mistakes.

How does the compiler know what to cache?

It reads the dependency graph. During the build, the compiler traces which values a component computes, which inputs those values depend on, and which functions get passed to children. Where a value only changes when specific inputs change, it wraps it so it recomputes solely when needed. Where a function would otherwise be recreated on every render, it stabilizes it so children do not re-render for no reason. This is the same reasoning a developer does by hand when adding useMemo, but done mechanically across the entire component tree, which is why it is both more thorough and more reliable than manual effort.

What is the catch?

The compiler only works safely if your components follow the Rules of React: components and hooks must be pure, must not mutate values they do not own, and must declare their dependencies honestly. Code that breaks those rules, mutating props, reading from shifting external state mid-render, relying on side effects during rendering, can confuse the compiler or get skipped. In practice this is a feature, not a bug. It turns discipline that was always good advice into a direct, measurable payoff, and the tooling includes a linter that flags violations before they bite. Teams with clean, idiomatic React get the speedup almost for free. Teams with a decade of hacks may need to fix a few components first, which is worthwhile regardless.

RelatedAstral's ty Brings Rust-Speed Type Checking to Python

Who benefits most?

Large, interaction-heavy applications gain the most, because they are where wasted re-renders compound into visible jank. Dashboards, editors, feeds, and anything with deep component trees will feel snappier. Smaller apps benefit less in raw performance but still shed boilerplate and a class of bugs. And the whole ecosystem gains a cultural shift: performance stops being a manual craft that separates senior engineers from juniors, and becomes a default the framework handles. That lowers the skill floor for writing fast React, which is exactly what a mature framework should do.

Our take

This is React quietly retiring one of its own worst ergonomics. Manual memoization was always a leak in the abstraction: the framework promised you could just describe your UI, then made you hand-optimize when it got slow. The compiler closes that gap and does it the right way, by rewarding clean code instead of punishing it. The 25 to 40 percent re-render reduction is nice, but the real win is deleting thousands of lines of defensive caching and the bugs that hid in them. The one honest caveat is that it raises the price of sloppy React: break the rules and you lose the magic. That is a trade worth making. After ten years, writing fast React is finally becoming the same thing as writing simple React.

Original analysis by GenZTech. Source: React docs. Figures current as of July 2026.