🔮 Polyformalism — Quilt in 12 languages

Same model, every language. What works crazy well. What needs crazy workarounds. What you learn by expressing the same idea in 12 different language constraints.

☕ Buy Casey a Coffee

Home Workspace Fleet Polyformalism Infrastructure Playground AI sheet

Polyformalism is the practice of expressing the same model in many different formal languages to discover what's essential vs accidental. You write the same Quilt cell system in 12 different programming languages. Each language's constraints force different choices. The differences reveal the model. The similarities confirm the model.

This page is the entry point to the 12-language Quilt polyformalism. Each card is one language. Each one has a GitHub repo, a splash image, a philosophy, concrete proof, and insights you can only get from that language's perspective.

The polyformalism methodology

From the parent framework at github.com/SuperInstance/polyformalism:

Pick a constraint kernel. The Quilt cell model: a typed value, a formula, a listener, a dependency edge.
Express it in each language. No translation guides. The language's idiom is the point.
Note what works crazy well. Each language has a feature that makes the model more natural than the canonical version.
Note what needs crazy workarounds. Each language has a constraint that forces a non-obvious choice.
Synthesize insights. The things that are easy everywhere are essential. The things that are hard in one place are likely accidental.
Iterate the canonical version. The polyformalism back-pressure makes the original better.

The 12 languages

quilt (TypeScript)

Canonical · 2024

The original. 9 cell kinds, reactive evaluation, federation, 96 tests.

"Reactive evaluation is natural in JS. It hides the state machine structure."

GitHub README

quilt-tutor

1970s PLATO · Foundational

The original cell-based authoring system. Multi-user cells by default.

"Multi-user cells are the default in Tutor. Federation is a 1970s feature, not a 2020s one."

GitHub README

quilt-pydantic-ai

2026 · Production Python

The modern descendant of Tutor. Type-safe cells for LLM agents.

"Pydantic is to Pydantic-AI what Fortran was to Tutor. Both are the trusted type layer."

GitHub README

quilt-mojo

2024 · AI hardware

Cells as types. SIMD-friendly formulas. Compile-time reactivity.

"In Mojo, the cell is a struct, not a value. The type IS the cell kind."

GitHub README

quilt-julia

2012 · Scientific

Multiple dispatch = cell kinds. The reactive engine IS the type system.

"Cell kinds become types. Formulas become methods. The engine is just dispatch."

GitHub README

quilt-chapel

2009 · HPC

Distributed cell evaluation across locales. Cells are inherently parallel.

"In Chapel, cells are first-class distributed. The reactive engine runs on every node."

GitHub README

quilt-cobol

1959 · Business legacy

The cell model is older than spreadsheets. COBOL programmers were doing it.

"The four COBOL divisions are a layered cell system. IDENTIFICATION is metadata, PROCEDURE is the reactive engine."

GitHub README

quilt-c

1972 · Bare metal

The mathematical core. Cells = structs. Formulas = functions. No sugar.

"In C, the cell model is just a struct + a function table. Everything else is sugar."

GitHub README

quilt-cpp

1985 · Systems modern

Templates reveal the cell kind lattice. Type-erasure for any cell.

"`std::variant<>` is the perfect cell value. `std::function<>` is the perfect formula."

GitHub README

quilt-csharp

2000 · Enterprise

Records for cells, delegates for formulas, events for listeners. LINQ for graph queries.

"C# has all the pieces already. Records + delegates + events + LINQ. Just compose them."

GitHub README

quilt-metal

2014 · GPU

Cells evaluated in parallel on the GPU. Kernels = formulas. Buffers = cell values.

"The cell model is inherently parallel. The GPU is the natural runtime."

GitHub README

quilt-swift

2014 · Apple

Actors for cell isolation. `@Published` is exactly a Quilt cell.

"Swift's Combine framework IS a cell engine. The polyformalism finds what was always there."

GitHub README

The cross-language comparison

Language	Era	Cell =	Formula =	Insight
TypeScript	2024	`{path, kind, value}`	`(ctx) => any`	Reactivity is natural
Tutor	1970	`$variable`	`do fortran.X`	Multi-user by default
Pydantic-AI	2026	`BaseModel`	`Callable[[dict], Any]`	Types are the contract
Mojo	2024	`struct`	`@always_inline fn`	Cells are types
Julia	2012	`struct`	`method on type`	Engine is the type system
Chapel	2009	`var` on locale	`proc`	Cells are distributed
COBOL	1959	`01 RECORD`	`PERFORM`	Hierarchy is explicit
C	1972	`struct`	`function ptr`	Everything is sugar
C++	1985	`std::variant`	`std::function`	Templates reveal the lattice
C#	2000	`record`	`delegate`	All pieces already exist
Metal	2014	`buffer`	`kernel fn`	Cells are inherently parallel
Swift	2014	`@Published var`	`async fn`	Combine is a cell engine

The polyformalism insight

The 12 languages differ in 12 ways. They agree on 1 thing: a cell is a typed value, a formula is a function, a listener is a reaction, a sheet is a collection of cells with dependencies. That agreement is the model. The differences are the polyformalism findings.

The polyformalism methodology also iterates back. The insights from each language version feed back into the canonical TypeScript version. quilt-pydantic-ai in particular is iterated twice — once at the start (as the modern equivalent of Tutor) and once at the end (informed by all the other languages). The end version is better than the start version. That's the back-pressure working.