Burroughs Large Systems

A couple of sightings on social media:

with photos (see below)



There are a couple of simulators available for the B5500:

  1. Paul Kimpel’s “retro-B5500” browser-based simulator,
    (The same gentleman has also done simulators for
    the Burroughs/Datatron 205
    and the B220

  2. Richard Cornwell’s SimH-based B5500
    (sims on github)

Both 5500 simulators will run MCP XIII, available under
license for non-commercial use from Unisys.
(It was thanks to Sid McHarg that the MCP tapes
from ca. 1970 were preserved.
(“Burroughs B5500 Mark XIII System Software” on retro-B5500)

Both Paul Kimpel and Nigel Williams (of retroComputing
Tasmania) have been looking for some years now for an
early version of MCP that would justify a simulator for
the B6500/B6700, but so far nothing has turned up.
simulating a Burroughs B6700 system? (archived thread from comp.sys.unisys)

One interesting piece of software for the B5500 that has
been preserved and transcribed is a 6500 simulator that ran
on the 5500 and was used by Burroughs to develop the initial
version of MCP for the 6500. We also have the “MCP 0.0” that
ran on the simulator, and the B6500 Espol implementation compiler
(the cross-compiler that ran on the B5500, and that has already
successfully compiled MCP 0.0 on retro-B5500). However, to date
no one (as far as I know) has yet attempted to actually run
the 6500 simulator on retro-B5500 (or even quite knows how to
do so).

There’s a short film about the development of
the B6500 on YouTube:

1969 Burroughs B6500 Computer Vintage Mainframe History
(UNISYS, Data Processing, Pasadena))
Jul 5, 2016
Computer History Archives Project


What happened with the [link rejected] failed links? Only two links seem to have made it…

Oh dear, I think that’s a technical measure, that very new users can only post limited numbers of links. @Jim_F please keep hold of those valuable links! If you send them to me in a PM I can (probably) edit them into your post.

Well, any links I attempted to provide in the original
post were there simply for the convenience of the
reader. There’s enough context so that anybody who
is really interested can use Google to find the
relevant Web pages.

Here’s one, though, for the retroComputing Tasmania page
on the B6700:


Thanks @Jim_F for the extra link - also, you’re right, I was readily able to supply the missing links from your post.

1 Like

For anyone interested, I uploaded a brochure for the B1700 system a while back to my website : Burroughs B1700 Systems - Classic Computer Brochures

If you want to view future uploaded Burroughs brochures you can follow this link : burroughs Archives - Classic Computer Brochures


Thanks for putting up and maintaining that website!

All from my personal physical collection and scans :slight_smile: A whole pile to scan still, I think there are some more Burroughs brochures included to be scanned.

1 Like

Thanks! Back in 2019 I studied what material I could find about the B1700 and exchanged some emails with some people who had used it in the 1970s. But I focused on the technical side and detailed internal architecture. It was fun to see a different side of it in this brochure. None of the technical papers mentioned that the operating system was MCP, for example. Though the brochure is vague enough that I can’t tell how closely related this is to the B6700 (and friends) MCP.

According to Barbara Liskov, she used Lisp on a Burroughs B5-something while at Stanford. It seems likely to have been the one in Pine Hall:

I found this B5500-software/LISP-Fort-Monmouth at master · retro-software/B5500-software · GitHub, but I don’t know if there’s any connection to Stanford.

The only thesis I paid to get a copy of was a Lisp for the Burroughs 6700. It was a waste of my money. The guy was too interested in the original Lisp paper and M notation and everything was far more complicated than it had to be. At least I learned a little more about the Burroughs large systems than I knew before.

The title of the master’s thesis was “LISP 1.5 E UMA IMPLEMENTACAO NO SISTEMA B-6700” by Siang Wun Song, 1975, University of São Paulo.

Not very close. There were similarities in terms of ease of use and ease of administration. All of the major Burroughs systems of that time, the “Large Systems” (B6x00/7x00), “Medium Systems” (B2x00/3x00/4x00), and “Small Systems” (B1x00), where x is (5…9), had operating systems named “MCP,” but they were all completely different implementations with no common code base at all.

The system at Stanford was a B5000, later updated (as were all B5000s) to a B5500. It’s likely the LISP version used at Stanford was the one from Ft. Monmouth – this stuff was passed around pretty freely among the user base. The transcription cited was done from a listing on bitsavers.org that originally came from the University of California at Santa Cruz

Another possibility was GTL (Georgia Tech Language), which was available in the CUBE (Burroughs user association) library. That was a procedural language, but had some LISP-2 features. Documentation here.

The Lisp I used on the B6700 was REDUCE which included a symbolic integration and differentiation package and used an Algol style syntax instead of the traditional S-Expressions.

This was in 1982. It worked really well.

1 Like

I also have someones (Dutch) complete course with notes for the Burroughs B2000 system. All held together with two thick bolts :slight_smile: (does the job well as there probably weren’t any official binders thick enough).

Great information, thank you!

REDUCE sounded familiar, so I went looking. The source code still exists – it was on a tape from 1986 for a Burroughs math/statistics collection called “SL2200” that I help a colleague recover several years ago. The installation document for REDUCE2LISP from that tape says this in part:

The system provided has three REDUCE programs: LISP, REDUCE itself, and
INTEGRATOR which includes REDUCE as a subset. It is assumed that the
reader has read:
both of which are available from the Higher Education Software Library
(and also from the Computer Science department at the University of

The REDUCE system for the B7000/B6000 series consists of four parts: The
REDUCE algebraic processor itself, a LISP processor, a LISP compiler
which converts LISP programs to an intermediate language, and an
assembler which converts the intermediate language to Burroughs ALGOL.
The INTEGRATOR has a fifth part which is the integrator package.

The algebraic processor, the compiler, the assembler and the integrator
package are written in RLISP, a sort of LISP with ALGOL-like syntax.
The LISP processor is written partly in ALGOL and partly in RLISP. All
these parts are combined into a single large ALGOL program. The parts
written in RLISP must first be translated to ALGOL. The algebraic
processor does this translation.

The algebraic processor was largely written by Anthony Hearn, the
compiler is the work of Anthony Hearn and Martin Griss, the assembler
was done by John Fitch, the part of the LISP processor written in RLISP
was done by John Fitch and Jed Marti. The integration package was
developed at Cambridge by Arthur Norman, John Fitch, and Maryann Moore.
The ALGOL portion of the LISP processor, originally an SDL program for
the B1700 that was written by Fitch and Marti, was translated to ALGOL
and subsequently modified by Dave Dahm.

REDUCE is still around, having become open source in 2008. I found a later manual for REDUCE (version 3.8) and one for Standard LISP on that web site.

It would probably not be all that difficult to get this package running on modern Unisys MCP systems, which are the current descendants of the B6x00/7x00 and A Series systems. I can make the source code available as Windows text files or an MCP-compatible “wrapped container” to anyone who may be interested.


Great job digging up all this information!

The project I used REDUCE for on the B6900 (just upgraded from a B6700) in 1982 was the development of a giant robot arm. They wanted to control it by doing all the physics calculations (open loop control - a bad idea) and the equations soon became absurdly complicated. My job was to have REDUCE simplify the result of subtracting one equation of one step from the next, If REDUCE simplified that to zero then no mistakes had been made. I can’t say I understood the equations myself.

A bit similar to REDUCE was MuMath, which was written in MuLisp and could run on 8 bit microcomputers.

1 Like

From that site, a nice retrospective, in just 6 pages of PDF:
REDUCE: The First Forty Years

The development of this program began over forty years ago. We shall discuss the design decisions that have influenced its long-term survival, and the way in which the program has evolved with time.

A new professor in the Stanford Computer Science Department, John McCarthy, gave a talk in the Physics Department proposing his computer language Lisp as the basis for nonnumerical calculations in physics. I was out of town, and therefore missed this talk. However, a colleague, knowing of my interest in automating Feynman diagram calculations, suggested I talk to McCarthy about his work. To cut a long story short, McCarthy convinced me that his language would be a suitable basis for such calculations. Part of his efforts to convince me included the offer of free access to a new computer he was acquiring. In those days, getting computer access was not a trivial thing. Computers at that time were expensive with limited access, so such an offer was irresistible! Thus began my work in symbolic computation.

REDUCE 2 first appeared in 1970. The big change in this release was that the whole system was written in an Algol-like dialect, RLISP, rather than in the rather awkward parenthesized notation of Lisp used for the original REDUCE.