React 19.2 vs 'React 20': There Is No React 20, and Here's What's Actually New

There is no React 20. If you searched for it because you saw the term somewhere and assumed you’d missed a release, the framework you’re thinking of is still React 19, now at 19.2.7 as of June 2026. The confusion is understandable, because 19.2 shipped enough that it feels like it should have been a major version. It wasn’t, and here’s what it actually contains.

What actually shipped in 19.2

The headline addition is useEffectEvent, a hook that solves a problem every React developer with more than a few months of experience has hit: you need an Effect to read the latest value of a prop or piece of state, but you don’t want that value in the dependency array, because including it would re-run the Effect more often than you want.

Before 19.2, the common workaround was a ref:

function ChatRoom({ roomId, theme }) {
  const themeRef = useRef(theme);
  useEffect(() => {
    themeRef.current = theme;
  });

  useEffect(() => {
    const connection = createConnection(roomId);
    connection.on("connected", () => {
      showNotification("Connected!", themeRef.current); // reads latest theme
    });
    connection.connect();
    return () => connection.disconnect();
  }, [roomId]); // theme intentionally omitted
}

With useEffectEvent, the same pattern is a stable, first-class API instead of a workaround:

function ChatRoom({ roomId, theme }) {
  const onConnected = useEffectEvent(() => {
    showNotification("Connected!", theme); // always reads latest theme
  });

  useEffect(() => {
    const connection = createConnection(roomId);
    connection.on("connected", () => onConnected());
    connection.connect();
    return () => connection.disconnect();
  }, [roomId]); // theme doesn't need to be listed, onConnected is stable
}

The function returned by useEffectEvent always sees the latest props and state when it’s called, but it’s not reactive itself, so it doesn’t belong in and doesn’t need to be in the dependency array. If your codebase has any useRef-based workarounds for this exact stale-closure problem, 19.2 gives you a cleaner replacement worth the refactor.

The second change is smaller in scope but easier to trip over: the default useId prefix changed from :r: (React 19.0) or «r» (19.1) to _r_. The reason is practical rather than cosmetic. The old formats weren’t valid as view-transition-name values or in some XML 1.0 contexts, and useId output is used in exactly those places often enough that it mattered. If your test suite has any assertions checking the literal string of a generated ID, that’s the one thing worth grepping for before you upgrade.

Why this reads like a major version

Three things stack up to create the “this feels like React 20” impression. First, a new hook primitive is the kind of change that historically arrived with major versions in other frameworks, so seeing one in a .2 release reads as unusual. Second, the useId prefix change, while narrow, is the closest thing to a breaking change in the release, and breaking changes usually signal “major” to developers scanning a changelog. Third, the patch releases since 19.2.0, up through 19.2.7 in June 2026, kept adding Server Component type hardening and performance work, which made the 19.2 line feel like it was still actively evolving months after its initial release rather than settling into maintenance mode the way most .x releases do.

None of that adds up to a major version by React’s own versioning logic, which reserves major bumps for breaking changes to the public API surface, not for “this shipped more than usual.” But it explains why enough people expected one that “React 20” became a search term with no release behind it.

Should you upgrade

If you’re on React 19.0 or 19.1, moving to 19.2 is a minor-version upgrade, not a migration project. Run your test suite, grep for any hardcoded assumptions about useId output format, and adopt useEffectEvent where you’re currently working around stale closures with a ref. There’s no reason to hold off.

If you’re earlier than React 19 entirely, that’s a different and larger conversation about whether the jump to Server Components and the new hook set fits your app’s architecture, which is worth scoping separately rather than folding into a “just get to 19.2” task. For teams weighing that bigger move, it’s worth reading the current framework comparisons before committing, since a major React version jump is often a good moment to also reconsider the framework wrapped around it.

React 20 will exist eventually. It doesn’t exist yet, and 19.2.7 is what you should actually be running.