As mentioned in the introduction, retro-b5500 runs in any modern desktop web browser. It aims to emulate each component of the system with a graphical user interface so you get a taste of what it would be like to operate the machine.

The project includes some great information on its wiki, starting here, describing how the system works and what you need to do step by step. Rather than repeat this here, I will give a summary of the steps involved along with some screenshots. For a first install I recommend you use the server code hosted on the web and the default configuration.

You will need a copy of the virtual install tapes for MCP. Unisys, the current owners of the OS, have provided a license to use these non-commercially. Go to Burroughs B5500 Mark XIII System Software, read and accept the license, download the files, unzip and store them somewhere.

You will also need to download the cold start card image.

Go to the main page and click Start & Power On. Accept the default configuration and the emulator front panel will pop up along with windows for each peripheral. Note that you should keep the main page visible at all times otherwise the browser may think it's inactive and starve resources from the emulator. I have found it OK to arrange windows I don't use often, such as the card punch, into tabs instead of windows.

Find the tape drive window and load the uncompressed system tape you downloaded earlier, then click the REMOTE button.

Find the card reader and load the cold start card you downloaded earlier. Click the START button.

On the operator console, click CARD LOAD SELECT.

On the SPO (operator console), ensure REMOTE is selected.

Arrange the windows so you can see all the above. Your screen should now look something like this:

retro-b5500 just before starting the install. Source: Rupert Lane. License: CC0.

Follow the wiki instructions on cold starting the system. This will involve:

• Booting the system from the card deck.
• The system will start and read from the tape drive, and then initialise the disk. This is all automatic and you should see console messages, ending with MCP FILE LOADED.
• It will then reboot and load from disk from the first time.
• You will be prompted to enter the date and time on the SPO.
• More software will be automatically installed to the disk.
• You will then set the intrinsics (system library).

This should all take less than ten minutes. After this is done, you can shut the system down by pressing the HALT button - there's no special shutdown procedure.

You can restart by pressing LOAD. The system will ask for the date and time again and look something like this:

retro-b5500 on first boot. Source: Rupert Lane. License: CC0.

The guide has one more section on Loading Additional System Files which you can follow if you want, but we will basically load the entire tape as part of the next section so this is not necessary.

At this point the system can accept and run batch jobs. To add time-sharing (CANDE) we need to install more components. Switch over to WebUI Setting Up TSMCP and CANDE for this.

You will need to create two new card files to control terminal line set up and specify user accounts as part of this. Load each of these into the card reader and press START, and the system will read and create these files on disk.

You then tell the system to load all files from tape with the CC command specified in the above wiki. While this is happening, the screen will look like this:

Installing CANDE on retro-b5500. Source: Rupert Lane. License: CC0.

Finally, tell the system about the new install with the CM and CI commands, and halt-load.

When you next start up, enter date and time as before, and enter one more operator command CE to begin time-sharing. (This will need to be done each time you start the system.)

Now find the Datacom window and press CONNECT. You may need to hit enter to get a login prompt. Type the user name and password you specified earlier - when the screen prompts for the password it will type some characters that on a real typewriter would overwrite the password, but on a screen this will not, and you do need to wait for the overprint to stop before entering the password.

Once you are logged in, try creating a simple program and running it:

CREATE HELLO BASIC
10 FOR I = 1 TO 5
20 PRINT "HELLO, WORLD"
30 NEXT I
40 END
RUN

When you type RUN it will compile and execute the program. The screen will look like this:

Note the tasks you are doing also show up in the SPO.

To finish, type SAVE to store the working copy of the program to disk, and type BYE to log out. You can then click HALT on the main console.

I welcome any questions or comments, and also especially any corrections if I have got something wrong. Please email me at rupert@timereshared.com and I will add it here and update the main text.

For software, there are some listings on bitsavers but the most important artefact is a complete copy of the Mark XIII (1971) release of MCP, found on a 7 track tape in the collection of Sid McHarg. This was concerted by Paul Pierce to a tape file and Unisys has allowed this to be distributed under a non-commercial use license. You can find it on Paul Kimpel's site. There is also a collection of miscellaneous software including the CUBE tapes, which was a user-contributed library of programs from Burroughs users.

For documentation, bitsavers has a good collection of manuals for the hardware, operating system and languages.

There are two excellent Burroughs B5500 emulators that take quite different approaches.

Paul Kimpel and Nigel Williams developed retro-b5500. This is written in Javascript and runs in the browser, storing virtual disk files in the browser's local files. It has a user interface that presents each system component - console, printer, tape drive etc - in a form similar to the original hardware, so you get a great idea of how the machine was operated. It runs the batch and time-sharing MCP, though the latter is limited to a single terminal. The documentation is complete and well written; the story of how the project was built is also a fascinating read.

The prolific Richard Cornwell has developed a version of simh for the architecture. This uses the traditional command line interface, supports multiple terminals and brings the automation features of simh which can help with some tasks. Richard's project page contains full information about setting up and using the system; the quick start guide is a good place to start.

I believe Unisys used to offer Windows emulators of its contemporary MCP product under a hobbyist license, but the links I have no longer work.

The Wikipedia articles on Burroughs and its large systems are good places to start.

The IEEE Annals of the History of Computers articles "Before the B5000" and "After the B5000" give a detailed history of Burroughs computers around this period.

There are several good oral histories about this period. Richard Waychoff's Stories about the B5000 (pdf; archive.org link) gives an account of the development of the Algol compiler, with a cameo from a young Donald Knith. The B5000 Conference brings together many of the people involved in the system's design to discuss its origins.

• A quickstart guide to running MCP on retro-b5500

The below will be covered in future posts.

• A quickstart guide to running MCP on simh
• MCP Architecture
• Using CANDE
• Batch and the operator's console
• Getting data in and out
• Programming: BASIC, Algol, Fortran and COBOL

I welcome any questions or comments, and also especially any corrections if I have got something wrong. Please email me at rupert@timereshared.com and I will add it here and update the main text.

By "time-sharing" I mean an operating system which is

1. multi-user - more than one person can use the system at the same time.
2. multi-programming - more than one job can appear to run on the system at the same time.
3. interactive - a user can interact with the system without having to go through an intermediate step like submitting a batch job.
4. general purpose - the system can be used to develop and run programs in more than one language.

I also include virtualised systems like CP/CMS in the list.

We start with pioneers such as CTSS and Dartmouth DTSS in the early 1960s, but time-sharing really took off with mainframes in the late 1960s, with IBM's System/360 and Digital Equipment Corporation's PDP-10 having several commercial and academic operating systems. Also very influential was Multics, built by a consortium for a GE machine. IBM had many other competitors at this time, and outside the US several systems were developed. Minicomputers such as the PDP-8 and -11 started to appear towards the end of the decade, along with the birth of Unix on the latter machine. As the 70s continued, more minicomputers arrived, along with later large scale systems like PRIMOS and VAX VMS. Coming into the 1980s, focus shifted to microcomputers for personal use, with some outliers like MP/M and the workstation orientatted Domain/OS.

I have grouped operating systems into families where there is a clear line linking them together. This may span many years and different computer hardware. Probably the biggest example is Unix which is listed once in the table for the original implementation but went on to appear in many different versions (BSD, commercial Unixes like Solaris, Linux) across many different platforms.

As an operating system evolves, it can take on many names: for example the OS listed as CP/CMS includes its derivatives VM/370, VM/SE, VM/SP, VM/XA, VM/ESA, z/VM etc.

In some cases this is a judgement call - for example WAITS was originally based on TOPS-10, but I have included it as it is evolved to be a quite different system,

In scope are operating systems first introduced before 1983 - this is a fairly arbitrary cut off date chosen to focus on the period time-sharing systems were dominant before the personal computer started its ascent.

The date column indicates the first year an operating system was introduced: for commercial systems, the year of its first release to customers; for academic systems, the first year it ran production workloads.

Some operating systems had a lifespan of many years, gaining features and adding architectures. Some started as batch operating systems and had time-sharing added later. I have used the year when time-sharing features were added in that case. Some are still being maintained today, albeit in quite different forms from the original version, such as MVS, MCP and VMS.

This column was by far the hardest to verify and I would appreciate any correctiobs.

One complication then is, when we look at an operating system which version should we select? Often the choice is made for us, so for CTSS we have a single source from around 1969; in other cases like TOPS-10 we have a choice of releases spanning 1972 to 1988.

I will generally choose to look at the most recent version of a system, but this does make a chronological comparison of different systems more difficult.

I concentrate on running operating systems under emulation here, which anyone can do if they have a personal computer. The gold standard is an open-source, cross platform emulator, but I do included single platform ones (eg emulators running on Windows only) and closed-source but freely available emulators where this is the only choice. I do not include commercial, paid-for emulators as the focus for this site is hobbyists and researchers.

Some systems have more than one emulator. I usually choose simh or hercules if available, if not the most fully features single architecture emulator. In some cases where there is sufficiently different functionality or approach to emulation I list more than one.

simh is the most frequently represented emulator on this list as it emulates more than 30 different architectures. There are several different forks, but in most cases a recent version of open-simh is a good choice.

hercules also appears several times due to the large number of IBM System/360 operating systems. Again there are several forks, but SDL hercules hyperion is my current preference.

I have not (yet) run all the emulators listed in the table, so it's quite possible some do not work fully - please let me know if so.

Alternatives to emulation running on your own personal computer:

• hardware for more recent systems such as PDP-8s or VAXes is available on sites like ebay, but is getting increasingly expensive.
• replicas running emulators on hardware like Raspberry Pis, such as the PiDP-11.
• some museums has put original hardware online where you can get an account, such as The Interim Computer Museum.
• there also collections of online-accessible emulators such as nostalgiccomputing.org.

In the "SW" column I link to the project page or archive site where software kits can be obtained. Be aware that some kits have specific licenses attached and others have no obvious current owner so their licensing status is unknown.

The "Doc" column links to the main source of documentation for the operating system in PDF format: this is usually Bitsavers.

This is not a comprehensive list of all time-sharing operating systems ever produced - to my knowledge, no such list exists but I estimate it would be at least double this size.

In order for a system to be available on emulation, several things need to happen (or to have already happened)

• the original software and documentation needs to have been preserved, ideally in digital form
• sufficient details of the hardware it ran on need to have been preserved
• someone has made the big effort to write an emulator for the system

Some examples of systems that are not available, at least today, via emulation

• early systems like AN/FSQ-32, JOHNNIAC or the PDP-1 systems developed by BBN and MIT, along with British systems like the Titan Supervisor
• Mainframe operating systems like GE GCOS, RCA TSOS, Univac Exec 8 and ICL VME.
• Academic systems like CAL-TSS, OS-3, CAP or EMAS.
• Many minicomputer systems.
• More recent systems that are only available commercially, eg Tandem or Stratus VOS.

And in many cases, even for those available, not all versions of each operating system has been preserved.

Please let me know if you think I am missing any systems, or if you think my methodology is not right. You can email me at rupert@timereshared.com and if it makes sense I will add it here and update the main text.

August 2025: Lars Brinkhoff suggested adding SITS.

Algol was originally designed by a committee of European and American computer scientists in the 1950s-60s. The first version to be widely implemented was Algol 60, which is what we will look at here.

Dartmouth had experience of implementing subsets of Algol on its smaller computers before DTSS, and this was the second language to be introduced on DTSS after BASIC in 1964.

An illustration of a GE-225 system from "GE 200 Series Operation Manual", GE, 1966. Source: bitsavers.

One important point when dealing with Algol is different levels or representations of the language: there is one for the spec, one for printed programs and one for the machine implementation. As an example, to raise a to the power b:

• Spec: a ↑ b
• Printed: a^b
• Machine - Dartmouth: a ^ b
• Machine - IBM: a ** b

We'll use the printed form in this article and the Dartmouth machine form for code examples.

Keywords are in bold lower case in the printed form (eg integer). Dartmouth uses upper case (eg INTEGER). (IBM used quotes, eg 'INTEGER', which must have been a pain to type).

Here's an example program that will print Hello World 5 times

10 BEGIN
20 INTEGER I;
30 FOR I := 1 STEP 1 UNTIL 5 DO
40     PRINT("HELLO, WORLD")
50 END PROGRAM

The line numbers are not part of Algol but are needed for the Dartmouth program editor.

Statements are grouped into blocks, separated by semicolons; the last statement in a block does not need a semicolon.

Variables are typed (real, integer, boolean); strings are allowed only as constants.

Algol has no standard I/O - reflecting how different each computer was at that time, it was up to the implementation to add this. Dartmouth Algol uses print much like BASIC for output.

Let's exercise Algol further by implementing the TPK algorithm.

100 BEGIN
110     COMMENT TPK ALGORITHM IN ALGOL 60;
120 
130     REAL PROCEDURE FN(X);
140     VALUE X;
150     REAL X;
160     BEGIN
170         FN := SQRT(ABS(X)) + 5*X^3
180     END PROCEDURE;
190 
200     COMMENT MAIN PROGRAM;
210     INTEGER N, J;
220     REAL ARRAY A[1:11];
230     N := 11;
240     COMMENT READ NUMBERS FROM DATA;
250     FOR J := 1 STEP 1 UNTIL N DO
260         READATA(SAMPLE, A[J]);
270     PRINT("RESULTS ARE");
280     FOR J := N STEP -1 UNTIL 1 DO
290     BEGIN
300         REAL RESULT;
310         RESULT := FN(A[J]);
320         IF RESULT > 400.0 THEN
330             PRINT("TOO LARGE")
340         ELSE
350             PRINT(RESULT);
360     END LOOP;
370     DATA SAMPLE := 10, -1, 1, 2, 3, 4, 4.3, 4.305, 4.303, 4.302, 4.301;
380 END PROGRAM

The indentation is for readability only and is not required by the language. Contemporary users would probably pack more statements per line so as to use less vertical space on the typewriter output. It's not shown here, but you can also spread out statements over several lines and even include spaces in variable names.

In the procedure definition, note that we declare the input parameter X as having real type and also value class, so it is passed by value; the other option is name which is similar to pass-by-reference.

The main program starts on line 200. Note that variables need to be declared before they are assigned to, and arrays can have arbitrary indices.

The program uses the readata procedure, which is a Dartmouth extension to read items from the matching data statement, similar to BASIC READ and DATA. print is also a Dartmouth extension.

At line 300, note that RESULT is declared in the for block so its scope lasts until the end of the block only; this was an innovation of Algol.

• See the quick tour on how to get the emulator running.
• Download the source file from Github.
• If you are not on Windows, ensure the file has CR/LF line endings. A simple way to do this:

awk 'sub("$", "\r")' < input_file > output_file

• Store the file as TPKA (no extension) in the same directory as DTSS.EXE.
• Start DTSS.
• Type SYSTEM ALGOL to switch from BASIC to Algol.
• Type OLD TPKA.
• Type LIST to confirm the source has been loaded.
• Type RUN.

The DTSS zip file contains An Algol Outline.pdf.

The Revised Report on the Algorithmic Language Algol can be considered as the standard definition of the language.

There are some contemporary books on the Internet Archive: Dijkstra's A Primer of Algol 60 Programming is terse but readable; McCracken's A Guide to ALGOL Programming is a more traditional text book.

I wrote an overview of Algol 60 on the IBM S/360 under MTS here, which goes into more detail on the language and how IBM implemented it.

I welcome any questions or comments, and also especially any corrections if I have got something wrong. Please email me at rupert@timereshared.com and I will add it here and update the main text.