Welcome, weary traveller from the orange site! Let me tell you the tale of roons — a kit for building mechanical computers.

I got inspired a couple of years ago when I binged a bunch of mechanical logic gate YouTube videos. There are some unbelievably clever implementations — Steve Mould’s water computer was a particular inspiration.

Still, these mechanical logic gates usually end up too big to make any practical devices. I figured, how hard can it be to miniaturise them into a usable kit?

loom automaton

The Analytical Engine weaves algebraic patterns just as the Jacquard loom weaves flowers and leaves.

Ada Lovelace

After noodling around with far too many prototypes, I settled on what I call a loom automaton. We place tiles (“roons”) on a loom of alternating bars that move up and down. The contours on these tiles guide marbles and holes in discretised steps, representing bitstreams.

Isn’t it incredibly neat that a literal physical loom turns out to be a great substrate for Lovelace’s metaphorical loom?

Anyway — you can think of this loom as a cellular automaton, where each cell is:

If you know of prior work on this kind of system, please get in touch! I don’t claim the loom automaton is original; I just haven’t seen it elsewhere.

why loom good

Initially, I was making ad-hoc devices for each computer component — a gadget for number comparison, which worked like this; and a gadget for addition, which worked like that; etc.

The loom was a turning point. Instead of a loose collection of dissimilar gadgets that plug in together, everything is implemented on the loom. (Except peripherals, which we’ll get to later.) This gives us a common interface for stitching together whatever devices we need — memory, instruction sets, whatever. It makes it trivial to deliver power in synchronised discrete steps to every component.

I tried several variations on the loom: moving the marbles using alternating pins; continuously guiding the marbles using slides rippling in a wave; replacing gravity with magnetic potentials; etc. You can read more about these failed attempts in the hardware/prototypes deep dive.

Turing completeness

You can skip this section if it’s obvious that discretised marble movements are Turing complete, but then you’d miss out on the beautiful interactive simulator:

I learned JavaScript for this.

When the xor roon above receives its inputs, a single ( or ) can fall into the central channel, while will block each other. So an xor implements XOR.

Other roons implement other logic gates. The canute performs a check then kicks an back one step, which lets us implement carry-like functions on a marble bitstream. There are also roons like the trap that can permanently store a piece of state.

Though actually, you don’t need any stateful roons to store state — you can just cycle a stream of round in a loop, bam, you’ve got a register:

We read from this register using a switch to divert the path of an infinite stream of . Meanwhile, the register is constantly reading in from one of two data sources: itself, or an input stream, depending on a 3rd signal channel. While this channel is , the data loops; when it’s , it gets overwritten by the external input, letting us perform a write.

But I’m getting off track. Trivially, XOR gates are Turing complete; my job is done, that’s a computer, we can all go home. Thank you.

convenience

“But wait! Being Turing complete isn’t enough to not suck!”

That’s a good point. To actually make a good mechanical computer kit, we need a few other things:

• Compactness — build interesting devices in a small area, with very few pieces — no warehouse-sized processors!
• Promptness — reasonable processing rate; don’t have to wait for BB 10 steps before a computation finishes
• Fast editing — minimal friction to changing a pattern and running it. “Hot reloading” so a pattern can be edited while running.
• Saving and loading — can save your work to compact storage, then bring it back later
• Minimal — build many complex systems from a small number of core parts

Basically I wanted a kit that’s actually practical and fun for building circuits.

did you make one?

… yes!

Here’s a binary adder made of a long turn , canute , and distributor — which together are not much bigger than a postage stamp. (Wave your hands and amortise away the space occupied by the disk drive itself, I/O plumbing etc etc)

Because space is at such a premium, instead of staggering multiple XORs and ANDs, we just bundle it all into a single unit — it’s small but slow.

We can also do memory, latches, processors, counters, timers, counters etc. Follow the tutorial sequence to learn more.

modularity

I wanted it to be easy to store and run lots of different patterns. Each disk drive is reasonably pocket-sized, but there’s still a lot of space dedicated to the internal gear mechanism.

So here’s the removable disk system:

This is pretty simple, but it took a long time to get right! Challenges included:

• Figuring out exactly how much of the mechanism I could shunt down into the disk drive, and how much I had to retain in the disk
• Optimising magnet strengths and positions — need the save/load to work smoothly, while preventing the base from popping back up in operation

We can also move individual bars between disks, or rearrange the order within a disk. This makes it easy to adjust a pattern if we started it in the wrong place.

extendability

If we need a bigger workspace, we just put drives next to each other. This works along both X and Y axes, so you can build 2D grids.

binding

Each face of the drive has a pair of north-south magnets at its ends. This lets it pair up with a 180-degree-rotated copy of itself.

The centre of each face also has a small raised nub next to a corresponding pocket. This locks the drive into a precise position.

power

We also need to transfer power through the system. Originally I used horizontal axles with hidden magnetic couplers, which looked very cool but had too many design issues.

Instead, each drive has a 2 x 2 gear grid, where each gear has an integrated barrel cam to move the bars up and down. When two drives are placed next to each other, the gears bind together.

Because N is even in our N x N gear grid, the drives all spin the same way. This mat