The Web Loom Blog
The story of how Web Loom came to be, plus deep-dives on every published package — the history behind each pattern, how other platforms handle it, and how Web Loom thinks about it.
Introducing Web Loom
Where Web Loom came from, why its reactive core moved from RxJS to signals, and what building it with AI agents taught me about patterns.
Web Loom: A Playground That Grew Into a Framework
How an old C# pattern, a detour through RxJS and a lot of AI-assisted coding became a framework-agnostic MVVM toolkit for the web.
From RxJS to Signals: Rebuilding Web Loom's Reactive Core
Why a framework-agnostic MVVM toolkit started on RxJS, what that cost, and why it now runs entirely on signals.
One ViewModel, Many Views
Writing presentation logic once in plain TypeScript, rendering it with React, Vue, vanilla JavaScript and a framework-free template, then testing it without a DOM.
Patterns in the Age of Agentic Coding
AI wrote most of Web Loom's code. Here's how that worked, what kept it on track, and why I think knowing patterns matters more now, not less.
Package Deep Dives
One article per published package — the history behind each pattern, how other platforms handle it, and how Web Loom thinks about it.
Putting It All Together — Building a Complete Feature With Web Loom
We've spent ten articles looking at individual packages. Each one solves a specific problem. Each one is useful on its own.
Read article@web-loom/mvvm-core — The Architecture Layer the Web Forgot
There's a moment most frontend engineers recognise. You've been asked to estimate how long a migration will take — React to Vue, web to React Native, monolith to micro-frontends. You open the codebase. Five minutes later…
@web-loom/signals-core — Reactive State Without the Framework Tax
The idea that a value change should automatically propagate to everything that depends on it is not new. Spreadsheets have worked this way since VisiCalc in 1979. When you type a new number into cell A1, every cell with …
@web-loom/event-emitter-core — Typed Events for the Modern Web
The event emitter is one of those ideas so fundamental to software that it's been reinvented independently across virtually every language and runtime. Java has `EventListener` and `Observer`. C# has delegates and events…
@web-loom/event-bus-core — Decoupling Features With Typed Pub/Sub
There's a tension at the heart of application architecture that nobody talks about enough: features need to know about each other, but shouldn't depend on each other.
@web-loom/store-core — UI State Belongs Somewhere Specific
Ask ten engineers where theme preference should live in an application and you'll get ten different answers. In the component. In localStorage. In Redux. In React Context. In a URL parameter. In a cookie. In a database. …
@web-loom/query-core — Data Fetching With a Memory
There's a scenario every web developer has written at least once. The user navigates away from a list page, does something else in the app, comes back to the list page — and the application spins a loading indicator and …
@web-loom/ui-core — The Behaviour Layer Below Your Components
In 2016, Ryan Florence gave a talk at React Rally that changed how a lot of people thought about component libraries. He argued that most UI library components are over-specified: they own the markup, the styles, and the…
@web-loom/ui-patterns — When Behaviours Become Patterns
There's a difference between a behaviour and a pattern. A behaviour is atomic: "a dialog can be opened and closed." A pattern is compositional: "a master-detail view has a list on the left, a detail panel on the right, s…
@web-loom/design-core — Design Tokens as the Contract Between Design and Code
Somewhere in every medium-to-large frontend codebase there is a file called `colors.ts`, or `theme.js`, or `design-tokens.json`, or some variation thereof. It was created by someone who recognised that hardcoding `#3B82F…
@web-loom/mvvm-patterns — The Conversations ViewModels Need to Have
There's a moment in every MVVM implementation where the architecture hits a wall.