May 2024, Revisited: React 19 RC and the Compiler That Ended Memoization

Our Three-Year Retrospective — this first year of it, anyway — closes with May 2024 and React Conf, where the React team finally showed the shape of everything it had been building toward since 2020. React 19 reached release candidate, and the React Compiler was open-sourced. After two years in which React's direction had felt like rumor and RFC, May 2024 was the month it became concrete.

Actions: forms rejoin the framework

The headline API of React 19 was Actions — first-class support for the write side of applications, which client-side React had left as an exercise for the reader since its beginning. A form could now take a function as its action; React managed the pending state, optimistic updates via useOptimistic, error surfacing, and form reset. The supporting hooks — useActionState, useFormStatus — replaced the boilerplate every team had hand-rolled or imported a library for: the isSubmitting flag, the error state, the disable-the-button dance.

function ChangeName() {
  const [error, submitAction, isPending] = useActionState(
    async (prevState, formData) => {
      return (await updateName(formData.get("name"))) ?? null;
    },
    null,
  );
  return (
    <form action={submitAction}>
      <input type="text" name="name" />
      <button type="submit" disabled={isPending}>Update</button>
      {error && <p>{error}</p>}
    </form>
  );
}

Alongside Actions came the use() API for reading promises and context with fewer ceremony rules, refs as ordinary props with forwardRef heading for the exit, document metadata support, and a long list of quality-of-life removals. Individually small; collectively, the framework absorbing a decade of userland patterns.

The compiler ends the memoization era

The deeper announcement was the React Compiler, open-sourced at the conference and already running in production on Instagram. React's re-render model had always carried a tax: components re-render when parents do, so performance work meant hand-placing useMemo, useCallback, and React.memo — incantations that cluttered every serious codebase, broke silently when a dependency array drifted, and constituted perhaps the most-asked interview topic of the era. The compiler made the optimization automatic: it analyzed components at build time, understood what could change, and memoized accordingly. Code got simpler and faster — the rare optimization with no ergonomic cost.

The honest caveats: it was experimental, it relied on your code actually following the Rules of React (years of lint-rule nagging suddenly had a payoff), and it shipped outside React 19 itself, on its own timeline. But the direction was unmistakable. Manual memoization was now legacy practice with a countdown attached.

The server-first direction settles

React Conf also marked the moment Server Components stopped being controversial and started being canon. React 19 shipped the stable underpinnings frameworks needed, and the architectural picture clarified: components render on the server by default, client interactivity becomes the opt-in island, and data fetching moves to where the data lives. The community arguments of 2023 — is this even React? — gave way to the practical question of migration. We spent that spring telling teams the same thing: nothing forces you to adopt any of this immediately, your existing client-rendered app keeps working, but new architectural decisions should assume the server-first direction is permanent, because it visibly was. The convergence with what we had watched Blazor do six months earlier, and what the htmx crowd had argued a year earlier, was hard to miss — the whole industry had circled back to rendering HTML on servers, each ecosystem in its own accent.

Looking back from June 2026

React 19 went stable in December 2024, and the May announcements aged largely as advertised. Actions became the normal way to handle mutations; use() and ref-as-prop made the old patterns look dated within a year; and the compiler graduated from experiment to expectation, to the point where teaching manual useMemo placement now feels like teaching manual memory management — worth understanding, rarely worth doing. Server Components remain framework-mediated rather than universal, and the client-rendered SPA is far from dead, but the center of gravity moved exactly where this conference said it would.

Modern React is a meaningfully different framework from the one most tutorials still describe, which is why React Essentials with TypeScript teaches the current model from the start — Actions, hooks as they are actually used, and compiler-era habits rather than memoization folklore. For teams carrying mature codebases across this divide, Advanced React goes deep on Server Components, concurrent rendering, and performance work in a world where the compiler does the easy parts and leaves you the interesting ones.