The thinnest possible layer between intent and reactivity, backend or frontend
There is a way to tell when a stack is finished, and it is not that nothing more could be added. It is that every layer left is doing exactly one irreducible job — and between them, nothing.
Look at what now sits between a JavaScript program's intent and its reactivity:
alien signals is the propagation invariant, reduced to its minimum. Track reads, push writes — that is what reactivity is once everything decorative is carved away. Vue 3.6 rewrote its reactivity on it, and it is the fastest core in the ecosystem for the least mysterious reason available: there is nothing left in it to be slow.
Vue's reactivity API is the stable contract over it. ref, computed, watch, effect scopes — the ergonomic surface, owned and battle-tested by a framework team. When the engine under it was swapped for alien signals, the contract held; ivue's entire test suite passed on the release candidate without touching a line. A contract that survives its own engine being replaced is a real contract.
ivue is the one question neither layer answers: where do cells live, when do they materialize, who owns their death? Placement in the class grammar the language already has; materialization on first touch, never before; disposal as an owner's verb that resets the object to its pre-touch state. That is a grammar, not an engine — and a grammar weighs one kilobyte because grammars weigh nothing.
The purity test
How close is this to the pure form? Measure the residue — everything still standing between the intent and the mechanism. The list is countable on one hand:
.valueat the leaves- the state destructure at the top of a component
- lateness on cross-module references
And here is what makes the stack feel finished rather than merely small: every survivor is information-bearing. .value marks the exact points where reactivity enters — the object tells the truth about which reads are tracked. The destructure declares, in one statement, the complete set of cells a template consumes. Lateness on module edges encodes a true fact about JavaScript — that load time and run time are two different clocks — rather than papering over it.
Nothing left is accidental. A seam that says something true is not overhead; it is notation. The residue you cannot remove without losing information is the pure form.
For everything
"Backend or frontend" stopped being a boundary somewhere along the way, because none of the three layers ever mentions a DOM. The same graph, under the same grammar, is currently running:
- a documentation site's live demos, in the browser
- a 20,000,000-cell spreadsheet at 4.7 bytes per cell
- a terminal IDE rendered cell-for-cell into a PTY grid — 94,000 lines, no DOM in the process
- that IDE's Bun backend, where reactivity allocates OS resources — files, watchers, terminals — and the floor below it stays plainly imperative
One substrate, one grammar, every host. The claim is not that ivue scales from small to large. It is that the layer is thin enough to have no opinion about what sits above or below it — which is what "universal" actually requires.
Why thin was the hard part
None of these layers was designed into its final shape. Each is somebody's completed reduction — the alien-signals authors reducing propagation until only tracking remained, this project reducing placement and lifecycle for three years until only the grammar remained. Completed reductions compose cleanly for a structural reason: there is nothing extra left on either side to collide.
That is why the result reads as inevitable in hindsight and took years in practice. You cannot design a stack into this state. You can only reduce it there — and then notice that what's left between intent and reactivity is almost nothing, and all of it is true.
Comments