⬢ Quilt

The reactive, typed, cellular runtime. A spreadsheet that thinks. A database that reacts. A control plane that's a single file. Twenty-five open-source repos. One ecosystem.

The point • Philosophy • Architecture • Concrete proof • The 25 repos • Get started • Why care

---

✦ The point

You're building software. Some of it is a web app, some is an embedded sensor, some is a data pipeline, some is an LLM agent, some is a control plane for a fleet of edge devices. Each one has a different framework, a different language, a different deployment story. Each one breaks in different ways. Each one has a different way of testing, observing, and evolving.

Quilt is one model that fits all of them. A cell is a value, a formula, a listener, an API call, an AI call, a sensor, a router, a program, or a vector store. A sheet is a JSON document of cells with dependencies. An engine evaluates the sheet reactively — when a cell changes, every cell that depends on it is recomputed. The same model runs in the browser, on a server, on a Cloudflare Worker, on a Raspberry Pi, on a Jetson, on an ESP32.

If you've ever wished your entire software system could be a single reactive spreadsheet, Quilt is for you.

✦ The philosophy

Most software is built in layers. A presentation layer. A business logic layer. A data layer. An infrastructure layer. Each layer speaks a different language, uses a different framework, and breaks in a different way. The result is complexity that compounds with every line of code.

Quilt proposes a different model. Everything is a cell. A user input is a cell. A computed value is a cell. An API call is a cell. A database record is a cell. A webhook is a cell. A LLM call is a cell. A sensor reading is a cell. A scheduled task is a cell. They're all just nodes in a reactive graph.

The implication: your entire system is a JSON document. The cells describe the data. The formulas describe the computation. The listeners describe the side effects. The engine evaluates the graph reactively. There's nothing else.

                          ┌──────────────────────┐
                          │   Quilt Sheet (JSON) │
                          │                      │
                          │  "a": 1,             │
                          │  "b": 2,             │
                          │  "sum": a + b,       │
                          │  "log": listens sum  │
                          │                      │
                          └──────────┬───────────┘
                                     │
                          ┌──────────▼───────────┐
                          │  Quilt Engine        │
                          │  (TypeScript / Rust) │
                          │                      │
                          │  reactive evaluation │
                          │  memoization         │
                          │  listener firing     │
                          │  federation          │
                          └──────────┬───────────┘
                                     │
              ┌──────────────────────┼──────────────────────┐
              │                      │                      │
       ┌──────▼──────┐        ┌──────▼──────┐        ┌──────▼──────┐
       │   Browser   │        │  Cloudflare │        │  ESP32      │
       │   (TS)      │        │  Worker     │        │  (Rust)     │
       └─────────────┘        └─────────────┘        └─────────────┘

The same sheet. The same engine. Different runtimes. That's the entire point.

✦ The architecture

Quilt is a 25-repo ecosystem organized in 6 layers:

                    ╔═══════════════════════════╗
                    ║  L8  Ecosystem / community ║  25 repos, cross-refs
                    ╠═══════════════════════════╣
                    ║  L7  Workflows / demos     ║  30+ work-doing pages
                    ╠═══════════════════════════╣
                    ║  L6  Invisible elves       ║  quilt-elf (5 components)
                    ╠═══════════════════════════╣
                    ║  L5  Embedded orchestrators ║  quilt-swarm, quilt-nomad
                    ╠═══════════════════════════╣
                    ║  L4  Specialized cells     ║  time, vault, vision, zk, flow
                    ╠═══════════════════════════╣
                    ║  L3  Cell + AI core         ║  quilt-core, quilt-ai, quilt-evolve
                    ╠═══════════════════════════╣
                    ║  L2  Federation             ║  quilt-fleet, quilt-mesh, quilt-agent
                    ╠═══════════════════════════╣
                    ║  L1  Hygiene / engineering  ║  LICENSE, CI, Dependabot, ESLint
                    ╚═══════════════════════════╝

The first three layers (L1-L3) are the foundation. The next three (L4-L6) are the value-add. The top two (L7-L8) are the experience.

Every repo at every layer cross-references the others. Every repo has the same engineering bar: Apache 2.0 license, GitHub Actions CI, CODEOWNERS, SECURITY.md, Dependabot, ESLint.

✦ Concrete proof

1. A Quilt sheet, top to bottom:

import { QuiltEngine } from '@quilt/core';

const engine = new QuiltEngine('expense-tracker');

engine.loadSheet({
  name: 'expense-tracker',
  cells: [
    // Inputs (the knobs you turn)
    { path: 'income',      kind: 'value', value: 5000 },
    { path: 'food',        kind: 'value', value: 800  },
    { path: 'rent',        kind: 'value', value: 1500 },
    { path: 'transport',   kind: 'value', value: 200  },

    // Derived (recompute when inputs change)
    { path: 'total_spent', kind: 'formula',
      fn: (ctx) => ctx.food + ctx.rent + ctx.transport },
    { path: 'savings',     kind: 'formula',
      fn: (ctx) => ctx.income - ctx.total_spent },
    { path: 'savings_rate', kind: 'formula',
      fn: (ctx) => ctx.savings / ctx.income },

    // Reactive (fires when a value changes)
    { path: 'on_spend_change', kind: 'listener', listens: 'total_spent',
      fn: (ctx) => console.log('Total spent:', ctx.total_spent) },
  ],
});

console.log(engine.get('savings_rate'));  // 0.5

engine.set('food', 1000);  // changed a value
console.log(engine.get('savings_rate'));  // 0.46 (auto-recomputed)

Try it live →

2. AI-powered sheets:

Type "Track my expenses with food, transport, and income". z.ai generates the sheet.

Try AI sheet →

3. A reflex engine in your browser:

A reflex engine that learns to respond to "list containers" in <50ms without an LLM. After enough uses, it never needs the LLM.

Try Pincher →

4. A multi-instance fleet with federation:

Watch cells propagate across 4 simulated instances with simulated network latency.

Try Federation →

5. Chaos engineering on K3s:

Run 5 failure scenarios (node down, network partition, disk full, API down, etcd down) with Kimi-designed recovery thresholds.

Try Chaos test →

6. A live inspector for any sheet:

Visualize any Quilt sheet as a dependency graph. Click any node to inspect.

Try Inspector →

✦ The 25 repos

#	Repo	What it does
1	quilt	The core engine. 9 cell kinds, reactive evaluation.
2	quilt-rust	Rust port. Sync core, async cells.
3	quilt-live	The whole engine in one HTML file. 70KB.
4	quilt-esp32	no_std Rust for ESP32.
5	quilt-mesh	Distributed cell graph.
6	quilt-agent	Agent substrate. 5 SDK primitives.
7	quilt-time	Time cells: cron, intervals, debouncing.
8	quilt-vault	Encrypted secret cells.
9	quilt-vision	Vision cells: object detection, OCR.
10	quilt-zk	Zero-knowledge cells.
11	quilt-flow	Flow control cells.
12	quilt-cloudflare	Cloudflare Workers runtime.
13	quilt-ai	AI cell kinds. 4 providers.
14	quilt-evolve	Self-evolving cells. RLAIF.
15	quilt-codespace	GitHub Codespaces runtime.
16	quilt-jetson	NVIDIA Jetson runtime. CUDA.
17	quilt-rag	Production RAG as cells.
18	quilt-fleet	Multi-instance federation.
19	quilt-elf	Invisible elves. LLM-powered background workers.
20	quilt-pincher	Reflex engine as Quilt cells.
21	quilt-base	Minimal container base images.
22	quilt-swarm	Docker Swarm control plane.
23	quilt-core-os	Immutable Ubuntu Core appliance.
24	quilt-k3s	K3s chaos testing framework.
25	quilt-nomad	HashiCorp Nomad control plane.
26	quilt-tutor	Polyformalism: Quilt in PLATO Tutor (1970).
27	quilt-pydantic-ai	Polyformalism: Quilt as a Pydantic-AI agent.
28	quilt-mojo	Polyformalism: Quilt in Mojo.
29	quilt-julia	Polyformalism: Quilt in Julia.
30	quilt-chapel	Polyformalism: Quilt in Chapel.
31	quilt-cobol	Polyformalism: Quilt in COBOL.
32	quilt-c	Polyformalism: Quilt in C.
33	quilt-cpp	Polyformalism: Quilt in C++.
34	quilt-csharp	Polyformalism: Quilt in C#.
35	quilt-metal	Polyformalism: Quilt in Metal.
36	quilt-swift	Polyformalism: Quilt in Swift.

Plus the live workspace with 30+ work-doing tool pages, and the polyformalism page that compares the 12 languages.

The 12 polyformalism repos all express the same model in different language constraints. See the comparison →

✦ Getting started

In a browser (no install):

<script type="module">
  import { QuiltEngine } from 'https://cdn.jsdelivr.net/npm/@quilt/core@0.6.0/dist/index.js';
  // ...
</script>

Or try the live playground →

In Node:

npm install @quilt/core

import { QuiltEngine } from '@quilt/core';
const engine = new QuiltEngine('my-app');

On a Cloudflare Worker:

npm install @quilt/cloudflare

On a Raspberry Pi / Jetson / ESP32:

See quilt-codespace, quilt-jetson, quilt-esp32.

✦ Why you should care

If you've ever wished your system was simpler. If you've ever had a service that depended on five other services and you couldn't keep track of the dependencies. If you've ever wanted a config file that was also a program. If you've ever wanted one model that runs in the browser, the server, and the embedded device. If you've ever wished your software was more like a spreadsheet — reactive, visual, easy to change.

This is for you.

✦ License

Apache 2.0. See LICENSE.

---

The point is not the 25 repos. The point is the one model.