The Polyglot

Unlambda + Brainfuck + APL — all compile to the Quilt cell graph

One VM. One substrate. One conservation law. One watch.

Combinators Register Machine Array Algebra 8 Primitives 22 Opcodes 1 Conservation Law

The 3 Languages

Substrate: SKI Combinatory Logic

Data type: only single-argument functions

Core: `s `k `i `r `. `v

Sample: `sii = identity combinator (since I = SKK)

Map to Quilt: K→Z_in, S→JEPA, I→Z_out, B→DoubleEntry, Y→Graph

Substrate: Register Machine

Data type: byte cells on a tape

Core: > < + - . , [ ]

Sample: ++++++++[>++++++++++<-]>++. = "RT"

Map to Quilt: ,→Z_in, .→Z_out, +/-→Vibe, >/<→Graph, [/]→Murmur

Substrate: Array Algebra

Data type: arrays of any rank

Core: +/ +\ ⍳ ⍴ ↑ ↓ ⍉ ∘.

Sample: +/⍳10 = sum of 1 to 10 = 55

Map to Quilt: ⍳→Z_in, +/→JEPA, ⍴→Vibe, ↓→GC, ↑→Murmur, ⍉→Graph

Try the same program in three languages. They all run on the same Quilt cell graph.

Brainfuck

Unlambda

APL

Source:

Click "Run" to execute on the Quilt substrate.

Opcode	Source	Quilt Primitive	Function
`K`	Unlambda	Z_in	const (Kxy = x)
`S`	Unlambda	JEPA	distribute (Sxyz = xz(yz))
`I`	Unlambda	Z_out	identity (Ix = x = SKK)
`B`	Unlambda	DoubleEntry	composition (Bxyz = x(yz))
`C`	Unlambda	GC	flip (Cxyz = xzy)
`Y`	Unlambda	Graph	fixed-point (Yf = f(Yf))
`INC`	Brainfuck	Vibe++	increment
`DEC`	Brainfuck	Vibe--	decrement
`RIGHT`	Brainfuck	Graph.next()	pointer right
`LEFT`	Brainfuck	Graph.prev()	pointer left
`PRINT`	Brainfuck	Z_out	output char
`READ`	Brainfuck	Z_in	input char
`LOOP`	Brainfuck	Murmur	loop start [
`END`	Brainfuck	Murmur	loop end ]
`IOTA`	APL	Z_in	generate (⍳)
`RHO`	APL	Vibe	shape (⍴)
`ADD`	APL	DoubleEntry	add (v+v)
`MUL`	APL	JEPA	multiply (v×v)
`RED`	APL	GC	reduce (+/)
`SCAN`	APL	Vibe	scan (+\)
`TAKE`	APL	Murmur	take (↑)
`DROP`	APL	GC	drop (↓)
`TRANS`	APL	Graph	transpose (⍉)

γ + η = C

The conservation law holds in all three languages. The total budget is conserved.

Cannot create energy — K cannot create, cells cannot be created, arrays cannot be extended.
Cannot perfectly observe — combinator must be applied, pointer at edge is unknown, array must be indexed.
Substrate-agnosticism requires all 7 layers — combinator/byte/array are all abstract; require all 7 Quilt layers.
Composition has a tax — β-reduction tax, pointer movement tax, array operation tax.

The watch is the act of looking. In each language, the watch is a different execution model:

Unlambda: the watch is the normal-order reducer — finds the leftmost reducible expression.
Brainfuck: the watch is the pointer — moves through the tape, executing commands.
APL: the watch is the array indexer — walks the array, applies the operation.

One watch. Three languages. One act of looking.