🌱 Origin Story

I was looking at HTMX and thinking: I can dig this. Server-rendered HTML, declarative attributes, minimal JavaScript. The philosophy was right. But I looked at the code and it wasn't where I needed it to be. So I built Gimmicks — an HTMX clone with one improvement I couldn't live without: dismiss as a first-class feature. In HTMX, canceling a UI state means making a server request to get back the "empty" version. That's braindead. Dismiss should be local.

So I'm building Gimmicks, and I need to match HTMX's feature set, which means I need a way to express triggers and targets. I built a parser for triggers. Then I built a parser for picks — the selectors that say what to extract from the response. Two little languages, each doing half the job.

And then the thought: these should be one language.

There were weird problems with the HTML DSL approach. When you're stuffing logic into attributes, it's not clear what comes before and after. Where does the trigger end and the target begin? The ordering is ambiguous because HTML attributes are unordered.

Then I saw the pipe. What if the trigger piped into the pick, and the pick piped into the target? Like a UNIX pipeline — left to right, one thing flows into the next. The whole interaction described as a single expression.

Famous last words.

I started engineering the pipe language. In JavaScript, naturally. The first version was a recursive descent parser that handled triggers and picks. Then I rewrote it. Then I rewrote it again. Each time the language got more capable and the implementation got more tangled.

After the third rewrite I stopped and looked at what I was actually doing. I wasn't building an HTML enhancement library. I was building a programming language. And I was building it on the wrong foundation.

I thought I knew compiler engineering. I was a paid compiler engineer. I had been doing compiler engineering for years. I thought I knew enough to invent a programming language from living in San Francisco for years and doing nothing but sit around on computers and think about programming languages all day long every day. But once you start designing a compiler from scratch for a programming language that does not exist yet, you quickly learn how little you know. How little any of us know really.

I booked up. I admitted I didn't know what the fuck I was doing, and I booked up. I rewrote the compiler in C, then again in Zig. I read about compilers, type systems, garbage collectors. I interrogated the AI day and night about them. I read the textbooks.

So I started building Focal — a real language with a real type system, generator pipes, partial application, and components as first-class values. A language designed for the thing it's doing, not bolted on after the fact.

I learned about compiler engineering. Parsers, type inference, code generation. My back went out from working on it day and night. I bit off more than I could chew. Building a language is hard in a way that building applications isn't — every decision compounds, every shortcut becomes a wall later.

But while Focal was gestating, the problem didn't wait. I still needed to build sites. I still needed to ship things. So I built fungal — a static site generator with pods, built-in bundling, and Handlebars templates as a placeholder for the language that wasn't ready yet.

And then something unexpected happened. I realized that the architecture problem — the thing I'd been trying to solve with a new language — was solvable now, without the language.

The insight: you don't need Focal to escape the client-side framework trap. You need web components that handle the imperative DOM work, a build system that renders HTML at build time, and the discipline to let the browser be the browser. That's it. No new language required. JavaScript in its proper place — inside self-contained components that do one thing well — is fine. Good, even.

So I built MOAT. A library of web components you copy into your project. No npm, no framework, no build tool required. Light DOM, platform APIs, zero coupling. The imperative guts that make the declarative vision possible.

Fungal, MOAT, and the old web stack — domains, RSS, email, static files — solve the architecture problem today. No client-side framework. No JSON APIs feeding a reconciler. No virtual DOM diffing what the browser already knows how to render. Just HTML, served from the edge, enhanced by web components that own their own behavior.

You don't have to wait for the perfect language to stop doing the wrong thing.