React Compiler 2026: Should You Delete useMemo and useCallback Forever?

React Compiler v1.0: What It Actually Does

After more than two years of development under the codename “React Forget,” the React team shipped React Compiler v1.0 as a stable release alongside React 19. The premise is bold: the compiler performs automatic memoization at build time, eliminating the need for developers to manually annotate which values and functions should be stable across renders.

React Compiler solves this by analyzing your component code at build time and automatically inserting the equivalent of memoization where it would be beneficial — and only where it would be beneficial. The compiler understands React’s rules and uses that understanding to predict when a value is stable across renders without developer annotation.

How to Enable React Compiler in Next.js 16

For Next.js 16 projects, enabling the compiler is a one-line configuration change in next.config.ts:

const nextConfig = {
  experimental: {
    reactCompiler: true,
  },
};
export default nextConfig;

You will also need the compiler package:

npm install --save-dev babel-plugin-react-compiler

The compiler runs during both next dev and next build. The 'use no memo'; directive at the top of a component file excludes it from automatic memoization — the safety valve for third-party integrations and edge cases.

Benchmark Results

The React team’s internal benchmarks show meaningful gains in render-heavy scenarios. In the JS Framework Benchmark, React with the compiler shows approximately 15–20% improvement in interaction-to-next-paint metrics for list-heavy UIs.

Scenario	Without Compiler	With Compiler	Improvement
Large list re-render (1000 rows)	420ms	310ms	~26%
Form with 20 controlled inputs	85ms	72ms	~15%
Dashboard with 8 chart components	190ms	165ms	~13%
Simple blog page	28ms	26ms	~7%

Real-world gains depend heavily on how much unnecessary re-rendering your current codebase performs. Applications with aggressive manual memoization may see smaller gains; applications that never used memoization may see the largest improvements.

When You Still Need useMemo and useCallback in 2026

1. External State Management Libraries

Libraries like Zustand, Jotai, and Redux Toolkit operate outside React’s component model in ways the compiler cannot fully analyze. If you are deriving computed values from an external store and passing them as props, manual useMemo on derived external state remains necessary.

2. Third-Party Libraries Expecting Stable References

Chart libraries (Recharts, Victory), map libraries (Mapbox GL, Leaflet), and certain animation libraries (GSAP integrations) perform reference equality checks outside React’s reconciler. These still require stable references via useCallback or useMemo.

3. Concurrent Mode Edge Cases

When using useTransition and useDeferredValue, there are edge cases where manually stabilizing expensive computations provides more predictable performance. This is particularly relevant for typeahead search components filtering large datasets.

4. Intentional Performance Boundaries

When you need an explicit performance boundary — a component that should never re-render regardless of parent state changes — React.memo combined with useCallback remains the most explicit and auditable approach.

Migration Guide: What to Actually Delete

1. Enable the compiler and run your test suite. If tests pass, the compiler has correctly analyzed your components.
2. Run React DevTools Profiler on your most interaction-heavy pages.
3. Remove useMemo hooks that wrap pure computations with no external dependencies — prime candidates for deletion.
4. Remove useCallback hooks on event handlers passed only to native HTML elements or well-behaved React components.
5. Retain useCallback where the callback is passed to a third-party library or a custom hook that performs reference comparison.
6. Retain useMemo for expensive computations on large datasets, selector functions over external stores, and object/array values passed as context.

Known Third-Party Compatibility Issues

React Hook Form: Versions prior to 7.50 have known incompatibilities with the compiler’s memoization of register and control references. Upgrade to 7.51+ before enabling the compiler.

TanStack Query: The select option on useQuery can cause issues — the compiler may over-memoize the selector. TanStack has shipped fixes in v5.28+.

The Verdict

React Compiler v1.0 is a genuine advancement that makes React applications faster with less developer effort. The mental model shift in 2026: use memoization hooks intentionally for documented performance contracts with external libraries, not defensively as a general optimization practice. The compiler handles the defensive case. You handle the intentional case.

Related reading

• OpenAI GPT-Realtime-2: Complete Voice API Developer Guide (2026)
• Anthropic Advisor Strategy: Run Opus Intelligence at Sonnet Cost
• Claude Managed Agents: Complete Developer Guide (April 2026)
• Best AI Agent Starter Kits 2026 — Buyer’s Guide (Tested and Compared)