vs Spreadsheets (Excel, Google Sheets)
The closest cousin. Spreadsheets made reactive programming visual. Quilt is what spreadsheets would be if they were designed today.
The mental model
A spreadsheet is a grid. Quilt is a graph.
Excel: Quilt:
A1 = 10 - id: budget.total
A2 = 20 kind: value
A3 = A1 + A2 value: 5000
- id: spent
kind: formula
expr: "rent + food + transit"
The grid is a constraint of the UI, not the model. Quilt's cells have stable addresses (budget.savings) that don't change when you insert a row.
vs Reactive frameworks (React, Vue, Svelte)
These frameworks made reactivity mainstream. Quilt is a different shape of the same idea — a runtime, not a UI library.
The mental model
React/Vue: Quilt:
function App() { - id: count
const [n, setN] = kind: value
useState(0) value: 0
return ( - id: doubled
<div>{n * 2}</div> kind: formula
) expr: "count * 2"
}
UI libraries are component graphs. Quilt is a cell graph. Both reactive, but Quilt is data-first, not DOM-first. A Quilt sheet has no UI; you give it one.
vs Databases (Postgres, Redis, SQLite)
Quilt is not a database. But it has cells, persistence (via time travel), and queries (via formulas). The lines are blurring.
The mental model
SQL: Quilt:
CREATE TABLE users ( - id: users.alice.name
name TEXT, kind: value
age INT value: "Alice"
); - id: users.alice.age
INSERT INTO users kind: value
VALUES ('Alice', 30); value: 30
SELECT name FROM users; get('users.*.name') # implicit
vs Config languages (YAML, TOML, JSON)
Quilt uses YAML as its wire format. But it's not just data — it's an executable document.
The mental model
YAML (data): Quilt (executable):
database: - id: database.host
host: localhost kind: value
port: 5432 value: localhost
- id: database.url
kind: formula
expr: "'postgres://' + database.host"
A config file is data. A Quilt sheet is a program that happens to be data-shaped. The line between code and config dissolves.
vs Workflow tools (Airflow, Prefect, Temporal)
These tools orchestrate work. Quilt is reactive, not orchestrated — the cells react, the system doesn't direct.
The mental model
Airflow: Quilt:
@task - id: extract
def extract(): kind: program
return fetch() code: "return await fetch()"
- id: transform
@dag(...) kind: formula
def pipeline(): expr: "JSON.parse(extract)"
extract() >> transform()
vs PLCs / SCADA (industrial automation)
Programmable Logic Controllers have been running factories on a cell-graph model since the 1970s. Quilt is the spreadsheet descendant of the same idea.
The mental model
PLC ladder logic: Quilt:
|---[temp]----(fan)---| - id: sensor.temp
kind: sensor
- id: motor.fan
kind: io
- id: control
kind: formula
expr: "sensor.temp > 25"
PLCs invented the reactive cell. Quilt brings the model to software, the cloud, the browser, and the $3 chip — anywhere there's a CPU.
vs Notebooks (Jupyter, Observable)
Notebooks made reactive programming narrative. Quilt is a notebook where every cell is named, addressable, and persistent.
The mental model
Jupyter: Quilt:
[1]: x = 10 - id: x
[2]: y = x * 2 kind: value
[3]: z = y + 1 value: 10
- id: y
kind: formula
expr: "x * 2"
- id: z
kind: formula
expr: "y + 1"
Notebooks are linear. Quilt is a graph. The dependency is explicit. The order doesn't matter. The cells have names.
The bottom line
When to use Quilt, when not to, and when it's the only option.