← all animations

LITTLE MAN COMPUTER

Write assembly, assemble it into numeric mailboxes, and run it through the fetch-decode-execute cycle one instruction at a time.

PROGRAM Example Inputs (used by INP, space or comma separated)

Speed

Click Assemble to load the program.

ACC

INSTRUCTION

–

Output

Memory (mailboxes 0–99)

How the Little Man Computer works — step by step

What the LMC is

The Little Man Computer is a tiny model of a real CPU, designed for teaching. Imagine a single person (the “little man”) sitting in a room with 100 numbered mailboxes, a small calculator (the accumulator), a finger pointing at the next mailbox to read (the program counter), an in-tray (input), and an out-tray (output). That’s the whole machine.

The pieces (on the right of the page)

Mailboxes 0–99 — the memory. Each mailbox holds a 3-digit number (000–999). Some mailboxes hold instructions; some hold data.
ACC (Accumulator) — a single register where all arithmetic happens.
PC (Program Counter) — the address of the next mailbox to execute. The orange-bordered cell in the memory grid.
INSTRUCTION — the instruction currently being executed (decoded from the mailbox the PC just pointed at).
OUTPUT — every number sent by an OUT instruction lands here.

Instructions are just numbers

Every LMC instruction is a 3-digit number. The first digit is the opcode (what to do); the last two digits are the operand (which mailbox to use).

Example: ADD 5 becomes the number 105 — opcode 1 (ADD), operand 05. The Assemble button does this conversion: it reads your assembly text and fills the mailboxes with the right numbers.

The Fetch–Decode–Execute cycle

Every instruction goes through the same three steps. Click Step once and you'll run one full cycle:

Fetch — copy the number in mailbox[PC] into the INSTRUCTION register, then add 1 to PC so it points at the next instruction.
Decode — split the 3 digits into opcode and operand to work out what to do.
Execute — do it.
- LDA addr → ACC = mailbox[addr] (the cyan-flash on the memory grid shows which mailbox was touched).
- STA addr → mailbox[addr] = ACC.
- ADD addr → ACC = ACC + mailbox[addr].
- SUB addr → ACC = ACC − mailbox[addr].
- BRA addr → jump: PC = addr.
- BRZ addr → jump only if ACC is zero.
- BRP addr → jump only if ACC is positive (≥ 0).
- INP → take the next number from the Inputs box, put it in ACC.
- OUT → copy ACC into the OUTPUT list.
- HLT → stop.

Then the cycle repeats with the new PC. The machine keeps running until it hits a HLT.

The instruction set in one table

Mnemonic	Code	What it does
INP	901	take the next input into ACC
OUT	902	send ACC to OUTPUT
LDA xx	5xx	load mailbox[xx] into ACC
STA xx	3xx	store ACC into mailbox[xx]
ADD xx	1xx	ACC = ACC + mailbox[xx]
SUB xx	2xx	ACC = ACC − mailbox[xx]
BRA xx	6xx	unconditional jump to xx
BRZ xx	7xx	jump to xx if ACC = 0
BRP xx	8xx	jump to xx if ACC ≥ 0
HLT	000	stop
DAT n	nnn	declare a data slot (optional initial value)

Labels

Labels are nicknames you give to a mailbox address. When the assembler sees loop LDA n, it remembers “the address of that instruction is called loop” — so any later BRA loop is automatically turned into the correct mailbox number. Labels save you from having to count addresses by hand.

Three patterns of control flow

Every program — in any language — is built from three patterns. LMC shows them in their rawest form:

Sequence — instructions run top-to-bottom because PC simply increments by 1 each cycle. The Sum two numbers example uses nothing but sequence.
Selection — BRZ and BRP let the program take different paths based on what's in ACC. The Max of two example computes b − a, then BRP jumps to one branch if the result is ≥ 0 and falls through to the other branch if it's negative.
Iteration — BRA jumps backwards to repeat a block of instructions. Combined with a counter that's decremented each loop and a BRZ exit test, you get a while/for loop. The Countdown and Multiply examples are loops.

Walking through one cycle — “ADD 1” in mailbox 3

Suppose the PC is 3, mailbox[3] holds 101 (ADD 1), mailbox[1] holds 7, and ACC is 5.

Fetch: read mailbox[3] → 101. INSTRUCTION = ADD 1. PC becomes 4.
Decode: 1xx means ADD; operand is 01.
Execute: read mailbox[1] → 7. ACC = 5 + 7 = 12.

Then the cycle starts again with PC = 4. Press Step on the simulator and watch the orange PC arrow move, the ACC change, and the mailbox you read flash cyan.

How to use this page

Pick an example from the dropdown above the code editor.
Click ⚙ Assemble — the mailboxes fill with numbers.
Click ⏭ Step to advance one instruction at a time and read every change, or ▶ Run to play through and adjust the Speed slider to taste.
Change the Inputs and assemble again to see the same program behave with different data.
Edit the code yourself — the simulator will tell you about any assembly errors.