The Quilt Manifesto

The shape of the problem

Software is built out of nouns and verbs. The nouns are data. The verbs are operations. The relationship between them is what we call programs.

For fifty years, we have built programs out of functions. A function takes data, transforms it, returns data. Functions compose. Functions are the unit. This is the model of essentially every language and framework since Lisp.

It works. It scales. It's not wrong. But it's not the only shape. There is another shape, just as old, that we have largely ignored.

The spreadsheet.

The shape of the spreadsheet

A spreadsheet is also nouns and verbs. The nouns are cells. The verbs are formulas. The relationship is wires: a formula depends on certain cells; when those cells change, the formula recomputes.

This is a reactive system. A cell is not a value — a cell is a live, addressable, reactive thing. The spreadsheet is the runtime. The cell is the universal IO.

The spreadsheet was the killer app of the 1980s because it made reactive programming visual. You see the formulas. You see the values. You see the propagation. The system is inspectable in a way that no other software has ever been.

The spreadsheet is the most successful end-user programming language in history. And we don't think of it as a programming language — because it doesn't look like one.

What was missing

Spreadsheets were missing three things.

First, types. A cell can be a number, a string, a date, or — by accident — a Boolean, a list, an object. The spreadsheet has no concept of a cell's kind. It treats everything as a scalar, and coerces at the boundaries.

Second, side effects. A cell is a value. It can be displayed, exported, charted. But it can't do anything — it can't make a network call, it can't drive a motor, it can't log an alert. Spreadsheets are read-mostly.

Third, names. A cell is identified by its row and column: A1, B17. Insert a row, and B17 becomes B18. The address is fragile; the data is tied to its position.

What Quilt adds

Quilt takes the spreadsheet model and fills in what was missing.

• Types. A Quilt cell has a kind: value, formula, program, sensor, api, listener, router, io. The kind determines what the cell does, what its inputs are, and how it propagates.
• Side effects. A program cell can run async code. A listener cell can fire on change. A sensor cell can poll the world. An io cell can drive a motor. The cell is the universal IO.
• Names. A Quilt cell has a stable, hierarchical name: kitchen.temp, budget.savings, agent.memory. The address is a name, not a coordinate. Cells don't move when the sheet changes.

The paradigm shift

That's the shift. The spreadsheet, finally, is not the artifact. The spreadsheet is the program. The cell is the function. The wire is the data flow. The engine is the runtime.

What this unlocks

Once you accept that the spreadsheet is the runtime, several things become possible that weren't before.

1. Inspectability

Every cell is a value. Every wire is a dependency. Every change is a propagation. The whole system is visible, all the time, in a way that no other software has ever been. A spreadsheet, but live.

2. The mesh

Two spreadsheets can sync. No server, no API, no schema. Just a CRDT, propagating the changes. The cell is the unit of synchronization. The wire is the unit of conflict resolution.

3. Time travel

Every cell has a history. You can rewind to last Tuesday and see what your budget looked like. You can fork a sheet, try a different budget, and rewind if you don't like it. The cell is a versioned value.

4. Encryption

A cell can be encrypted. The server sees only ciphertext. The peers see only the cells they're authorized for. The cell is the unit of privacy.

5. Agents

An agent is a sheet. Its memory is a value cell. Its tools are API cells. Its reasoning is a chain of program cells. Its goals are listener cells. Every capability is inspectable, addressable, and persistent.

The architecture

Three layers, cleanly separated. The sheet is declarative. The engine is reactive. The harness is the entry point. You can use any layer in isolation.

The 5-year arc

The full vision is bigger than one runtime. It is a stack.

What this is for

Quilt is for the things that the cloud does badly and the spreadsheet does well.

For personal data that lives on personal devices, in a personal mesh, encrypted at rest, synced peer-to-peer, versioned by default, inspectable at will. Not on a server, not in a database someone else controls. On your own machine, in your own format, under your own keys.

For the agents that will live in our lives — assistants, schedulers, planners, companions — and need a runtime that's addressable, inspectable, and persistent. Not an LLM in a chat window. A program in a sheet, with memory, with tools, with a state.

For the IoT mesh that will be the edge of the next decade — a hundred small things, each with a state, each reactive to the others, each addressable by name. The cell model is the shape.

For the programmable world, where everything is a cell and every cell is a program. Where the spreadsheet is the runtime and the runtime is the spreadsheet.

The promise

The cell is the universal IO. The sheet is the runtime. The mesh is the network. The model is finally made real.

That's the project. If you read this far, you understand. Welcome to Quilt.

— SuperInstance, 2026