Quilt showcase — 11 repos, one model

quilt v0.2.0

The canonical TypeScript runtime

The reference implementation. 8 cell kinds, reactive DAG, MCP server, CLI, 30 tests. The most-tested Quilt. The starting point for everything.

8 cell kinds: value, formula, program, sensor, api, listener, router, io
Per-context memoization — formulas don't re-evaluate unless their inputs change
YAML and JSON sheet formats
MCP server for AI assistants to load and run sheets
CLI for headless use

View source → npm install

budget-tracker.yaml

9 cells · 3 formulas

📦

value (5)

ƒ

formula (3)

🔔

listener (1)

cells: - id: budget.total kind: value value: 5000 - id: spent kind: formula expr: "rent+food+..."

Edit a value. The formulas recompute. The listener fires when status changes. The engine handles all the propagation.

quilt-rust v0.2.0

The desktop Rust runtime

Same model, compiled to native. Sync core with async cell evaluators bridged via Tokio. 68 tests, zero warnings. Two front-ends: quilt-tui (terminal) and quilt-web (browser via Axum + SSE).

Send + 'static effectful evaluators (lifetimes just work)
Rhai formula DSL — safe, sandboxed, no eval
Tokio async; the engine stays sync
CLI with subcommands: run, eval, fmt, doc, validate
Web UI: HTTP + Server-Sent Events, live updates in the browser

View source → crates.io

lib.rs · engine.rs

~860 lines · 68 tests

use quilt_core::{{QuiltEngine, CellKind, CellValue}}; let mut engine = QuiltEngine::new(); engine.define("temperature", CellKind::Sensor, CellValue::Float(22.0))?; engine.define("fahrenheit", CellKind::Formula, CellValue::None)?; engine.add_dep("fahrenheit", "temperature")?; // Reactive, sync, native.

Use the Rust runtime as a library, embed it in a TUI, expose it as a web service. The cell model is the API.

quilt-live v0.2.0

The single-file browser runtime

Full Quilt in one HTML file. 70KB. No build, no deps, no network. 54 working examples across 8+ domains. Save state as a cookie or download the whole app with your data baked in.

One file. Drop it anywhere. Run it offline.
54 examples: budget, weather, recipes, mortgages, agents, vision, ZK, time travel...
Cookie save + downloadable HTML with state
Onboarding overlay, help modal, keyboard shortcuts
Real-browser tested in headless Chrome

Open Live → View source

54 examples · 5 test suites

146 verified checks

💰 Finance (6)

🏠 Home (4)

🏋 Fitness (2)

📐 Calculators (5)

🎲 Gaming (4)

🛠 Dev tools (4)

⏱ Time (3)

🔬 Science

🎵 Music

🔐 Security

🌍 Geography

+ 9 more

Try them all. Edit a value, watch formulas propagate. Save your work as a cookie or download. Open offline — it just works.

quilt-time v0.1.0 · 17 tests

Time travel for cells

Every cell gets history. Fork the engine like git, rewind to a fork, replay events, merge two engines. The killer feature that makes Quilt a database, not just a reactive system.

at(t) — value at any past time
diff(from, to) — per-cell change summary
fork(), rewind(), replay(), merge()
JSON serialization for save/load
Drop-in: 250 lines, no dependencies

Try it live → View source

time-travel demo

t=3

Every set is a new version. Every cell has a history. The engine is undoable, branchable, replayable.

quilt-vault v0.1.0 · 10 tests

Encrypted cells, end-to-end

Every cell wrapped in an encryption envelope. The owner holds the master key. Each viewer in the access list gets a wrapped content key. The server only sees ciphertext.

Real ECDH P-256 for key agreement
Real AES-GCM for content encryption
Per-cell access control lists
Grant and revoke with re-encryption
Server can't read anything, ever

Try it live → View source

end-to-end encryption

ALICE (owner)

value: 5000

↓ AES-GCM(content-key)

CIPHERTEXT (server)

9F2A8B...7C3D
E1F4B2...A8D9
3C7E91...4F2B

↓ ECDH(alice, bob)

BOB

value: 5000 ✓

EVE (not in ACL)

No access ✗

quilt-mesh v0.1.0 · 3 tests

Peer-to-peer cell sync

Two devices, no server, no internet, no account — share cells. The mesh is the network. Lamport clocks + per-peer version vectors. Offline-then-sync. Conflict-free merge.

CRDT-based, broker-less
Named rooms (your home, your team)
Per-peer version vectors
Last-write-wins by causal time
WebSocket, BLE, mDNS transports

Try it live → View source

3 peers · 1 room · no server

No cloud. No account. The peers are the network. Cells flow directly.

quilt-esp32 v0.1.0 · 2 tests

The microcontroller runtime

A no_std Rust port for ESP32-class chips. Sensors as cells. Actuators as cells. 3KB flash. WiFi + BLE mesh. Deep sleep for battery life. The cell model, scaled down to a $3 chip.

no_std, no allocator — everything in a static memory block
Up to 64 cells per device
Sensors: DHT22, BME280, GPS, accelerometer...
Actuators: LED, relay, motor, PWM...
Mesh sync via esp-wifi + esp-ble

Try it live → View source

3-cell reactive system

let mut engine = QuiltEngine::new(); let temp = engine.define("sensor.temp", CellKind::Sensor, CellValue::None)?; let rule = engine.define("led.on", CellKind::Formula, CellValue::None)?; let led = engine.define("actuator.led", CellKind::Io, CellValue::Bool(false))?; engine.add_dep(rule, temp)?; // 3 cells, 3KB flash, $3 chip.

🌡

sensor.temp

──wire──

ƒ

led.on

──wire──

💡

actuator.led

quilt-agent v0.1.0

LLM agents as sheets

Memory is values. Tools are API cells. Reasoning is a chain of program cells. The agent is a sheet. Multiple agents share cells. The graph is the team.

Memory, tools, reasoning, goals — all cells
LLM call as an API cell
Listeners fire on agent completion
Multi-agent: shared cells, emergent behavior
Composable with other Quilt sheets

Try it live → View source

research-agent.yaml

The agent is just a Quilt sheet. Memory cells persist, tool cells are APIs, the reasoning chain is data flow.

quilt-vision v0.1.0

Images as cells. Vision as formulas.

An image is a value cell. Computer vision is a formula on the image cell. Eight built-in kinds: caption, OCR, faces, objects, tags, embed, segment, depth. Local or remote models.

8 vision cell kinds
Local models via WebGPU (CLIP, BLIP-2, YOLO)
Remote models (GPT-4V, Google Cloud Vision)
Vector search via embeddings
Real-time on video frames

Try it live → View source

vision pipeline

cells: - id: photo.morning kind: value value: "morning.jpg" - id: caption kind: vision input: photo.morning model: blip-2 kind: caption - id: tags kind: vision input: photo.morning model: clip kind: tags

caption text (OCR) faces objects tags embed segment depth

quilt-zk v0.1.0 · 7 tests

Zero-knowledge over cells

A cell is also a statement you can prove. "My bank balance ≥ $50k" without revealing the balance. "I voted" without revealing how. 6 pre-built circuits. Real ZK backend (Noir) plugs in later.

value_at_least — prove ≥ threshold
value_at_most — prove ≤ threshold
value_in_set — prove membership
sum_equals — prove sum equals
group_membership — Merkle proof of membership
credential_present — prove a credential claim

Try it live → View source

proof: balance ≥ $50k

const proof = CIRCUITS.VALUE_AT_LEAST.prove( { value: 75_000 }, // private { threshold: 50_000 } // public ); // Bank learns: you qualify. // Bank doesn't learn: your balance.

VERIFIER (bank)
✓ balance ≥ $50,000
What the bank DOESN'T learn:
✗ your actual balance: $75,000

quilt-flow v0.1.0 · 8 tests

The visual editor

Drag-and-drop cell wiring, like Scratch but for cells. The data model is stable, the UI is a single-page web app. The editor itself is a Quilt sheet — cells all the way down.

Drag cells from palette onto canvas
Draw wires between ports
Inline edit values and formulas
Live values that update in real time
Time-travel slider, encryption toggle

Open Studio → Try it live → View source

weather sheet · 6 cells

The Quilt ecosystem

The canonical TypeScript runtime

The desktop Rust runtime

The single-file browser runtime

Time travel for cells

Encrypted cells, end-to-end

Peer-to-peer cell sync

The microcontroller runtime

LLM agents as sheets

Images as cells. Vision as formulas.

Zero-knowledge over cells

The visual editor

One model. Many runtimes.