The Signal Revolution: Fine-Grained Reactivity Everywhere

Something remarkable happened in 2024-2025: every major frontend framework independently converged on the same primitive — signals. This isn't coincidence. It's the industry acknowledging that virtual DOM diffing was a necessary stepping stone, not the destination.

What Are Signals?

A signal is a reactive value that tracks its dependencies automatically. When a signal changes, only the specific DOM nodes that read from it update — no tree diffing, no re-rendering parent components, no wasted work.

// Svelte 5 runes
let count = $state(0);
let doubled = $derived(count * 2);

// Solid.js
const [count, setCount] = createSignal(0);
const doubled = () => count() * 2;

// Angular signals
count = signal(0);
doubled = computed(() => this.count() * 2);

Three frameworks, same idea, different syntax.

Svelte 5 Runes — My Favorite Implementation

Svelte 5's runes ($state, $derived, $effect) replaced the old $: reactive syntax with explicit, fine-grained reactivity. The compiler transforms runes into optimized signal operations at build time.

What makes Svelte's approach special: no runtime overhead. The compiler does the work, so the output is vanilla JS that directly updates DOM nodes. No virtual DOM, no reconciliation, no diffing. Just surgical DOM updates.

React's Answer: The Compiler

React didn't add signals — instead, the React Compiler (formerly React Forget) automatically memoizes components and hooks. It's a different path to the same goal: stop re-rendering things that didn't change.

The advantage: no API changes. Existing React code gets faster for free. The disadvantage: it's still fundamentally doing more work than signal-based frameworks because it operates at the component level, not the DOM node level.

Performance Implications

In benchmarks, signal-based frameworks (Solid, Svelte 5) consistently outperform VDOM frameworks by 2-5x on update-heavy workloads. For typical applications, users won't notice the difference. For data-dense dashboards, tables, and real-time UIs, signals are a material advantage.

Where We're Heading

The convergence toward signals tells us something: the frontend is moving from "declarative rendering" to "declarative reactivity." We're not describing what to render — we're describing what depends on what, and letting the framework figure out the minimal update path.

My bet: within 2 years, signals (or compiler-equivalent) will be the default in every major framework. The VDOM era was the proving ground. Signals are the refinement.