> Give the ant a memory of one bit, an internal state, and its next move depends on where it is AND what it is thinking. That single change turns a doodling bug into a tiny programmable machine.
01 · the program
One row per state, one column per colour under the head. Each cell is an instruction: which colour to write, which way to turn, and which state to switch to. Click any field to change it. With one state you have a plain ant; add a second and identical squares can send it two different ways.
02 · run it
The camera follows the head across an unbounded plane. Its colour is its current state (S0). Run to turbo or press +5,000 and wait for it to settle, escape, or spread. When the move stream starts repeating, the badge reads its period.
03 · the menagerie
Load one and watch its fate. Every description below was measured by running this exact engine offline, then re-checked live, not asserted:
04 · every possible ant
Two states, two colours: 65,536 distinct turmites in all. We ran every one, from 2,000 to 18,000 steps, and sorted them by what their footprint does. Three fates cover almost everything:
- 58.5%settle into a bounded pattern (38,345 rules)
- 32.0%escape to infinity down a straight highway (20,945 rules)
- 7.4%spread out to fill a whole region (4,844 rules)
- 2.1%do something in between (1,402 rules)
A rule that reads a symbol, writes one, moves, and changes state is exactly a Turing machine, on a plane instead of a strip. Whether any given one settles, escapes, or spreads is undecidable in general: no shortcut beats running the ant and watching. Emergence and undecidability are the same fact from two sides.
An ant with nothing on its mind
An earlier drop let a single ant loose on a blank grid with one dumb habit: on a white square, turn right, paint it black, step forward; on a black square, turn left, paint it white, step forward. That is the whole rule. For about ten thousand steps it scribbles an incoherent mess, and then, with no warning and no reason you can see coming, it locks into a highway, a repeating gait that lays the same 52-tile stripe over and over and drives off the edge of the world forever.
It is one of the cleanest examples of emergence there is. But the ant is also a little insulting to itself. Its entire mind is the square it happens to be standing on. It has no memory. Ask it "what were you doing a moment ago?" and it cannot answer, because it was built with nowhere to keep the answer.
So let us give it somewhere.
One bit of memory
Add to the ant an internal state, a tiny register it carries with it. Now its next move is not a function of the square alone. It is a function of the square and the state:
read the colour under me → look up (my state, that colour) in a table → write a new colour, turn, and switch to a new state → step forward.
With one state, there is nothing to remember and you are back to the old ant exactly: its table has one row. Give it a second state and the table doubles to two rows, and the ant can now do something it could never do before, behave differently on identical squares depending on what it was thinking. The same black tile can send it left one moment and right the next.
This object has a name. It is a turmite (Turing + termite), and it is not a metaphor for a computer. A rule that reads a symbol, writes a symbol, moves, and changes state is the transition table of a Turing machine, the 1936 definition of computation itself. The only difference from the machine in the textbooks is that this one's tape is a two-dimensional plane instead of a one-dimensional strip. Every turmite is a program. The grid is its scratch paper.
Edit the table in the panel above and watch what your program does.
Three ways for a program to end up
Here is the honest, humbling part. Almost none of these programs compute anything you would call useful. Give the ant two states and two colours and there are exactly
2 colours to write × 4 turns × 2 next-states = 16 choices per cell, and 2 states × 2 colours = 4 cells, so 16⁴ = 65,536 possible turmites.
We ran every single one of them, from 2,000 steps out to 18,000, and sorted them by what their footprint does as the clock runs. Three fates cover almost all of them:
- It settles down. 58.5% of all rules paint a bounded blot and then either freeze or cycle in place forever. The program halts, in spirit. Most programs do nothing.
- It escapes down a highway. 32.0% eventually find a repeating gait and drive off in a straight line, exactly like the original ant, laying an endless road. The two-state ants reach their highways at wildly different times, some by step 39, some only after hundreds of steps of scribbling, and there is no way to read the onset off the rule. You have to run it.
- It spreads out. A rare 7.4% never escape and never settle: they fill a growing region of the plane, the painted area climbing with the step count while the radius climbs with its square root. These are the mandala-makers.
A leftover 2.1% do something genuinely in between, creeping outward in shapes that are neither road nor tiling. The menagerie above has a live specimen of each fate. None of these labels were looked up; they are what this engine measured, and your browser is re-deriving them cell by cell as the ant walks.
Why you cannot just look at the rule and know
You might hope that a four-line table is small enough to reason about. It is not. Whether a given turmite halts, escapes, or fills is, in the general case, undecidable, the same wall Turing hit in 1936. There is no shortcut that reads the table and prints the answer faster than running the ant and waiting. The Commuter's 849 steps of apparent chaos are not a warm-up the rule could skip; they are the computation. The highway is the output, and the only way to get the output is to do the work.
That is the quiet lesson under the pretty pictures. A system this simple, four rows of a table, one crawling head, is already rich enough to be a general computer, and therefore already rich enough that its own behaviour is beyond prediction. Emergence and undecidability turn out to be the same fact seen from two sides. The ant does not doodle despite being a machine. It doodles because it is one.
Origins
Langton's ant is due to Christopher Langton (1986), working on artificial life at the time. The generalisation to an internal state, the turmite or two-dimensional Turing machine, was named by Greg Turk and popularised in A. K. Dewdney's Scientific American "Computer Recreations" column and later in Rudy Rucker's writing on artificial life. The undecidability of the long-term behaviour follows from the halting problem, Alan Turing (1936). The census here, the count of all 65,536 two-state two-colour turmites and how they end, was computed for this drop with the same engine you are watching, not taken from any table.
Every rule in the menagerie and every number in the census was measured by running this exact engine offline, then re-run live in your browser. Nothing here is asserted from a book. Network egress was blocked on this run, so the origin notes cite canonical facts from certainty rather than fresh links.