ENIAC

Embedding

The ENIAC here is authored from scratch in one small file, eniac.js. It is a plain global — ENIAC.create(canvas) returns a machine object whose whole state (the twenty accumulators, the digit trunks and the plugboard program) is ordinary JavaScript, so the debugger reaches straight into it with no wasm heap and no hidden loop.

Boot. Create the machine on a <canvas>, load a program (a plugboard chain of program-line pulses plus the initial accumulator values), then run your own loop built on eniac.step() (fire exactly one program-line pulse):

var e = ENIAC.create(canvas);
var K = ENIAC.K;
e.load({ acc:{0:0, 1:1}, prog:[
  {k:K.XMIT,  acc:1, out:'A', tr:0}, // A01 transmits the odd number onto trunk 0
  {k:K.RECV,  acc:0, ch:0, tr:0},   // A00 receives it (square += odd)
  {k:K.CONST, val:2, tr:0}, {k:K.RECV, acc:1, ch:0, tr:0},
  {k:K.STEP,  limit:12}, {k:K.CBACK, n:5}, {k:K.HALT}
]});
(function tick(){
  var r = e.step();               // 'ok' | 'halt' — one pulse
  e.render();
  if (r !== 'halt') requestAnimationFrame(tick);
})();

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

Because the accumulators, trunks and program are ordinary JavaScript, breakpoints are a host-side Set of program lines checked before each step(), and watchpoints are checked inside onWrite — no changes to the core.

Debugger integration

The plug-in (eniac-debug.js) describes the machine to the shared debugger, and a new decoder (debugger/src/cpus/eniac.js) makes the plugboard readable. The ENIAC has no stored program and no instruction set, so this is an unusual but faithful mapping:

• The plugboard is the program. The disassembly view decodes one program-line pulse per address instead of one byte: accumulator CLR, transmit (A05 A→T1 add / S→T1 subtract), receive (A00 α←T1 on a channel), the MULT / DIV / SQRT units, the constant transmitter, and the master-programmer STEP / CBACK that close a loop. Anything unrecognised decodes to .pulse.
• Registers are the twenty accumulators (summarised as the low 32 bits of each, written back), plus the current program LINE, the cycling-unit PHASE, the master-programmer count MPCNT and the HALT flag — read live and written back each refresh. (The register inputs show the low bits; the canvas shows all ten neon decades.)
• Single step is one e.step() — the program line advances by one pulse. Breakpoints are host-side checks on the program line (click a line in the disassembly gutter); watchpoints fire inside onWrite when a watched accumulator is written.
• Like cpus/analytical.js and cpus/mix.js, the decoder cannot express a structured pulse through the byte-masked reader the view provides, so it reads the real pulse off the live core (window.EMU_BOOT.eniac.prog) and falls back to a one-byte kind code only when the core is absent.

Architecture

The ENIAC — Electronic Numerical Integrator and Computer — was built at the Moore School of Electrical Engineering, University of Pennsylvania, by John Mauchly and J. Presper Eckert, and unveiled in 1945. It was the first general-purpose, electronic, digital computer: roughly 18,000 vacuum tubes, 30 tons, and about a thousand times faster than the electromechanical machines before it. It had no stored program — it was programmed by plugging cables and setting switches, and reprogramming it could take days.

• Twenty accumulators — the memory and the adders in one. Each holds a signed ten-decimal-digit number. Every decade is a ring counter of ten neon lamps with exactly one lit — the glowing lamp is the digit — and a PM lamp shows the sign, negatives held in ten's complement. This is the display the emulator draws.
• Digit trunks — the buses that carry decimal digit pulses between units. A unit transmits its number onto a trunk (the A output adds, the S output sends the complement to subtract); a receiving accumulator counts those pulses in on one of five input channels, α β γ δ ε.
• Program-line pulses — a program pulse fires a unit's operation and, when it finishes, emits an output pulse that fires the next line. The plugboard wires those lines into a sequence; this chain is the "program".
• The multiplier and the divider / square-rooter — separate high-speed units for the operations the accumulators could not do directly.
• The master programmer — a bank of steppers with decade counters that count passes and switch program lines after a set number: the ENIAC's loop and branch control.
• The cycling unit — the central clock. One addition time is twenty pulse-times; every transmit and receive happens within it.
• Constant transmitter, function tables, card reader / punch — input of numbers and output of results.

The bundled demos are small plugboard loops in the spirit of the ENIAC's first real work (ballistics tables): a table of squares by the method of differences (add successive odd numbers), a running adder, a factorial driven by the multiplier, a reciprocal table driven by the divider, and a scaled square-root table — a Store counter, an accumulator folding a running result, and a master-programmer step closing the loop.