Data General Nova

Data General SuperNova
Data General SuperNova

The Data General Nova was a popular 16-bit minicomputer built by the US company Data General starting in 1968. The Nova packed enough power to do most simple computing tasks into a single rack mount case, and became hugely popular in science labs around the world. Eventually 50,000 would be sold.


deCastro and the Nova's origin

Edson deCastro was the Product Manager at Digital Equipment (DEC) of their pioneering PDP-8, a 12-bit machine generally considered by most to be the first true minicomputer. However deCastro was convinced it could be done even better, and left DEC to form Data General (DG) in 1968. The next year DG released the 16-bit Nova (at a base price of US$3,995), advertised as «the best small computer in the world».

Technical description

The packaging factor

Besides offering 16 bits compared to the 12 bits of the PDP-8, another big innovation of the Nova was in packaging. The original Nova CPU was contained on only two large 15×15 inch (38×38 cm) printed circuit boards, which could be run off on an assembly line with no wiring required. This greatly reduced costs over the rival PDP-8 and PDP-8/I, which consisted of many smaller boards that had to be wired together. The larger-board construction also made the Nova more reliable, which made it especially attractive for industrial or lab settings.

Memory and I/O

The first models were available with 4K words of magnetic core memory as an option, one that practically everyone had to buy, bringing the system cost up to $7,995. Even here DG managed to innovate, packing several planes of very small core and the corresponding support electronics onto a single standard 15 x 15 inch board. Up to 32K of such core RAM could be supported in one external expansion box. Semiconductor ROM was already available at the time, and RAM-less systems (i.e. with ROM only) became popular in many industrial settings. The original Nova machines ran at approximately 0.2 MHz, but its sibling released the next year - the SuperNova - was designed to run at up to 3 MHz when used with special semiconductor main memory.

The standardized backplane and I/O signals created a simple, efficient I/O design that made interfacing programmed I/O and Data Channel devices to the Nova simple compared to competitive machines. In addition to its dedicated I/O bus structure, the Nova backplane had wirewrap pins that could be used for non-standard connectors or other special purposes.

Programming model

The Nova had four 16-bit accumulator registers, of which two could be used as index registers. There was a 15-bit program counter and a single-bit carry register. As for the PDP-8, current + zero page addressing was central. The instruction format could be broadly categorized into one of three functions: 1) register-to-register manipulation, 2) memory reference, and 3) input/output. Each instruction was contained one word. The register-to-register manipulation was almost RISC-like in its bit-efficiency; and an instruction that manipulated register data could also perform tests, shifts and even elect to discard the result. Hardware options included a multiply and divide integer unit, a floating-point unit (single and double precision), and memory management.

Data General developed a wide range languages for the Nova computers running under a range of consistent operating systems. FORTRAN IV, ALGOL, Extended BASIC, Data General Business Basic, Interactive COBOL, and several assemblers were available from Data General. Third party vendors and the user community expanded the offerings with Forth, Lisp, BCPL, C, Asgol, and other proprietary versions COBOL and BASIC.

Historical impact

The Nova's biggest competition was from the newly-born DEC PDP-11 computer series, and to a lesser extent the venerable DEC PDP-8 systems. It has been said that the Nova was pretty crude compared to its competitors; but it was quite effective and very fast for its day, at least at its low-cost end of the market. In fact, the SuperNova computer's 300 nanosecond cycle time made it the fastest minicomputer for over a decade following its introduction. The Nova influenced the design of both the Xerox Alto (1973) and Apple I (1976) computers. Its external design has been reported to be the direct inspiration for the front panel of the MITS Altair (1975) microcomputer.

Data General followed up on the success of the original Nova with a series of faster designs. The Eclipse family of systems was later introduced with an extended upwardly compatible instruction set, and the MV-series further extended the Eclipse into a 32-bit architecture to compete with the DEC VAX. The development of the MV-series was documented in Tracy Kidder's popular 1981 book, The Soul of a New Machine. Data General itself would later evolve into a data storage vendor, eventually being purchased by EMC.

As of 2004 there are still 16-bit Novas and Eclipses running in a variety of applications worldwide. There is a diverse but ardent group of people worldwide who restore and preserve legacy 16-bit Data General systems, and a web search for [Data General Nova (], [Eclipse (], [RDOS (], or various other DG-related keywords should normally yield good results.

Assembly language examples

Hello world program

This is a minimal programming example in Nova assembly language. It is designed to run under RDOS and prints the string "Hello, world." on the console.

	; a "hello, world" program for Nova running RDOS, by Toby Thain
	; uses PCHAR system call
	.titl hello
	.ent start

	lda 0,@pmsg	; load ac0 with next character,
	mov# 0,0,snr	; test ac0; skip if nonzero (don't load result)
	jmp done
	.pchar		; print first
	jmp er	; skipped if OK
	movs 0,0	; swap bytes
	.pchar		; print second
	jmp er	; skipped if OK
	isz pmsg	; point to next character
	jmp dochar	; go around again

done:	.systm		; normal exit
er:	.systm		; error exit

pmsg:	.+1 ; pointer to first character of string
	; note bytes are packed right-to-left by default
	.txt /Hello, world.<15><12>/ ; that's CR LF
	0 ; flag word to end string

	.end start

16-bit multiplication

Basic models of the Nova came without built-in hardware multiply and divide capability, to keep prices competitive. The following routine multiplies two 16-bit words to produce a 16-bit word result (overflow is ignored). It demonstrates combined use of ALU op, shift, and test (skip). Note that when this routine is called by jsr, AC3 holds the return address. This is used by the return instruction jmp 0,3. An idiomatic way to clear an accumulator is sub 0,0. Other single instructions can be arranged to load a specific set of useful constants (e.g. -2, -1, or +1).

mpy:	; multiply AC0 <- AC1 * AC2, by Toby Thain

	sub 0,0		; clear result
mbit:	movzr 1,1,szc	; shift multiplier, test lsb
	add 2,0		; 1: add multiplicand
	movzl 2,2,szr	; shift and test for zero
	jmp mbit	; not zero, do another bit
	jmp 0,3		; return

Binary print accumulator

The following routine prints the value of AC1 as a 16 digit binary number, on the RDOS console. It reveals further quirks of the Nova instruction set. For instance, there is no instruction to load an arbitrary "immediate" value into an accumulator (although memory reference instructions do encode such a value to form an effective address). Accumulators must generally be loaded from initialised memory locations (e.g. n16). Other contemporary machines such as the PDP-11, and practically all modern architectures, allow for immediate loads.

Because AC3 is not preserved by the RDOS .systm call, a temporary location is needed to preserve the return address. (For a recursive or otherwise re-entrant routine, the stack must be used instead.) The return instruction becomes jmp @ retrn which exploits the Nova's indirect addressing mode to load the return PC.

The constant definitions at the end show two assembler features: the assembler radix is octal by default (20 = sixteen), and character constants could be encoded as e.g. "0.

pbin:	; print AC1 on console as 16 binary digits, by Toby Thain

	sta 3,retrn	; save return addr
	lda 2,n16	; set up bit counter
loop:	lda 0,chr0	; load ASCII '0'
	movzl 1,1,szc	; get next bit in carry
	inc 0,0		; bump to '1'
	.pchar 		; AC0-2 preserved
	jmp err ; if error
	inc 2,2,szr	; bump counter
	jmp loop	; loop again if not zero
	lda 0,spc	; output a space
	jmp err ; if error
	jmp @ retrn

spc:	" ;that's a space
chr0:	"0
n16: 	-20
retrn:	0

Emulating a Data General Nova

Nova assembly language programs can be run under Bob Supnik's simh emulator, in RDOS. Of the above examples, only Hello, world is a complete program. It includes the necessary directives for a successful assembly and generation of a runnable program.

Stepwise instuctions

Start the Nova emulation and boot RDOS following the instructions under "Nova and Eclipse RDOS" in the file src/simh_swre.txt of the simh distribution. After booting, RDOS' command prompt, R, should appear on the screen.

  • Before the first assembly on a newly setup RDOS system, the macro assembler's default symbol definitions need to be configured using the following command: mac/s nbid osid nsid paru</tt>
  • Create the assembly source file under RDOS: <tt>xfer/a $tti</tt> (the <tt>xfer command will accept input at the console and copy it to a disk file named; after entering the command, copy and paste (or type in) a complete assembly language program, and finish with Control-Z).
  • Next, run the macro assembler on to create the object file test.rb: mac/l test (the /l [slash-ell] option enables the listing file, which can be copied to the console using the command type
  • The relocatable loader, rldr, takes the object file and creates the executable : rldr test
  • To run the program, type test

Before going further with serious experimentation, it can be convenient to check one's programs at the PC using a suitable cross-assembler, such as the Didactic PDP-8 Assembler (dpa), before attempting execution in the RDOS environment.

RDOS hints

  • To have a directory listing of all files with basename test, type list test.- (note the hyphen, RDOS' wildcard character)
  • Delete files with delete (this might be needed because xfer won't replace an existing file)
  • A running program can usually be interrupted with Control-A
  • To exit RDOS, type release %mdir%
  • Quit simh at its prompt with q

External links

  • Bob Supnik's SimH project ( – Includes a basic Nova emulator in a user-modifiable package
  • SimuLogic's website ( – Attempts to archive everything DG plus provide free and commercial products
  • Didactic PDP-8 Assembler (dpa) ( – A portable PDP-8 and DG Nova cross-assembler

  • Art and Cultures
    • Art (
    • Architecture (
    • Cultures (
    • Music (
    • Musical Instruments (
  • Biographies (
  • Clipart (
  • Geography (
    • Countries of the World (
    • Maps (
    • Flags (
    • Continents (
  • History (
    • Ancient Civilizations (
    • Industrial Revolution (
    • Middle Ages (
    • Prehistory (
    • Renaissance (
    • Timelines (
    • United States (
    • Wars (
    • World History (
  • Human Body (
  • Mathematics (
  • Reference (
  • Science (
    • Animals (
    • Aviation (
    • Dinosaurs (
    • Earth (
    • Inventions (
    • Physical Science (
    • Plants (
    • Scientists (
  • Social Studies (
    • Anthropology (
    • Economics (
    • Government (
    • Religion (
    • Holidays (
  • Space and Astronomy
    • Solar System (
    • Planets (
  • Sports (
  • Timelines (
  • Weather (
  • US States (


  • Home Page (
  • Contact Us (

  • Clip Art (
Personal tools