Search › A-Z › N › Data General Nova

Data General Nova

1969 Open source · Public domain Online

A faithful Data General Nova authored for emulators.org and running in the browser. The Nova, launched in 1969, is the classic 16-bit minicomputer: a whole processor on a single board, with four accumulators, a regular instruction set and the famously dense arithmetic-logic word that does a function, a shift, a carry preset and a skip test all at once. This build models the processor, a console Teletype and a lit front panel, and boots with a demo running: it prints a banner and echoes what you type. The on-screen keypad is the front panel itself — flip the 16 data switches and press EXAMINE, DEPOSIT, START and STEP. It plugs into the shared debugger, where you can single-step the CPU, watch AC0-AC3 / PC / CARRY change, set breakpoints on the program counter, and read core memory as octal disassembly.

Runs on: Web browser

Data General Nova Online Emulator

Play Data General Nova using JavaScript directly in your browser.

Configurations

ConfigurationEmulatorMachineOSLegal
Teletype echoData General NovaData General NovaopenOpen ⛶
Front-panel blinkerData General NovaData General NovaopenOpen ⛶
Data-lights counterData General NovaData General NovaopenOpen ⛶

Notes

Embedding

The emulator is two small, self-contained pieces: a pure Data General Nova processor (nova-cpu.js) and a canvas that paints the console Teletype plus a lit front panel (nova-screen.js). Vendor both and drive the machine from your own loop. The core never touches the DOM, so the debugger can pause, step and breakpoint it:

var cpu = new Nova({ onOutput: function (ch) { screen.putChar(ch); } });
cpu.load(image, 0o40);      // image = { addr: word }, start PC = 0040
while (!cpu.halted) cpu.step();   // step() = one Nova instruction

The machine is plain objects. Everything the debugger needs is a live field or method on the core, so there is no wasm heap to reach into:

MemberKindWhat it does
cpu.step()methodExecute exactly one Nova instruction (the single-step primitive), including indirect / auto-index addressing and the full ALC shifter-carry-skip word.
cpu.ac[0..3]fieldThe four 16-bit accumulators, as plain writable numbers.
cpu.pc / cpu.carryfieldThe 15-bit program counter and the one-bit CARRY flag.
cpu.srfieldThe front-panel switch register, read by the panel EXAMINE / DEPOSIT / START logic.
cpu.rd(a) / cpu.wr(a,v)methodSide-effect-free read / write of one 16-bit word — what the memory views and watchpoints call.
cpu.keyIn(ch)methodPresent a character to the Teletype keyboard (raises the TTI Done flag for the running program to read).

Because the CPU and core store are ordinary JavaScript, breakpoints and watchpoints are host-side checks around cpu.step() and cpu.wr(), with no changes to the core.

Debugger integration

The boot shim publishes window.EMU_BOOT with a full transport: pause / resume / isPaused, stepInsn(n) (one instruction) and step(n) (a burst), reset, plus breakpoints (program-counter values the loop checks before each step) and watchpoints (core addresses, checked inside the write path). A dedicated CPU decoder, /debugger/src/cpus/nova.js, disassembles each 16-bit word into native octal mnemonics: the memory-reference set (LDA STA JMP JSR ISZ DSZ) with indirect and PC-/AC2-/AC3-relative modes, the programmed-I/O group (NIO DIA DOA … SKPDN with device names), and the whole arithmetic-logic class — function, shifter (L R S), carry preset (Z O C), the no-load # and the skip tests (SKP SZC SNC SZR SNR SEZ SBN).

Core memory is 32 K sixteen-bit words. The nova decoder reads each word as two bytes, little-endian, so the plug-in exposes the store as a 64 KB chip: byte 2n is the low eight bits of word n and byte 2n+1 the high eight. Every instruction is therefore length two, and the register plug-in returns a byte-scaled pc() so the disassembly gutter, the program-counter highlight and breakpoints all line up on word boundaries.

Architecture

The Data General Nova, launched in 1969, is the classic 16-bit minicomputer — a whole processor on a single 15-inch board, cheap enough to build the microcomputer era on. Its instruction set is small and famously regular: the top three bits pick the class.

  • Memory reference (LDA STA JMP JSR ISZ DSZ): an 8-bit displacement reaches page zero, the current PC, or an offset from AC2 / AC3; an indirect bit follows a pointer chain, and locations 020-027 auto-increment (030-037 auto-decrement) when used indirectly, giving cheap pointers for string and array walks.
  • Arithmetic-logic (ALC): one word does a lot at once — a source and destination accumulator, one of eight functions (COM NEG MOV INC ADC SUB ADD AND), an optional shift or byte-swap, a carry preset, and a skip test on the 17-bit carry-and-result, with a no-load # that runs the ALU only to make the test. This density is the Nova's signature.
  • Programmed I/O: NIO / DIA…DOC / SKP move data and test Busy / Done flags on a device code. The console Teletype answers on device 010 (keyboard) and 011 (printer).

The bundled demo is a short program in genuine Nova code: it walks a banner string through the auto-increment location 020 and prints it a character at a time to the Teletype, then loops on SKPDN TTI / DIA to read the keyboard and echoes each key with DOAS 0,TTO. Other configurations run a lamp-walker and a binary counter whose output you watch on the front-panel data lights.