React Bet Against Signals, and Everyone Else Took the Other Side

Every framework spent years chasing the same fix: stop making devs write useMemo by hand. In 2026 the ecosystem finally split into two camps solving it, and React picked the one everyone else walked away from.

The camp that picked signals

Svelte, Solid, Vue, Preact, and Angular all converged on signals: fine-grained reactive values that track their own dependents and update only the exact DOM node that depends on them. No re-render, no diffing, no memoization to remember. It is precise by construction. The TC39 Signals proposal is moving through standardization specifically because so many frameworks landed on the same primitive independently, a shared native implementation would end years of framework-specific reactivity code.

The camp of one

React Compiler bet the opposite way. Instead of a new reactive primitive, a build step reads your component code and inserts the memoization you used to write by hand, useMemo, useCallback, React.memo, without you touching any of it. Your code stays the same "re-render the whole component" model React always had. The compiler just makes that model cheap enough to stop mattering.

• Signals change how you write components: fine-grained reactive values, a real mental model shift
• The compiler changes nothing about how you write components, only what the build step generates
• Signals need a language-level primitive to hit full potential, still going through standardization
• The compiler already works, inside the model React already shipped

Why the fork matters more than either feature

This is not a performance debate. It is a bet on where complexity should live. Signals push it into how you author components. The compiler pushes it into the build step and keeps authoring simple, at the cost of trusting a tool to infer correctly what a plain useMemo used to make explicit. Neither side is wrong here, and that is the uncomfortable part. They are different answers to one question: who owns the optimization, the developer, the language, or the compiler?

What to actually do with this

If you are on React, adopt the compiler and stop hand-writing memoization, that fight is over. If you are picking a framework for something greenfield, know that signals are not a niche feature anymore, they are where the rest of the ecosystem is standardizing. Pick based on your team and your ecosystem, not on which one sounds newer this month. Both bets are serious and both are shipping in production right now. Which one would you have made?