Sheet → binary

A Quilt sheet is a program. Pick a target. Get a deployable artifact. One command, one output. The cell model stays the same.

🦀

Static binary

Linux · macOS · Windows · ARM
🔌

MCP server

stdio · sse · http
🌐

Web bundle

single HTML · npm
🔌

ESP32 firmware

no_std · 32 KB flash
📦

WASM module

any host · sandboxed
🐳

Docker image

scratch · distroless

Source sheet

→click "Build" to compile

What the build does

Every target goes through the same pipeline. The cell model is preserved across all of them.

1
Parse sheet
Read the YAML, validate against the schema, build the cell graph.
2
Resolve deps
Topological sort, detect cycles, mark reachable cells.
3
Bundle
Inline the engine, the cells, the adapters — into a single artifact.
4
Emit
Compile (Rust), link (binary), package (image, mcp, npm), or render (HTML).
5
Verify
Smoke test the artifact: load, evaluate, check the cell values.

By the numbers

The build pipeline, with the actual outputs from real runs.

$quilt build --target binary ./weather.yaml
→ parse sheet (8 cells, 8 edges)
→ topological order: sensor.temp, sensor.humid, …
→ compile to Rust: 8 cells, 1 listener, 2 sensors
→ cargo build --release: 12.4s
✓dist/weather (3.2 MB, static, stripped)
$quilt build --target mcp ./weather.yaml
→ parse sheet (8 cells)
→ expose 8 MCP tools (one per cell)
→ stdio transport
✓dist/weather-mcp (4.1 MB, stdio)
$quilt build --target web ./weather.yaml
→ inline engine (640 lines JS)
→ inline sheet (8 cells)
→ inline UI template
✓dist/weather.html (70 KB)
$quilt build --target esp32 ./weather.yaml
→ strip non-esp cells (no API, no listener if no actuator)
→ compile to no_std Rust
→ cargo build --target xtensa-esp32-espidf: 18.7s
✓dist/weather-esp32.bin (32 KB, flashable)
$quilt build --target wasm ./weather.yaml
→ compile to WASM (32-bit float, no threads)
→ optimize: -O3, lto, strip
✓dist/weather.wasm (180 KB, any host)

What you can do with the artifacts

Static binary (3.2 MB)

Run on a server: ./weather --mcp --port 8080. The whole sheet is now an HTTP+stdio MCP server. Claude Code, Cursor, or any MCP client can use it.

MCP server (4.1 MB)

Plug into Claude Code: claude mcp add weather ./weather-mcp. Now every cell is a tool Claude can call. The sheet is the tool registry.

Web bundle (70 KB)

Email it. Commit it. Run it offline forever. The download is a single HTML file with the engine, the sheet, and the UI all inlined. No server, no build, no install.

ESP32 firmware (32 KB)

Flash to a $3 chip: espflash flash weather-esp32.bin. The sheet is now the firmware. 8 sensors and actuators, a reactive engine, 32 KB total.

WASM module (180 KB)

Load from any host: const engine = await WebAssembly.instantiate(wasm). The cell model is the API. The host gets the cells; the WASM gets the engine.

Docker image (8 MB)

Deploy anywhere: docker run -p 8080:8080 quilt/weather. The image is scratch-based. The binary is the only thing in it. 8 MB total, no layers, no shell, no package manager.

The same model, six targets

This is the unlock. You write a sheet once. The cell model is preserved across every target. Same names, same kinds, same propagation. The target is just the runtime.

weather.yaml
├─ → binary (Linux x86_64)
├─ → binary (macOS aarch64)
├─ → binary (Windows)
├─ → binary (Raspberry Pi)
├─ → MCP server (stdio)
├─ → MCP server (HTTP/SSE)
├─ → Web bundle (HTML)
├─ → npm package
├─ → WASM module
├─ → ESP32 firmware
└─ → Docker image