Loop 2.1 is a computer that works differently from every other computer you have used. In every other computer — your laptop, your phone, every server running every website — there is a stored program that runs automatically. The machine fetches instructions, decodes them, executes them, moves to the next one. You write the program and walk away. The computer does the rest.
Loop 2.1 has no stored program. There is no instruction to fetch. There is no next step waiting to execute. Data circulates continuously in loops, and you — the operator — are the program. Every routing decision, every calculation, every movement of data from one part of the machine to another is a deliberate choice you make in real time.
This is not a limitation. It is the point. You cannot not understand what is happening, because you are making it happen.
"At 24 Hz, the machine tips from 'you can watch individual ticks' to 'motion becomes continuous.' That boundary belongs in this system."
By the end of this guide you will have loaded numbers into the machine, moved them through a bus, performed addition in the ALU, and gotten the result back. That is a real computation on a real computer. It just happened to require your hands at every step.
If that doesn't sound like you, try Guide B instead. No judgment — it covers the same ground.
Loop 2.1 is a dataflow machine with no instruction memory. Data is stored as 17-bit words — one marker bit followed by 16 data bits — circulating in one of four shift-register loops: Working (18 words), ALU (24 words), Memory (24 words), and Big (48 words). The marker bit distinguishes a data word from empty space; the 16 data bits carry the unsigned integer value (0–65535).
Words rotate at the clock rate — 24 Hz by default. There is a read head (R dot), a gate head (G dot), and a write head (W dot) at fixed positions on each loop. The bus samples the R dot, the gate controls whether a word exits, and the write head is where bus-delivered bits enter the loop.
A bus moves bits from the R dot of a source loop to the W dot of a destination loop. Buses A through D are the four general-purpose intra-machine buses. Bus E is the external interface — used for challenge I/O. F and G are P2P connections to neighboring machines.
The ALU is not pipelined and has no clock. It recomputes instantaneously whenever any input register changes. It has four 16-bit registers (A, B, C, D) and eleven operations: ADD, SUB, AND, OR, XOR, NOT, SHL, SHR, NEG, INC, DEC. Five flags (Zero, Carry, Overflow, Sign, Parity) are updated on every operation. The ALU result can be written back to the ALU loop via a 17-tick writeback pipeline — manually, or automatically on result change.
Memory provides 16 addressable 16-bit slots. Each slot can be written from the Memory loop's read head (Write to Slots mode) or read back out via individual slot writeback or Batch Write All.
You are going to add two numbers. Specifically: inject 1000 and 2000 into the Working loop, route them to the ALU loop via Bus A, capture them into registers A and B, compute ADD, and write the result back to the ALU loop. The result should be 3000 (0x0BB8).
This requires: inject channel, Bus A source/destination routing, the gate, ALU register capture, and ALU writeback. It exercises most of the core data path in one short session.
Open the Loop 2.1 simulator HTML file in any modern browser. You'll see a canvas with four loop tracks. The right sidebar contains all controls. The control bar at the top has CLOCK, RUNNING, BUS, INJECT, and P2P LEDs.
The inject channel loads data directly into the Working loop's write head. It's the primary way to get data into the machine from outside.
0x03E8 = 0000001111101000 in binary, so switches 9, 8, 7, 6, 5, and 3 should be up.
0x07D0 = 0000011111010000) and inject again.
Bus A is a 24-bit shift register that bridges source and destination loops. You need to configure its source, destination, and then open the gate to let words exit the Working loop onto the bus.
The ALU captures words from the ALU loop's read head into registers on demand. You set a route (which register to capture into next) and the next complete word that passes the R dot goes there.
The ALU computed the result the moment Reg B was populated. No clock cycle, no pipeline stage — it's purely combinational from the register values.
The result exists in the ALU's result register but not in any loop. To use it in further computation, route it back.
Now that the basic data path is clear, here are things worth exploring:
If you already know what registers and buses are, Guide A will move faster for you.
Every computer you've used in your life — phone, laptop, game console — works the same basic way. Someone wrote a program. The program tells the computer what to do, step by step, automatically. You click a button and a thousand instructions execute before you've moved your finger. The computer is fast, the program is hidden, and you are the user.
Loop 2.1 works differently. There is no program. There are no hidden instructions. There is just you, and data moving through loops, and a set of tools you can use to do things to that data.
You are the program. Every step, every decision, every movement of data — that's you.
This sounds slow and tedious. It is, a little. It is also the clearest possible view of what a computer actually does. Most computers hide everything from you in the name of speed and convenience. Loop 2.1 hides nothing.
Imagine a conveyor belt in a circle — like the kind at a sushi restaurant, where the food goes around and you take what you want. Loop 2.1 has four of these conveyor belts, called loops. Data circulates on them continuously, going around and around at whatever speed you set the clock to.
Data on the loop is stored as numbers — any whole number from 0 to 65,535. When you put a number on a loop, it circulates forever (or until you take it off). It doesn't go anywhere on its own. It just... goes around.
The four loops are: Working (your main workspace), ALU (for calculation), Memory (for storing values), and Big (a larger loop for bigger jobs). For this guide, you'll only use Working and ALU.
A bus is a bridge between loops. You point it at a source loop and a destination loop, open it, and data flows across. Think of it as a short conveyor belt that connects two of the circular ones.
You control which data crosses. The bus doesn't decide — you do. When a number reaches the exit point of the source loop, you can let it through (by opening the gate) or let it keep circulating. One press of the gate lets exactly one number cross.
The ALU (you can just call it the calculator) is where arithmetic happens. It has four slots — Registers A, B, C, and D — where you can hold numbers. You put a number in A, a number in B, tell it to add them, and it instantly shows you the result.
The ALU doesn't reach out and grab numbers. You route data to it through a bus. The numbers arrive from the ALU loop, pass the read point, and get captured into whichever register you've selected. The whole thing is deliberate and visible.
You are going to add two numbers: 1000 and 2000. The answer is 3000. You already know that — but the machine doesn't. You're going to show it, by hand, step by step.
Here's the plan: put both numbers into the Working loop, move them across a bus to the ALU loop, capture them into the calculator's registers, add them, and send the result back to the loop. By the end, the number 3000 will be circulating in the ALU loop, and you'll have watched every bit of it happen.
The inject channel is how you get a number into the machine from the outside. Think of it as the input slot.
0000001111101000). The switches represent the 16 data bits of the word, from bit 15 (left) to bit 0 (right).
0000011111010000) and press INJECT again. Now two clusters of bits are circulating in the Working loop — 1000 and 2000, going around and around.
The numbers are in Working, but the calculator (ALU) only knows about things in the ALU loop. You need to move them. Bus A is the bridge.
The numbers are circulating in the ALU loop, but the calculator doesn't have them yet — it needs to grab them as they pass the read point.
The calculator showed 3000 the instant Register B was filled. It didn't need you to press Calculate or Execute. It just does the math, always, as soon as it has both inputs. That's what "combinational" means — it combines the inputs instantly, without waiting for a clock tick.
The result (3000) exists in the calculator but isn't in any loop yet. To do anything with it — store it, route it somewhere, use it in a further calculation — you need to put it back in the loop.
You might be thinking: that was a lot of steps to do addition. And you're right — it was. A normal calculator does that in a fraction of a millisecond with no effort from you. So why bother?
Because now you know exactly how it happened. Most computers hide the routing, the transfer, the capture, the writeback — all of it happens automatically at billions of steps per second. You get the answer but you don't get the understanding. In Loop 2.1, you can't get the answer without the understanding. They're the same thing.
And once the understanding is there, the machine becomes surprisingly expressive. Try this: set the ALU operation to INC (increment by 1) and turn on AUTO-SEND: ON. Now every time the result changes, it automatically goes back to the loop — which means it gets captured again, which changes the result, which goes back to the loop. You've just created a counter that runs by itself at the clock rate. From "how does addition work" to "I made a machine that counts" in two steps.