Frequently asked questions

Quilt is a reactive, typed, cellular runtime. A spreadsheet where every cell is a live, addressable capability. The sheet is the program, the cell is the universal IO.

See the manifesto for the full story.

Quilt makes reactive programming visual and inspectable. You see the cells. You see the wires. You see the propagation. You see the value. Every cell has a name, a kind, a value, and dependencies. You can address any cell by name from anywhere — the engine, the CLI, the UI, an MCP client, a peer.

It's the spreadsheet model, finally made real for software.

Personal data apps, smart home controllers, AI agents, financial dashboards, IoT meshes, multiplayer games, real-time analytics — anything that fits the "reactive value + state" model. See the apps gallery for 30 examples.

It's a runtime that has database properties: persistence (via quilt-time), distribution (via quilt-mesh), encryption (via quilt-vault). It's not a SQL database; the cell model is the API.

Quilt is a runtime. The "language" is YAML (for sheets) and JavaScript or Rust (for programs inside cells). The cell model is the API surface; the YAML is the public contract.

Yes. The canonical runtime is Apache 2.0; the supporting repos are MIT. The code is at github.com/SuperInstance/quilt.

The SuperInstance org. It's a small team, working in the open.

value — a static value. formula — a reactive expression. program — an async body. sensor — a polled input. api — an outbound call. listener — fires on change. router — context-aware dispatch. io — a physical port.

See the deep dive for examples of each.

In TypeScript, yes — extend the engine. In Rust, also yes. In Live, the 8 kinds are fixed. The point of a fixed vocabulary is that sheets are portable across runtimes.

Hierarchical, dot-separated. Like kitchen.temp, budget.savings, agent.memory.short. The dot is just naming convention; the engine treats it as one string.

No. The engine detects cycles at load time and refuses to evaluate. Cycles are a code smell in reactive systems; the engine tells you where.

A cell called by different callers can have different cached values, based on the caller's context. This is what makes router cells work — the same cell, two different outputs, two different caches.

No. That would be a cycle. The engine would refuse to load the sheet.

Two implementations: TypeScript (the canonical, npm-installable) and Rust (the production, single-binary). They share the same sheet format and the same cell model. See the comparison for tradeoffs.

YAML. A cell is a YAML map with an id and a kind, plus kind-specific config. The same sheet format works in TypeScript, Rust, and Live.

id: example
cells:
  - id: a
    kind: value
    value: 10
  - id: doubled
    kind: formula
    expr: "a * 2"

Topological sort over the cell graph. When a cell changes, the engine computes the cascade — every cell that transitively depends on it — in dependency order. No re-evaluation of unchanged cells.

A formula cell that throws has a status of error, with the error message preserved. Dependent cells get a degraded value but don't crash. You can subscribe to errors and react.

Use the program cell kind. It's an async function with await, side effects, and a return value. For pure async, use api cells, which are lazily fetched and cached.

The formula language is JavaScript. You have access to Date, Intl, Math, and the standard library. There are no Quilt-specific date types — use what's in the language.

Real numbers on a MacBook Pro M2: 0.05ms average cell evaluation in TypeScript, 0.008ms in Rust. A 1,000-cell cascade in 30ms (TS) or 4.5ms (Rust). See the full benchmarks.

Linear in the size of the cascade, not the size of the sheet. A 10,000-cell sheet with one root change touches only the cells in the cascade. Topological sort is O(V + E).

Empty engine: 2 MB (TS), 800 KB (Rust). 1,000 cells: 8 MB (TS), 1.5 MB (Rust). The Live HTML file is 70 KB. The Rust binary is 3.2 MB stripped.

Yes — see quilt-esp32. A no_std Rust port that fits in 32 KB of flash, with 64 cells, 8 deps per cell, 32-char IDs. Runs on a $3 chip.

No. Quilt Live runs entirely in the browser. The TypeScript runtime runs in your Node process. The Rust runtime runs in your container. You bring the server, if any. The cell is the unit of storage; the engine is the unit of execution; you control both.

Yes — see quilt-vault. Per-cell encryption with ECDH P-256 + AES-GCM, real WebCrypto. The server (if any) sees only ciphertext. Per-cell ACLs are built in.

Yes — api cells do exactly that. The cell model is uniform: a value is a value, regardless of where it came from. If you want to lock down network access, you can run Quilt with a fetch policy that disallows certain domains.

Formulas are new Function() with the cells in scope. If a user can edit a formula, they can run arbitrary JavaScript. The same is true of Excel macros. Don't let untrusted users edit formulas in a shared sheet.

Three ways: as a library (npm install, import, ship with your app), as a binary (cargo build → 3.2 MB static binary → drop on any Linux/macOS/Windows/ARM), or as a single HTML (the Live file, email it, commit it, run it offline forever). See the build page.

Yes. The Rust port compiles to a 3.2 MB static binary. Cold start is ~12ms. Perfect for AWS Lambda, Cloudflare Workers (via WASM), Vercel Edge Functions, or a Graviton instance.

The sheet is a YAML file. You deploy it like any other file. Update the file, restart the engine. For live updates, the engine can be configured to hot-reload sheets from a file watcher.

In Quilt Studio, yes — there's multi-user collab via BroadcastChannel (same machine) or WebRTC (cross-machine, in development). For server-mediated collab, the engine exposes a CRDT via quilt-mesh.

See the full 5-year roadmap. Near-term: real-time multiplayer via WebRTC, more cell kinds, the production IDE, encrypted version history, MCP for every cell. Far-term: Quilt-on-Quilt (a sheet that edits its own sheet), a mesh of personal devices, the runtime for personal AI.

When the documentation is complete, the API is stable, the tests cover 95%+, and we've shipped 5,000 stars. Roughly Q3 2026. Current is v0.2.0.

Open an issue on GitHub. Pick a good first issue. File bugs. Suggest examples. Build a sheet and share it. Help with docs. Help with translations. The community is small; every contribution matters.

GitHub issues for bugs and feature requests. Discussions for questions. The Discord (TBD) for chat. Or open a Discussion on GitHub.

Not yet. GitHub Discussions is the main channel. We'll launch a Discord when the community is big enough to need it.

Yes, the license is Apache 2.0 (TS) or MIT (Rust). Use it commercially, modify it, ship it. Attribution appreciated, not required.

The team is small. We're not a consultancy. But there are early adopters in the community who can help. Reach out via GitHub.

The canonical runtime is Apache 2.0. The supporting repos (mesh, time, vault, etc.) are MIT. The site content (this page) is CC BY 4.0.