Ship the variant, keep the tuning
A production virtual scroller, hand-tuned for years, became a horizontal card strip and a book-length text marquee — and the whole diff is eight getters and one prop. How class extension keeps the hard 80% shipped once.
What native signals should steal
TC39's signals proposal standardizes the graph. It defers the layer where apps actually live: how signals attach to objects. That layer has been built and measured in userland. Lazy existence, zero-cost derivation, explicit release. Three mechanisms, three receipts, all on offer.
Expressiveness is no longer a budget
Every Vue codebase rations expressiveness. Inline the expression, flatten the model, split the editor from the player, keep it light. The rationing was never wisdom. It was a price list. Change the prices and the link between how expressive an app is and how heavy it is simply breaks.
Release what the GC can't
The garbage collector's contract ends at reachability: one retained reference — an event bus, a stray closure, devtools — and your unmounted component's 85 MB stays forever. We measured what happens when the model can empty itself instead: 4.7 MB. The leak keeps the husk. It doesn't keep the memory.
Derivations are free. Caches are earned.
We finally measured the one thing the doctrine never had a number for: the warm read. A plain getter recomputes every time; computed() reads its cache in 3 nanoseconds. So why is the getter still the right default? Because the crossover has a price — and most derivations never pay it.
Total memory control
In Vue, a ref exists the moment its line runs — name and storage are the same thing. Put the ref behind a getter and they separate: existence itself becomes a managed resource. One indirection, and memory has an API.
Pause the watchers, keep the state
An object's lifecycle has a third state between alive and reset: suspended — side effects silent, data intact. ivue 2.4 adds it as one option on the existing verb, and the resume half costs no API at all.
The thinnest possible layer between intent and reactivity, backend or frontend
alien signals reduced propagation to its minimum; Vue owns the stable contract over it; ivue answers the one remaining question — where cells live, when they materialize, who owns their death. What sits between intent and reactivity is now almost nothing, and every seam that remains says something true.
Inexpressible failure, expressible intent
Every failure mode a substrate leaves expressible squats on territory intent should own. Remove the mine field and something bigger than cleanliness returns: every shape the domain has becomes directly writable — one graph, traced by the text with nothing alien interrupting it.
Disposal is a reset
Every reactive system answers birth well; death is where they get vague. ivue's $stopEffects is one verb that stops the instance's effects, frees its cells — and leaves the object ready to live again.
The stack got faster. We changed nothing.
Vue 3.6 rewrites reactivity on alien signals; Vapor mode removes the virtual DOM. ivue changes nothing and gets faster on both sides — measured on the RC, and already running 94,000 lines in production.
Bulletproof class modules
LazyShared seals the last seam — the full Reactive() + Static() system is now memoizable at every scope, with polymorphism, inheritance, and performance intact. Every value kind, shown in full code.
The Options API everyone actually wanted
What people loved about the Options API was anatomy — a component you could read. The anatomy was fake. The class is the real one, and it was in the language all along.
Reactive() and Static() — discovered, not invented
Reactive() and Static() look like a designed pair — one transform for instances, one for the class object, same late binding, same per-receiver caching, one level apart. Neither was designed to complete the other. The mirror emerged from the same constraints, and emergent duals are load-bearing.
The field, not the rules
There are two ways to get good code — police it with rules, or reshape the field so bad design has nowhere to stand. ivue and its invariants flip JavaScript's defaults one by one, until the degenerate moves stop existing as moves. 144,000 lines of agent-built proof.
What becomes buildable
Frameworks made views cheap. ivue makes models cheap — big, long-lived, externally legible. Five categories of software that were blocked on exactly that: whole-dataset apps in the browser, software modified while it runs, agent-operable apps, reactive control planes, and architecture that cannot rot.
Reactive framework for the AI era
Frameworks were designed for human authors — expressiveness, flexibility, choice. The author changed. When agents write most of the code, the ranking of framework virtues inverts — uniformity beats expressiveness, construction beats vigilance, and an engine small enough to hold in one head fits whole into one context window.
Patterns the author never wrote
Invar is full of ivue patterns that ivue's author never used by hand — the mtime-keyed blame cache, observation-owned connections, the pull floor. Agents derived them from the 845-line Standard Operating Manual. The difference between a catalog and a generator is that a generator produces instances its author never enumerated.
Reactivity is an allocator
The industry uses reactivity to update pixels. Invar points it at the operating system — SQLite connections, git subprocesses, LSP servers, sampling timers all exist only while observed. One file system watcher, twenty-one watch sites, ninety-two version signals, and a pull floor under every notify channel. Rendering was just reactivity's first job.
What JavaScript becomes
Managed-runtime linking from the JVM, live-image classes from Erlang and Smalltalk, receiver-aware static storage no static language can express, and transparent reactive objects — one language ends up holding all four, and holds them in userland. The capstone of the series.
Circular imports, dissolved
JavaScript's oldest structural wound — module A needs B, B needs A — was never about the cycle. It was about the clock. One idiom moves every cross-module reference from load time to first access, and 372 files with a deeply cyclic domain graph produce zero import cycles. Measured, not promised.
Module-level state is a bug
The most normal line in JavaScript — const cache = new Map() at module scope — is an eager, global, unownable singleton with no seam. Static() replaces it with one declaration that is lazy, inheritable, overridable, and test-isolated. A 94,000-line codebase runs on zero module-level functions and zero module-level variables.
Three years to reduce, two weeks to build
Two commit logs, one project. ivue - 597 commits over three years finding the generator. Invar - 3,109 commits in twenty days generating from it, starting the same day the engine reached its final form. Reduction is where the cost lives.
Uniformity is a measuring device
Consistency is treated as taste. It is actually a measuring device — deviation is only visible against sameness, so a codebase with low structural entropy makes its own defects high-contrast. What that buys, and the one thing it cannot see.
The test is a subclass
Invar's test harness never mocks. It substitutes full citizens — swap the capability at its Static() seam, subclass $Class to pinch one knob, plant a defect as a positive control. No mock framework, no stub drift, and the compiler checks the fakes.
From monolith to modular design in a day
In one day, AI agents extracted a monolith's git, markdown, file tree, settings, and keybindings into plugins behind enforced boundaries — directed by one human talking casually. The care didn't come from the model. It was moved into the structure.
The editor tripled. The zeros didn't move.
Three days after we measured Invar at 26,000 lines, it passed 69,000 — 396 commits in three days, six new organs, a multi-provider agent harness. Every discipline metric we published held. A follow-up with the greps re-run.
Introducing Invar
A full IDE that lives in your terminal — file tree, git, LSP autocomplete, integrated AI agents that can watch your shell — built almost entirely by AI agents under a mechanical referee, on one kilobyte of ivue.
JavaScript's most-linted features are its superpower
JavaScript's most-linted properties — mutable bindings, late-bound dispatch — are the raw material for swappability no static language can reach and no dynamic language ever made safe.
Initialization order, solved in userland
Initialization order is a solved problem in four languages and an unsolved one in the most-used language on earth. One idiom and a 200-line checker close the gap — and pay three more dividends.
The whole story, in small words
The whole story in small words — a one-kilobyte brick, an editor that AI agents built out of it, and the referee that makes AI-built software safe to trust.
The object graph they took from you
Frontend never proved object graphs wrong — it fled two mechanical defects, then canonized the flight as philosophy. Fix the defects and workspaceSet.active.editor.selectLine() comes home.
Reactive() is all you need
Store libraries, composable factories, service layers, emitters, DI containers — the state-management zoo reduces to plain classes and one prototype transform. The roles were never different things; they were one thing with different lifetimes.
AI agents built a 26,000-line code editor on ivue
A working terminal code editor, written almost entirely by AI agents — zero cycle-breaking hacks, one computed() in the whole codebase, one wiring seam. What a substrate is worth when the author is a machine.
The object should tell the truth
State is explicit. Caching is intentional. Everything else stays pure. An ivue class makes the runtime semantics of an object visible in its source.
Win by reduction. Win by construction.
The strongest architecture does not manage complexity more efficiently. It removes the conditions that create it, then makes the remaining guarantees structural.
VS Code spent a decade hand-rolling reactive classes
The most influential TypeScript app is class-OOP with no framework — emitters, disposables, DI decorators, and since 2022 its own signals system. Every one of those subsystems maps to one ivue feature.
A million rows, twelve divs
A 1,000,000-row list where scrolling itself is virtual — Lenis owns position and momentum, the DOM holds a dozen rows between two spacers, and every operation is O(window). One 1,199-line ivue class runs all of it, live on this page.
computed() is a cache, not a derivation
Vue's derivation primitive was always the tracked read. Memoizing everything by default was never neutral — it was just unexamined.
Inheritance didn't deserve the exile
The composition-over-inheritance recoil corrected an abuse, then outlawed a tool. Reactive super chains show what it cost.
Measured, not promised
Every performance number on this site comes from a measurement we ran — with its method attached, most of them re-runnable right in your browser, on the shipped engine. Measured, not promised. That's the whole idea.
One kilobyte is a feature
1.1 kB is not a compression achievement — it is what remains when a design stops needing machinery. Small enough to read, small enough to trust.
Composables are organs, not skeletons
The ecosystem's decade of composables is not ivue's rival — it's the substrate. Classes give the body a spine; composables keep doing what they do best.
Your objects are rented from the framework
If your domain logic only exists while a component is mounted, you don't own your objects — you lease them. On evicting the landlord.
this.method, finally safe to pass
A decade of () => this.method() wrappers, .bind(this) rituals, and shipped undefined-this bugs — ended by binding methods lazily, once, on the prototype.
The 20,000,000-cell document
A spreadsheet Google Sheets cannot represent, fully reactive at 4.7 bytes per cell — and you can create it in your browser right now.
Introducing ivue: plain classes, full reactivity, one kilobyte
The launch post — why the field abandoned classes for the wrong reason, what the derivation primitive actually is, and the measured numbers behind a 1.1 kB answer.