Course contentsShow
← JavaScript
Lesson 2125 of 2,72344. Reactive PatternsFree lesson

Signals in Modern Frameworks

How signals appear in SolidJS, Preact Signals, Vue 3's reactivity system, and the TC39 signals proposal for JavaScript.

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.