Zuse Z3

Embedding

The Zuse Z3 here is authored from scratch in one small file, z3.js. It is a plain global — ZUSE.create(canvas) returns a machine object whose whole state is ordinary JavaScript, so the debugger reaches straight into it with no wasm heap or hidden loop.

Boot. Create the machine on a <canvas>, load a program (a punched-film byte array plus optional memory constants and queued keyboard input), then run your own loop built on z3.step() (execute exactly one film instruction):

var z3 = ZUSE.create(canvas);
z3.load({ film: [0xC1, 0xC1, 0x48, 0x83, 0xC2, 0xC2, 0x48, 0xC3, 0x60, 0x58, 0x78],
          mem: { 1: 3, 2: 4 } });
(function loop(){
  var r = z3.step();               // 'ok' | 'stop' | 'wait'
  z3.render();
  if (r === 'ok') requestAnimationFrame(loop);
})();

The machine is plain fields. Everything the debugger needs is live on the object:

Because R1, R2, the film position and the store are ordinary JavaScript, breakpoints are a host-side Set of film positions checked before each step(), and watchpoints are checked inside onWrite — no changes to the core.

Debugger integration

The Z3 has no bytes-and-addresses CPU, so its debugger view is built from two very different memory spaces plus a custom decoder:

• A new z3 decoder (/debugger/src/cpus/z3.js) disassembles the 8-bit film instruction. The top two bits pick the class (Pr z load, Ps z store, or an 01 sss 000 operation), the middle three bits pick the operation (Lm Li Lw Ls1 Ls2 Lu Ld), and anything else prints as .op. It reads the plain film byte the shared disassembly view hands it — no live-peek trick needed.
• Two chips. The punched film is decoded with z3 in the disassembly view; the relay memory is 64 words shown as 22-bit codes (hex and bits). Both reads are side-effect-free.
• Registers. R1 and R2 are surfaced as their live 22-bit floating-point words (via encode), writable back through decode; the film position is the program counter; STOP, WAIT and SEL2 (which register the next load targets) are flags.
• Transport. The boot loop implements pause / resume / one-instruction step, execution breakpoints on the film position, and write watchpoints wrapped around onWrite — all on EMU_BOOT.transport.

Because the Z3 has no keyboard-mapped CPU input, the operator keyboard is modelled directly: the on-screen keypad and the physical number keys drive keyDigit/keySubmit, which queue a decimal value that the next Lu instruction consumes; a Lu with an empty queue returns 'wait' and the loop parks until you press START.

Architecture

The Zuse Z3, completed by Konrad Zuse in Berlin and first demonstrated on 12 May 1941, was the world's first programmable, fully automatic digital computer. It was built from about 2,600 telephone relays and it computed in binary floating point — decades before that became standard.

• 22-bit word = 1 sign bit + a 7-bit exponent (two's complement, −64..63) + a 14-bit mantissa (a normalised fraction with an implicit leading 1).
• 64 words of relay memory (the store), addressed 0–63.
• Two arithmetic registers, R1 and R2. A load drops its value into R1 then R2 alternately; a two-operand operation computes into R1 and re-arms the loader on R2 so results accumulate; square root is one-operand on R1.
• Program on punched film — a stream of 8-bit instructions, with no conditional branch; the film was physically a loop for repeated computation.
• Decimal I/O — a keyboard for input and a lamp field for the decimal result.

The 8-bit instruction (after Raul Rojas's reconstruction) decodes from its top two bits:

The shared debugger's z3 decoder turns each film byte back into these mnemonics in the disassembly view, so you can watch the fetch-execute cycle one instruction at a time as the lamps light.