JavaScript Reactivity, the one-pager

Every framework, plotted on three axes

A summary of Parts 1 through 4 of the series.

Use the arrow keys or the buttons below.

The shape of it

Reactivity has two halves

The notification

Something changed.

Depth · Granularity

The update

Go sync the view.

Directionality

01 Depth

"What is the smallest change I can make that still triggers updates?"

ShallowDeep

JavaScript only sees a write when it goes through a setter or Proxy trap. Mutate a nested object and the outer reference never notices. That's why primitives get wrapped in a container with .value, and why deep systems (Vue, MobX, Solid stores) recursively proxy everything you touch.

Shallow is simple and leans on reassignment. Deep is ergonomic but brings proxy identity weirdness. Either way, every system ships an escape hatch: requestUpdate(), triggerRef(), notify().

Read Part 2: Deep vs. Shallow →

02 Granularity

"At what level are changes detected, and how does the system find what actually changed?"

CoarseFine

Scope shrinks in rings: window, application, service, component, template, DOM node. Zone.js rechecks the world. React re-renders a subtree and diffs. Signals frameworks track every read and update the exact bound node.

Coarse is simpler and gets you surprisingly far. Fine does less work, but now you own dependency tracking: de-duping, conditional reads, and the diamond problem.

Read Part 3: Coarse vs. Fine →

03 Directionality

"Does change get pushed to dependents, or pulled at render time?"

PullPush

Every framework nudges itself on a write, so that's not the test. A system is push when its dependencies are figured out ahead of time. Pull systems re-run render top to bottom and never see an inconsistent state.

Push-pull (signals) must solve glitches with scheduling and topological ordering. There's no truly pure push framework; Svelte 4 comes closest.

Read Part 4: Push vs. Pull →

Depth × granularity

Four families emerge

Fine + deep Reactive graphs

Recursive proxies track exactly which paths you read. Vue, MobX, Valtio, Solid stores, Svelte 5.

Fine + shallow Atomic primitives

A box around a value, exposed through .value or a getter. Signals, shallowRef, nanostores.

Coarse + deep Wholesale discovery

"Something changed, go find it." Least efficient, easiest to share across a platform. Zone.js, wc-services.

Coarse + shallow Diffing

Swap the reference, re-render virtually, compare. React, Preact, Redux, Lit.

See the interactive chart in Part 1.

Where each one lands

Pull frameworks

Where each one lands

Push-pull and Push frameworks

Granularity bars run coarse (window) to fine (DOM node). Lighter segments mark a range. Placements are approximate and full of "it depends"; the posts carry the nuance.

The takeaways

  • Detection and response are separate. Re-rendering everything doesn't make a system deep. Depth is about what triggers the update, not what the update touches. Part 2 →
  • Every system has an escape hatch. No detection scheme catches everything, so they all let you poke it manually, usually by reassigning the top-level reference. Part 2 →
  • Fine-grained frameworks converge. Angular, Solid, Svelte 5, and Preact signals all read to subscribe and write to notify. The API spelling is the main difference. Part 3 →
  • The diamond problem decides push vs. pull. Once dependencies are wired ahead of time, you need scheduling and topological ordering to avoid glitches. Pull frameworks dodge this entirely. Part 4 →

Read the whole thing

The JavaScript Reactivity series by Jim Schofield

  1. A Global Look
  2. Deep vs. Shallow Reactivity
  3. Coarse vs. Fine-Grained Reactivity
  4. Push vs. Pull Reactivity