React Compiler 1.0: Do You Still Need useMemo in 2026?

What does React Compiler 1.0 actually do?

React Compiler is a build-time tool that rewrites your components and hooks to memoize values and skip re-renders automatically, giving you the effect of useMemo, useCallback, and React.memo without writing them. React Compiler 1.0 was released October 7, 2025 at React Conf in Henderson, Nevada, battle-tested at Meta, and works for both React and React Native.

That first sentence is the whole pitch, but the mechanics matter. The compiler analyzes your code against the Rules of React and inserts fine-grained memoization at the value level, not just the component level. It can skip re-rendering a subtree, and it can also avoid recomputing a single derived array inside a component that re-renders anyway. Hand-written React.memo wrappers cannot match that granularity without making the code unreadable.

As of June 2026, the tooling defaults have caught up. Expo, Vite, and Next.js enable the compiler for new apps, and the compiler-powered lint rules ship in the recommended presets of eslint-plugin-react-hooks. If you are upgrading a framework at the same time, do the framework first; I documented the order of operations in my Next.js 16 migration guide ↗ because compiler problems and framework breakages look identical in a stack trace. The React Native support is real too, and it nudges the cross-platform math from my React Native vs Flutter comparison for startup MVPs ↗ further toward React Native for teams already shipping React on the web.

Do you still need useMemo in 2026?

For referential equality, no. You no longer need useMemo; the compiler handles it. You still hand-memoize genuinely expensive computations and values crossing non-React boundaries, plus anything living in files the compiler skips. A useMemo wrapping an object literal or a filtered list of fifty rows is dead weight in a compiled file.

The three survivor categories, concretely:

• Genuinely expensive computations. Parsing a CSV export, sorting 10,000 review rows, building a client-side search index. The compiler memoizes these too, but I keep the explicit useMemo because it documents cost for the next reader and protects the work if the file later gets skipped.


• Values crossing non-React boundaries. A comparator passed into a charting library, an options object handed to a map SDK, a message posted to a web worker. The compiler guarantees nothing about how foreign code treats identity, so I stay explicit there.


• Files the compiler skips. A skipped file gets zero automatic memoization, so the pre-2025 rules apply in full inside it.

// Still worth writing in 2026: the parse is the expensive part,
// and the useMemo documents that for the next reader.
const sortedReviews = useMemo(
  () => parseReviewExport(csvText).sort(byDateDesc),
  [csvText]
);

What still breaks React Compiler, and why are teams stuck there?

The breakage pattern is almost always the same: libraries break the compiler when they return a stable function identity that yields different values over time; memoizing on that identity means the value never updates. As of June 2026, this is the ecosystem's real adoption blocker, more than anything in the compiler itself.

Picture an older form library whose watch() function keeps the same identity forever while returning fresh values on every render. The compiler sees a stable input, caches the output, and your form silently stops updating. No error, no warning, just stale UI. That failure mode is what scared teams off through 2025.

Two things changed since. The compiler now ships detection that auto-skips files importing known incompatible libraries (landed in facebook/react PR #34027), and a matching incompatible-library lint rule tells you why a file was skipped instead of leaving you guessing. The 'use no memo' directive remains the per-file escape hatch for anything the detection misses.

The offenders I have personally hit or had flagged in client work:

// vite.config.ts: enable per directory while migrating
react({
  babel: {
    plugins: [['babel-plugin-react-compiler', {
      sources: (filename) => filename.includes('src/features/reviews'),
    }]],
  },
})

After eight months running it in production, my rule is simple: delete manual memoization in compiled files unless the profiler objects. The useMemo calls that remain in our codebase are documentation of genuinely expensive work, not guesses about re-renders.

Key takeaways

• React Compiler 1.0 was released October 7, 2025 at React Conf, battle-tested at Meta, and works for both React and React Native.


• For referential equality and re-render prevention you no longer need useMemo; keep it for genuinely expensive computations and non-React boundaries.


• Libraries returning a stable function identity that yields different values over time are the main breakage; since PR #34027 the compiler auto-skips known offenders and lints the rest.


• My production numbers were real but modest: commits from 41 to 23, average commit from 14.2ms to 9.1ms, 86 percent of components auto-memoized.


• Migrate in five steps: lint, fix, enable per directory, profile, then delete redundant memoization.