The Retrocomputing Museum is dedicated to programs that induce sensations that hover somewhere between nostalgia and nausea — the freaks, jokes, and fossils of computing history. Our exhibits include many languages, some machine emulators, and a few games.

Most are living history — environments that were once important, but are now merely antiques. A few never previously existed except as thought experiments or pranks. Most, we hope, convey the hacker spirit — and if not that, then at least a hint of what life was like back when programmers were real men and sheep were nervous.

The curators of the Museum are Eric S. Raymond and John Cowan. See Eric's offer for more about the kinds of things we build and collect.

If you've visited before, check out the what's new section. You, too can contribute to the Museum! If you think something belongs here, tell us about it. Take a look at our want list of things we're looking for. Finally, you can browse a list of related resources.

We link to Pete Friedrich's Spiked Punch project.

We have acquired hardcopy manuals for IPL-V and SLIP and are looking into what it will take to get them scanned and OCRed.

All these packages include documentation and example programs.

Adventure Definition Language. Ross Cunniff <cunniff@fc.hp.com> & Tim Brengle, 1987. An adventure language, semi-object-oriented with LISP-like syntax. A superset of the infamous DDL (Dungeon Definition Language). Available for Unix, MS-DOS, Amiga and Acorn. You can find other adventure-writing languages at the Interactive Fiction Archive.

An interpreter for Algol-60, the common ancestor of C, Pascal, Algol-68, Modula, Ada, and most other conventional languages that aren't BASIC, FORTRAN, or COBOL. Correctly described by Edsger Dijkstra (one of its co-designers) as "a great improvement on many of its successors". This distribution (which seems to originate here) includes TeX source for the Algol 60 Report. There is a GNU implementation as well. More resources, including sample programs, are available here.

(Off-site link) This page collects resources — implementations, documentation, etc — related to Algol 68, the most magnificent combination of theoretical success and practical failure in the history of programming languages. More Algol68 resources can be found at the Software Preservation Group.

ADVenture SYStem, another adventure-writing system by David Betz, 1986. The language describes it as "LISP-like and object-oriented". We carry it mainly for comparison with ADL. You can find other adventure-writing languages at ftp://ftp.gmd.de/if-archives/programming.

A very old and very weird APL implementation. Said to contain substantial amounts of code written by Ken Thompson, one of UNIX's coinventors.

Before FORTRAN (the first compiled langage) was Autocode (the first interpreter), dating from 1954. Amazingly, it has been revived as a control language for microcontrollers!

The BlooP and FlooP languages from Chapter XIII of Goedel, Escher, Bach: An Eternal Golden Braid by Douglas R. Hofstadter. BlooP mechanizes primitive-recursive functions, FlooP mechanizes general-recursive ones. Thoroughly primitive otherwise. Implemented as a Perl interpreter which generates Perl and promptly interprets it (how Hofstadterian!), by John Cowan <cowan@locke.ccil.org>.

BASIC lives — unfortunately. This version implements most of the notoriously bad ANSI X3.113-1987 standard for Full Basic. As the Computer Contradictionary succinctly observes, "Shit with icing".

(Offsite link) This is (more or less) what happened when a Danish schoolteacher got fed up with Basic back in the early 1980s. COMAL added procedures and various structured-programming facilities. It was popular in the Commodore-64 community in Europe for a few years. This vesrsion has been heavily extended, but still conveys some of the flavor of what those 1980s micro languages were like. There is a very interesting history of the language (presented as introduction to a bibliography) which puts it in context with BASIC.

(Offsite link.) The design of C was based on an earlier language, B, which was an interpretive typeless subset of BCPL. This implementation includes a suite of demonstration programs. We also carry a B-to-C translator.

A compiler for a very, very tiny subset of Algol (no procedures, even). More a demonstration on how to write a recursive descent parser than anything else. Generates stupid but portable C code.

COBOL is still a living language in 2004, but we've included a link to an open-source implementation because it's nearly as crufty as some of the horrible old dead ones we keep here.

Another hideous old design, CUPL — Cornell University Programming Language. It looks something like a really archaic BASIC with linear-algebra builtins. This 1.1 version now also interprets and documents CUPL's immediate precdecessor, CORC (Cornell Computing Language). I (esr) reverse-engineered it from the original manuals, written in 1966 and 1962; the language-description parts of the manuals are included in the docs. If you want to know what programming was like before interactive time-sharing, build this and find out. Requires either lex or flex, and bison or yacc.

Note: there's a modern CUPL, an EDA tool, that is unrelated to this language.

A very archaic educational language, a sibling of (and closely resembling) MUMPS.

Retro in a different direction: this programming language uses the orthography and mimics the syntax and gammar of Classical Chinese.

A computer language designed by Don Woods and James Lyons in 1972. INTERCAL is purposely different from all other computer languages in all ways but one; it is purely a written language, being totally unspeakable. Said by the authors to stand for "Computer Language With No Pronounceable Acronym". INTERCAL devotees hang out on the alt.lang.intercal newsgroup.

The JCL Shell is a Unix shell which emulates, in style and syntax, the infamously complex and perverse Job Control Language used to control IBM mainframes.

Joss, the JOHNNIAC Open Shop System, was an early interactive calculator language similar in scope to Unix's bc(1) calculator, but with a rather more English-like syntax. We have a rudimentary implementation and two sample programs. We'd be very grateful to anyone who could supply documentation.

A very odd little language alleged to have been used for embedded-systems control on Swedish nuclear submarines in the 1950s. Notable for its probabilistic-jump instruction.

The language that gave us "turtle graphics" — intended (in the approximate words of one coauthor) for 5-year-old children and less educable beings, such as corporate executives. Rather advanced for 1968; it was really a sort of stealth LISP with pretty displays.

(Note: we don't carry this locally — we don't know the state of its documentation, or whether it includes examples.)

We have an implementation of MAD, the Michigan Algorithmic Decoder from 1959-1962. The entire original manual, including diagrams and flowcharts, is included in the distribution. So is a chrestomathy of programs.

An implementation of the MIX pseudoassembler used for algorithm description in Donald E. Knuth's The Art Of Computer Programming , vol I. This is the GNU implementation, which replaces the MIXAL package I formerly maintained. It includes all the material Donald Knuth contributed to MIXAL.

Finally, a truly orthogonal language! This unique design, inspired by a speculative thread on alt.lang.intercal in September 1994, is an interpreter for a simple language with two-dimensional control structures...your control flow can go forwards, backwards, or sideways (or even diagonally!).

The reference implementation for IEEE standard PILOT, a horrible language designed in 1962 on IBM mainframes that a group of ancient academics was still insane enough to be using in 1990 —- and not only using but standardizing. I (esr) wrote this implementation as a weekend hack.

HTMLized version of the CACM paper describing Zuse's Plankalkül design. Note: the diagrams and some of the glyphs in this paper are GIF images. Here's an implementation and more documentation.

Once upon a time in the early 1960s, there was a monster called PL/1 that was IBM's attempt to create The Final Language. Ten years later Gary Kildall wrote a compiler for a tiny subset he called PL/M as a development tool for 8080 micros (and wrote CP/M as a demonstration project for the language). This program is a PL/M-to-C translator by Robert Ankeney.

Starting in 1972, Adele Goldberg and other researchers at XEROX PARC began experiments with personal interactive computing that were to tremendously influence many later environments, especially including the Macintosh. The language they designed for development in their icons-windows-and-mice environment was Smalltalk. We offer an implementation here.

One of the most interesting, original, and influential languages of the 1960s, SNOBOL was designed around string-processing, pattern-matching, and textual transformation. Like many other one-idea languages (TRAC, APL) it was extremely powerful and elegant within its problem domain, but weak outside it (there also seems to be a law that such languages must have obscure syntax). It strongly influenced UNIX regular expression notation. Docs and example programs are bundled with the so-called `vanilla' distribution. (Note: we don't keep this locally.) (You may also want to check out the Icon home page.)

Yes, it's the Editor From Hell...the infamous TECO, bane of lusers and tricky, unforgiving tool of master hackers. Build this to find out (a) what we lived with before Emacs, and (b) how expressive line noise can be. This is Sander Van Malsen's ANSIfied version of TECO for Ultrix. For other versions of TECO, see the collection at http://sunsite.tus.ac.jp/pub/academic/computer-science/history/pdp-11/teco/.

An extremely funky computer language based entirely on macro processing. There is an interpreter written in Perl, and a text file documenting the language and the implementation. This implementation is by John Cowan <cowan@locke.ccil.org>.

Turingol, a language for programming Turing machines. Invented by Donald Knuth to demonstrate some technical points in compiler design (featured the first construction of a nontrivial attribute grammar). See "Semantics of Context-Free Languages", D. Knuth, Math Sys Thy 2:127-145 (1975). This implementation is written in Java by Georges Focant.

An implementation of Turingol in C by Peter Gammie. Dumps the tape states during computation to standard output. This version has been lightly adapted from Gammie's original for the Museum.

A stack-based, Forth-like language for speakers of Klingon. The author says: "var'aq is the bastard child of a back-room tryst between PostScript and Lisp after a Star Trek convention....it's really something of a Klingon Basic, a simple, loosely-typed programming language designed mostly just to be used for programming things like command displays and high-level control systems. In its eventual final incarnation, we're looking at concurrency, advanced mathematics, and even native support for distributed programs..."

The author describes Unlambda as "Your Functional Programming Language Nightmares Come True". Elsewhere, there is a Unlambda interpreter in INTERCAL.

You've heard of RISC, Reduced Instruction Set Computers? Well, here is the concept taken to its logical extreme — an emulator for a computer with just one (1) instruction (Subtract and Branch if Negative)! Sample programs in the OISC machine language are included.

We now have available have a revised and expanded version of oisc called OIC. In the future, this may replace OISC.

There have been several demonstration emulators for machine architectures with single instructions. This is another. Examples of its unique assembly language are included.

Retro in a different direction: this programming language uses the orthography and mimics the syntax and gammar of Classical Chinese.

The DEC PDP/8 was the best-selling computer in the world until the advent of the Apple II. However, we don't maintain PDP-8 software here, because there is an excellent archive at sunsite.unc.edu in the `/pub/academic/computer-science/history/pdp8' directory; various emulators are available in the `emulators' subdirectory. On a modern RISC box, an emulator can run faster than the ancient TTL hardware it is emulating!

A faithful clone of the classic Hunt The Wumpus game, exactly as it appeared in 1972 on the Dartmouth Time-Sharing System. Also includes an original but strangely similar game, superhack.

(This game has popped up in some odd places. You can actually play it on a WAP cellphone).

Colossal Cave Adventure - not the 350-point 1977 version in the BSD Games collection, but the 430-point 1995 version that was the last one Crowther & Woods worked on. Issued with the permission of the authors.

SST2K is a modern Unix port of the University of Texas "Star Trek" game originally written in FORTRAN in the mid-1970s. It has options to restrict its feature set to what was in earlier versions.

Possible Future Projects

The Museum has an incomplete BLISS-to-C compiler. A substantial amount of BLISS source code is available for use as test code.

Implementations, or softcopy specifications, for the following languages:

IPL-V, SLIP, RPG, JOVIAL, CORAL, POP-2 or POP-10, 1401 Autocoder, NEAT/3.

Hm, there seens to be a Coral spec here....

Sample programs to add to the distributions for the following languages:

FOCAL, ALGOL-60, JCL, TECO.

The Heirloom Project

The Heirloom Project provides a large collection of classic Unix tools forward-ported from OpenSolaris. The curator says: "Some people like to drive classic cars, others like to arrange their domiciles with period furniture. The Heirloom Project caters to people who like to operate their computers using a traditional Unix command line interface. The Heirloom Project is not a software museum; it does not attempt to preserve utilities unmodified. Rather, it keeps stylistic, algorithmic, and interface aspects intact while modernizing the framework as appropriate."

The Source of Multics

(Off-site link) The source code of the Multics operating system has been opened and is now available from MIT. This was one of the pioneering timesharing operating systems of the mid-1960s -- actually, only the second one ever built, after CTSS -- and was the design ancestor of Unix.

This is an archive of classic AI programs and games including Eliza, Adventure, and many others. Also, implementations of AI languages including XLISP and many others. The Attic is an FTP archive located at: {bongo,ftp}.cc.utexas.edu:pub/AI_ATTIC.

This is a collection of Internet slang, folklore, and history. The entry page also offers you the option to download it in one of several formats.

The collection of open-source software that I wrote and/or maintain. There is some overlap with this collection, of course.

This is a collection of implementations of a trivial program (one to print out the lyrics of "99 Bottles Of Beer On The Wall") in lots of different languages. A very interesting chrestomathy.

Perhaps the ultimate retrocomputing-in-hardware project! Don't miss the nifty picture of the test chip.

And this must be the ultimate retrocomputing-in-software project; an emulator of Babbage's Analytical Engine, with lots of supporting documentation.

Yet another page of nasty old languages.

Perhaps the most remarkable hardware retrocomputing hack yet was Tony Sale's painstaking reconstruction of the Colossus machine, a parallel computer built for codebreaking during WWII and kept secret for fifty years afterwards.

A collection of simulations of historical machines.

Bill Buzbee designed and home-built computer roughly equivalent in power to an eary 8086 using TTL chips and wire-wrap. Then he hand-built an OS for it, retargeted a C compiler to it, and ported Minix to it. Need we add that it has a front panel full of switches and blinkenlights?

A ne plus ultra of old-school hacking back in the 1980s from a high-school kid who homebrew-hacked an IBM card punch to be driven by a TRS-80...and, decades later, recovered the original hardware and describes how he did it. With photographs.

Some material on this site may be under copyright by its original authors and reproduced without permission here. We're talking about code and manuals that are decades old and predate even the concept of open-source licensing; in some cases the original authors are dead or long retired and it is not clear how to even begin locating them.

This site is a resource for hackers and scholars. We have tried to treat all these materials with respect for the intentions of their authors. If you are an author, we will be happy to comply with any requests concerning your material.