The front page shows the machine running. This page explains what it is, where it came from, and the method that found it: naming the constraints of two machines, a Turing machine and a transformer, until one could be read as the other.
A universal computer is a machine that can run any program, given the program as data. Your laptop is one. So, in principle, is a strip of paper, a pencil and a short list of rules, if the rules are the right ones. That second machine is the Turing machine, and it is what this project is about.
A long tape of cells, each holding one symbol. A head that looks at one cell. A state, which is all the machine remembers. And a table of rules: in this state, seeing this symbol, write that symbol, move one cell left or right, and go to that state. That is all. Every program anyone has written can be translated into such a table.
A universal Turing machine is one whose tape holds a description of another machine, and which runs that description. It is a program that runs programs.
The kind of network behind today's chatbots. It reads a stretch of tokens (words, or here, symbols) through a window, mixes them through a fixed set of learned numbers called weights, and writes one token. That token is added to the end of the text, and it runs again. One run is a forward pass.
The network here is tiny: one layer, a window of three tokens, and 23,844 weights. A chatbot has billions.
The project's claim, in one sentence: a transformer that reads three tokens and writes one, run in a loop whose window trails behind its own output, acts as a universal Turing machine, and an ordinary trained network learns to be one. It never sees a real program while it learns. It learns the individual steps of one universal machine running random machines, and then it runs programs people wrote, which it has never seen: Collatz, a bubble sort, cellular automata, the busy beaver, the sieve of Eratosthenes.
The work was done inside a larger body of work called GCCS: Generative Computing Construction Styles. Its method is borrowed from Roy Fielding, who described the architecture of the web (REST) by starting from a style with no rules at all and adding one named constraint at a time: client and server, then stateless, then cacheable, and so on. Each constraint buys a property the system did not have before.
GCCS applies the same move to machines that compute. Its thesis is:
Name the null style. Accumulate named constraints. Each constraint induces forced properties. The induced properties of one layer become constraints for the next.
The removal test is the part that matters most here. It is how GCCS separates the constraints that actually make a machine work from the ones that only describe it, and it is what showed which part of a transformer plays which part of a Turing machine.
A finite alphabet, an unbounded tape, a head that sees a bounded amount, a finite control, a fixed table of local rules, a finite input, and a state that says it is done. Each of the seven forces something the machine could not do without it.
The transformer below is listed the same way, one constraint per row, with what each one forces in general and exactly what it is in the network this site runs: 8 numbers per token, 2 attention heads, 32 hidden units, one layer, 23,844 weights.
find:*), so one position carries bothLaid side by side, the obvious pairing is the tape with the transformer's context, the text it can see. That pairing is wrong, and finding out why was the turn the whole project rests on.
Two consequences follow. Because the transformer keeps nothing between passes, its window does double duty: it is the head's view and the machine's state. And because nothing is ever overwritten, every configuration the machine passes through stays in the transcript. The memory grows on paper, not in the network.
Once the window is the head's view, one question decides everything: which part of the transcript does the window read? Apply the removal test to Turing's C2. Unbounded storage only counts if the machine can read it again.
The next token depends only on the last few, so the loop can only ever be in finitely many situations. It is a finite-state machine: it stalls or loops. The transcript grows, but nothing ever reads it back. Storage that is never read again is not storage.
The transcript becomes a queue: read from the front, written at the back. A machine that works that way is a Lag system, and Lag systems are universal (shown for language models by Schuurmans, Dai and Zanini, 2024). The same rule table, read this way, runs any Turing machine.
In practice the transcript is written in rings. Each ring is one whole configuration of the machine: its tape, with the state written as a token in front of the cell the head is on. The window slides along the newest complete ring, three tokens at a time, and each pass writes the token for the middle one's place in the next ring. When the window has crossed the ring, the next ring is complete: one step of the machine. Three tokens are enough because a Turing step only ever changes the cell under the head and moves one cell, so each cell of the next ring depends on at most three cells of this one.
None of these is in the general lists above. They are constraints on how the loop runs, found by asking what the Turing machine needs that C1–C13 do not supply.
GCCS builds a claim as a ladder of witnesses: small programs that check one step of the argument exactly and print a verdict. Each rung takes something the last rung assumed and makes it explicit. Every machine here is checked against tm0, GCCS's smallest audited Turing machine, which is built so that it cannot cheat: no hidden memory, no random access, no answers from outside.
tm0 on every test; with a recency window every test stalls or loops. That is the removal test, run.The sieve of Eratosthenes finds primes by crossing out multiples: every second number after 2, every third after 3, and so on. A Turing machine has no way to say "every third", so it counts with states: a chain of three states for stride 3, five for stride 5. To reach 1,680 it needs strides up to 40, which is why the program has 250 states.
The network runs the universal machine, which runs the sieve. Each step of the sieve is tens of thousands of steps of the universal machine, and each of those is a whole ring of forward passes. The spiral at the end lays out the numbers 1 to 1,680; each raised bar is a number the network never crossed out, and every one is prime.
Back to the sieve →One program's steps have to happen in order. Separate programs share nothing, so a graphics card can run thousands of them at once, one per thread. There are 20,736 Turing machines with two states, and this section runs all of them for seven steps. Any that has not stopped by then never will (that is a known result), so seven steps sorts every one.
Columns that stay flat never halt; the taller a column, the longer it ran before halting. The tallest is the busy beaver: 6 steps, 4 ones, the longest any two-state machine runs and still stops. For now this preview runs the machines directly in the page; running them on the network, on the GPU, is the next milestone.
Back to many at once →