A pocket calculator

Four operations on two bits, selected by two control bits. This is what a CPU does. Build a tiny 1-bit ALU — the capstone of the curriculum.

What you'll learn

• What an ALU (arithmetic-logic unit) is and why every CPU has one.
• How to use a MUX tree to pick between precomputed operation results.
• The discipline of building a working mini-CPU component from primitives you already understand.

The idea

A 1-bit ALU takes two data bits (Input A, Input B) and two selector bits (Op Low, Op High), and emits one result bit. The selector picks which operation to run:

Op High	Op Low	Operation
0	0	AND (A ∧ B)
0	1	OR (A ∨ B)
1	0	XOR (A ⊕ B)
1	1	NOT A (B ignored)

A real CPU's ALU is just this shape writ wider: 8, 16, 32, or 64 bits instead of 1, and usually with addition and subtraction thrown in. But the structure is the same — compute everything in parallel, then MUX the one you want to the output.

The plan

1. Compute all four results in parallel:
   • and_result = A ∧ B
   • or_result = A ∨ B
   • xor_result = A ⊕ B
   • not_result = ¬A
2. Build a 4-to-1 multiplexer driven by (Op High, Op Low) that picks one of those four results.

A 4-to-1 MUX is a tree of three 2-to-1 MUXes:

 and_result ─┐
             ├── 2:1 MUX (Op Low) ─┐
 or_result  ─┘                    ├── 2:1 MUX (Op High) ── Output
                                  │
 xor_result ─┐                    │
             ├── 2:1 MUX (Op Low) ─┘
 not_result ─┘

When Op High = 0, the final MUX picks from {AND, OR} (chosen by Op Low). When Op High = 1, it picks from {XOR, NOT}.

The challenge

Place four Levers labeled Input A, Input B, Op Low, and Op High. Compute the four operation results, build the MUX tree from lesson 7, and send the final output to a Lamp labeled Output. Flip through combinations of op bits to see the ALU switch personalities.

If you haven't built a half or full adder yet, this one is doable but large — give yourself room on the canvas, and use the redstone patterns at /redstone if you want a gate-by-gate reference.

Where you go from here

You've finished the combinational half of the curriculum — every gate, every adder, every multiplexer, every operation that's a pure function of its inputs.

The next three lessons cross the divide into sequential logic — circuits that remember:

• Lesson 9: Memory introduces the SR latch, the simplest one-bit store.
• Lesson 10: Clocked memory turns memory into the disciplined D flip-flop every CPU register is built from.
• Lesson 11: Counting clock pulses uses a T flip-flop to count.

Combine the ALU you just built with the registers you'll build next and you have, in miniature, a CPU. Everything else is composition.