Loop 2.1 — Getting Started

The Architecture

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.

What You Will Build

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.

Step 1 — Open the simulator and get oriented

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.

1. 1
   Press START in the control bar. The machine starts running. You will see the clock LED flash and the tick counter increment. The loops are empty — the canvas shows no lit bits.

Step 2 — Inject your first value

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.

1. 1
   Find the Inject panel (top of the right sidebar, or inline below the Working loop). Set the value to 1000 using the sixteen toggle switches — each switch is one bit of the 16-bit value. 1000 decimal = 0x03E8 = 0000001111101000 in binary, so switches 9, 8, 7, 6, 5, and 3 should be up.

   1000 decimal = 0x03E8 = 0000001111101000 in 16-bit binary
2. 2
   Press INJECT. A 17-bit word (marker + 16 data bits) enters the inject channel and shifts into the Working loop's write head over 17 ticks. Watch the canvas — you will see the lit bits appear and start circulating.
3. 3
   Wait for the word to clear the inject channel (17 ticks at your clock rate). Then set the switches to 2000 (0x07D0 = 0000011111010000) and inject again.

   You need a gap between words — at least one empty marker-position between them — or the second word's marker will collide with the first word's tail bits. Waiting for the inject LED to go dark is enough.

Step 3 — Configure Bus A and route to ALU

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.

1. 1
   Open the Bus A panel in the right sidebar. Set Source to Working and Destination to ALU.
2. 2
   Press TURN BUS A ON. The bus activates. Nothing moves yet — the gate is closed.
3. 3
   Watch the Working loop canvas. You'll see your two words circulating. When the first word is approaching the gate position (G dot), press OPEN GATE on the Working loop (or use the gate button in the Bus A panel). The marker bit exits through the gate onto the bus, followed by the 16 data bits. The word is consumed from the Working loop and travels across Bus A to the ALU loop's write head.

   One OPEN GATE action passes exactly one word — the gate closes automatically after the word exits. Repeat for the second word.
4. 4
   Open the gate once more to pass the second word (2000). Both values are now in the ALU loop.

Step 4 — Capture into ALU registers

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.

1. 1
   Open the ALU panel. Set the capture route to A.
2. 2
   Watch the ALU loop. When your first word (1000) passes the R dot, it is captured into Register A. The register display updates immediately. The word is still circulating in the loop — capture is non-destructive by default.
3. 3
   Set the route to B. The next word (2000) that passes is captured into Register B.

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.

Step 5 — Write the result back to the loop

The result exists in the ALU's result register but not in any loop. To use it in further computation, route it back.

1. 1
   Press SEND TO LOOP in the ALU panel. This starts a 17-tick writeback — the result word is shifted bit by bit into the ALU loop's write head. The result (3000) is now circulating in the ALU loop.
2. 2
   Set the capture route to C and let the result word pass the R dot. Register C now holds 3000 — your verified answer.

What to Try Next

Now that the basic data path is clear, here are things worth exploring:

• Auto-writeback. Toggle AUTO-SEND: ON in the ALU. Now the result writes back to the loop automatically every time it changes. Load values, set op to INC, watch the ALU loop count upward continuously.
• Memory slots. Enable Write to Slots and Auto-Increment on the Memory panel, then route values from the Working loop through Bus B to the Memory loop. Watch them land in consecutive slots.
• The Pattern Matcher. Configure PM1 on the Big Loop to match a specific bit pattern. Route a stream of values through and watch it eject matches while letting non-matches continue circulating.
• Challenges. Open the Challenges panel and try Add Two Numbers — the machine sends values to you via Bus E and you route them through the ALU and send the answer back.

A Different Kind of Computer

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.

The Basic Idea: Data Goes Around in Circles

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.

Moving Data Between Loops: Buses

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 Calculator: The ALU

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.

What You'll Do

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.

Step 1 — Open the simulator and start the clock

1. 1
   Open the Loop 2.1 simulator in your browser. You'll see a panel of loops drawn as canvases — circular tracks. The right side has all the controls. It looks complicated. Ignore most of it for now.
2. 2
   Find the control bar at the top. Press START. The machine starts running. A tick counter begins incrementing — each tick is one step of the clock. At 1 Hz (the default), there's one tick per second.

   The loops are empty, so nothing interesting happens yet. That's fine. The machine is ready.
3. 3
   Optionally: find the clock speed slider and bump it to around 8. Things will move a little faster and feel more alive. You can always slow it back down.

Step 2 — Put numbers into the Working loop

The inject channel is how you get a number into the machine from the outside. Think of it as the input slot.

1. 1
   Find the Inject panel (it's near the top of the right sidebar, or there's a small one inline below the Working loop). Set the value to 1000 using the sixteen toggle switches — flip them to match the binary pattern for 1000 (0000001111101000). The switches represent the 16 data bits of the word, from bit 15 (left) to bit 0 (right).
2. 2
   Press INJECT. Watch the Working loop canvas. You'll see a cluster of lit bits appear and start moving clockwise around the loop. That cluster is your number — 1000 — circulating.

   Why lit bits? Numbers in Loop 2.1 are stored in binary — a series of 0s and 1s. Lit bits are 1s, dark bits are 0s. The pattern of lights is the number 1000 written in binary. You don't need to read binary — the number display shows the decimal value.
3. 3
   Wait a moment for the injection to finish (the INJECT LED in the control bar will go dark). Then set the switches to 2000 (0000011111010000) and press INJECT again. Now two clusters of bits are circulating in the Working loop — 1000 and 2000, going around and around.

Step 3 — Move the numbers to the ALU loop

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.

1. 1
   Open the Bus A section in the right sidebar. Set the Source to Working — Bus A will read from the Working loop. Set the Destination to ALU — it will write into the ALU loop.
2. 2
   Press TURN BUS A ON. The bus is ready, but data hasn't moved yet — you still control the gate.
3. 3
   Watch the Working loop. There's an exit point — the Gate — where numbers can leave the loop onto the bus. When your first number (1000) is near the gate, press OPEN GATE.

   The gate opens and closes automatically after one number passes. You'll see the lit bits shift from the Working loop across the Bus A channel into the ALU loop. It takes a moment at the clock rate you've set.
4. 4
   Wait for 1000 to finish crossing the bus. Then open the gate again when 2000 approaches. It crosses too. Both numbers are now in the ALU loop.

Step 4 — Capture the numbers into the calculator

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.

1. 1
   Open the ALU section in the sidebar. Find the register route selector — buttons labeled A, B, C, D. Press A to set the next capture destination to Register A.
2. 2
   Watch the ALU loop. The moment your first number (1000) passes the read point, it's captured into Register A. The ALU panel will show A: 1000.

   The number is still in the loop too — capture doesn't remove it. You're reading a copy, like scanning a barcode.
3. 3
   Press B to set the next capture to Register B. When 2000 passes, it's captured into B. The ALU panel shows B: 2000.

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.

Step 5 — Send the answer back into the loop

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.

1. 1
   In the ALU panel, press SEND TO LOOP. Watch the ALU loop — a new cluster of lit bits appears and starts circulating. That's 3000, now living in the loop alongside the 1000 and 2000 you put there earlier.
2. 2
   To confirm: press C in the register selector, and let the 3000 word pass the read point. Register C will show 3000. You've verified the answer is what you expect.

What Makes This Interesting

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.

What to Try Next

• Different operations. Change the ALU operation to SUB, SHL (shift left — doubles the value), XOR, or NOT. Watch what happens to the result display as you swap operations while registers are loaded.
• The auto-send counter. As described above — INC + AUTO-SEND is one of the most satisfying things in the machine.
• Memory slots. Find the Memory Slots panel. Enable Write to Slots and route values from Working into the Memory loop via Bus B. Watch them get stored in slot 0, 1, 2... in sequence.
• Challenges. The Challenges panel gives you structured problems to solve — the machine sends you numbers via Bus E and asks you to send back an answer. Add Two Numbers is the natural first one.