The Piet program on the cover of Cox and McLean’s *Speaking Code* is not a picture of the code – it *is* the code. As an image printed on a book jacket, it’s not in the correct format for Piet interpreters, but it still contains all the information needed to function as a Piet program. It is not hard to imagine a system that could scan Piet programs from print and run them similar to how QR codes are read.

But what if we wanted to run the code without using the machine at all? It’s been claimed on this blog that esolangs need not be confined to what we might ordinarily think of as a computer. The Turing Machine (a generalized example of a CPU) was described using the metaphor of a machine manipulating symbols on a tape. In practice, it could be a CPU working on data stored in memory, or a person scratching symbols in the sand, following the same rules for how those symbols are processed.

This post will investigate esolanging off the machine, looking at several languages that expand the idea of the compiler.

*Manqala board image by elPadawan (2013)*

Of childhood games, Manqala is one of the more numerical: a game of counting where players who can do a quick series of simple arithmetic have the advantage (see: *Mancala: Playing is Easy - Winning is Computational*). For those who played as children, it’s perhaps more familiar as a game of rote practice (my sister and I stopped playing once we had both memorized the lengthy series of moves ensuring a win to the first player). But even then, it’s a game of manipulating numbers: the count of stones in each pit.

It’s easy to see how those pits could serve as memory cells, with the number of stones in each serving as that cell’s current value. If we were to enact an esolang using this system, I would suggest sticking to a 4-bit system, as 15 stones could maybe fit in the pit of an ordinary Manqala board, and 255 stones (for 8-bit) is a lot to have to count and re-count. But of course this is already the beginning of an esolang that uses the board, called $tonePits. It’s more of an idea than a fully developed language. The language uses the game’s count-and-capture rules to manipulate numbers. Its esolangs wiki entry asks if you feel like a “paleolithic caveman programmer” as you code it. But we cavemen are not only the programmers but also the compilers, carrying out instructions by playing the game according to $tonePits’ rules. The language is still pretty undeveloped (the beginnings of an oscillator are sketched out) but it’s an interesting prompt to move a language into physical space.

A much more developed game-based esolang is the uniquely geeky Turing machine using Magic: The Gathering cards.

Alex Churchill is really into Magic: The Gathering. Here is a text generator he wrote for card descriptions. In this model, Alex is the processing head, manipulating a tape where each step is an individual card:

A series of Zombie tokens controlled by Alex represent the tape to the right of the current head: the creature one step to the right of the head is 1 toughness away from dying, the next one over is 2 toughness from dying, etc. A similar chain of Yeti tokens, also controlled by Alex, represent the tape to the left.

The operation “move one step to the left” is represented in this machine by creating a new Ally token, growing all Allies by 1, and shrinking all Zombies by one.

Alex’s implementation is not exactly a language but rather a Universal Turing Machine, a theoretical construct that can simulate other computers. It’s less friendly than a simpler language might be but allows for his Magic: The Gathering based system to mimic the workings of computational systems more broadly. It was achieved by adapting the small Universal Turing machine defined in Rogozhin’s paper.

The rest of the lengthy rule set can be read here (also here is a write-up for boingboing.net).

An even weirder example is that of the human heart working as a Turing Complete system.

Turing Completeness emerges in some very unexpected places, often unintentionally. It’s been proven that Minesweeper is Turing Complete (if implemented on an infinte board), as are MediaWiki templates. Here is a list of other accidentally Turing Complete systems.

A paper with the unlikely title “Implications of the Turing completeness of reaction-diffusion models, informed by GPGPU simulations on an XBox 360: Cardiac arrhythmias, re-entry and the Halting problem” shows that heart cells can form the equivalent of a NOR gate in how electrical signals are processed. The NOR gate is a fundamental logic gate which can be used to build other logic gates, on which a Turing Complete system can manifest. The paper’s aim seem to be to show that cardiac tissue is not deterministic (if it’s Turing Complete, it can’t be determined). I’m pretty sure the point of the paper is not to encourage the user to build an XBox 360 with cardiac tissue, which would be a neat paper.

Rather than walk through how we get from NOR gates to Turing Completeness, take a look at this great write-up with neatly summarizes the process.

***

These three examples show what is possible in working with non-traditional computational spaces and can hopefully serve as a jumping off point for esolangers who want to work off the traditional machine. Starting with the idea that a programming language is just a list of rules, an esolanger can develop or adapt programmatic rules to any sufficiently complex system.