Signals in Modern Frameworks
You'll learn how signals have been adopted across modern JavaScript frameworks and how they're being standardized at the language level.
The Signals Revolution
After years of different reactivity approaches (two-way binding, virtual DOM diffing, etc.), frameworks have converged on signals as an elegant solution. Rather than each framework inventing its own system, we're seeing remarkably similar patterns emerge.
Framework Implementations
SolidJS
SolidJS pioneered fine-grained reactivity with signals as its core primitive:
import { createSignal, createEffect } from 'solid-js';
const [count, setCount] = createSignal(0);
createEffect(() => console.log(count()));
SolidJS compiles away the virtual DOM entirely—signals directly update the real DOM.
Preact Signals
Preact adopted signals as an opt-in addition to virtual DOM:
import { signal, computed, effect } from '@preact/signals-core';
const count = signal(0);
const double = computed(() => count.value * 2);
effect(() => console.log(double.value));
Note the .value syntax—slightly different from SolidJS's function calls.
Vue 3
Vue 3's reactivity system uses signals under the hood (via ref and reactive):
import { ref, computed, watchEffect } from 'vue';
const count = ref(0);
const double = computed(() => count.value * 2);
watchEffect(() => console.log(double.value));
Looks familiar! Vue's API closely mirrors the signals pattern.
TC39 Signals Proposal
Recognizing this convergence, TC39 is working on a native JavaScript signals proposal—bringing reactivity directly into the language. This would provide a standard foundation all frameworks could build upon, similar to how Promises unified async patterns.
Key Takeaway: Signals have become the dominant reactivity pattern across modern frameworks (SolidJS, Preact, Vue 3), with TC39 working to standardize them at the language level—unifying years of framework innovation into a shared primitive.