MUSS Source Code


MUSS is the Manchester University Software System. It is an operating system that was designed and built at Manchester University for MU5, designed to be portable, and in fact ported to other machines.

In October 2017 I asked the editor of Resurrection, the Computer Conservation Society’s publication, to publish an appeal for information relating to MU5 to help my emulation project. Then, in December 2017 I received a response from Eur Ing Brian Tompsett a lecturer at Hull University. He had a full set of printed MUSS documentation and a 9-track magnetic tape which he thought may have the same documentation on it. The interesting thing about MUSS documentation is that it is really a combination of documentation and code, written using a system called Flocoder. This meant that there may be machine-readable source code on the magnetic tape. However,  Brian Tompsett thought that the tape may only contain the portable parts of the sources from the post MU5 era, covering MU6G, PDP11, VAX11 and MC68000. This also ties in with the printed documentation I have seen in a store room at Manchester, which all seems to be post MU5.

In April 2018 one of Brian Tompsett’s tapes was sent to The National Museum of Computing in Bletchley Park, where Delwyn Holroyd read the tape successfully a week ago. It contained a tar file, inside which were a large number of documentation and source code files.

The tape appears to contain the source code for Flocoder, the Manchester University system implementation language (MUSL) compiler, large parts of Version 11 of MUSS itself and other compilers, including Fortran and Cobol compilers that Brian Tompsett wrote. I am waiting for permission from Manchester University and then I hope to post the files, possibly on GitHub.

It looks like the best approach is going to be to hand build a processor to implement the Flocoder FLIP (Form LInear Program) function to extract the MUSL from the documentation, and then build a MUSL compiler, which will allow me to bootstrap the building of MUSS. It looks like it may be possible to get MUSS built for PDP-11 and VAX.

This entry was posted in MUSS, Retro-Computing. Bookmark the permalink.

5 Responses to MUSS Source Code

  1. Professor Greg Egan says:

    A fantastic result. Getting it to gitHub and other places is VERY good idea.


    Sent from my iPhone


  2. Prof Greg Egan says:

    Fantastic :).

  3. John says:

    Ah, Flocoder. I remember it well! I used it extensively from summer 1979 to summer 1981. The text file contained the layout of the flowcharts, the English text for each box and the code for each box in one or more languages. Each box could have different ‘levels’ defined. Level 0 was usually the English text and the other levels were for the code. FLIP was used to produce the code for a particular level that could then be used as input to the compiler/assembler. FLIP also inserted into the code the labels for ‘goto’, ‘if’ etc. So that if the layout of the flowchart was changed, the generated code reflected this. One downside, however, was that the language(s) used had to support labels, ‘goto a label’ and conditional statements that branched to a label – without the label name having previously been defined as a label. This was great for assembler code, Fortran, MUSL/MUPL etc but no good for languages such as Pascal. I spent some fruitless time summer 1979 trying to coax it to produce compilable Pascal code – butt to no avail. At the time, Pascal was the main language used by undergraduates (although Fortran 77, Cobol and Algol 68 were also taught).
    DRAW was used to produce the flowcharts with all the boxes nicely connected by lines. For complicated charts it was a matter of some skill and experience to get the flowchart to draw properly without crossed lines etc. The DRAW program was quite ‘intelligent’ in that respect but by no means infallible and manual layouts had to be tweaked by moving boxes among the rows and columns to get the required clean chart. When I first used Flocoder, DRAW actually produced a paper-tape which then had to be taken to the PDP-8 computer to which was attached a plotter. You inserted the paper-tape, set up the PDP-8 and then came back a couple of hours latter and hoped to find your flowcharts – if the paper-tape hadn’t broken or snagged! Of course, you often found that it was already in use by someone else and had to wait (sometimes for hours or the next day). This system was replaced by a pen-plotter directly connected to the MU5 PDP-11 peripheral controller sometime I think early 1980 – so that DRAW could then send the flowcharts direct to the pen-plotter as outlined in the MUSS manual. This was much better as the work was simply queued and automatically plotted when it came to your turn. If I remember right, lecturers/researches got a higher priority and us others got a low priority. Ah, the late nights spent trying to get flowcharts!
    Implementing a version of FLIP in say c++ to produce compilable code from the Flocoder source text files shouldn’t be that difficult. If I remember right (and I’m hazy about this), the MUSL compiler for MU5 was first implemented in terms of MUPL and then implemented in MUSL itself so that it could compile itself. The MUSL compiler produced MUTL statements, but I think the MUPL compiler produced autocode for MU5 (or other processor direct language as required). MUSS for MU5 was originally written mainly in MUPL with some autocode (Gordon Frank).
    It would be great to have the source-code published on GitHub and to get a working MUSL PDP-11 compiler so that the great SIMH PDP-11 emulator could be used to bring MUSS back to life! I look forward to hearing about progress.

  4. Rob Turner says:

    Great to stumble across this. I worked on MUSS and MUSL with the OS team at UMIST (Derrick Morris, Roger Phillips, Colin Theaker, Willie Love et al) between 1987 and 1990. I remember Flocoder well, and the set of ring-bind folders containing the MUSS and MUSL source code drawn as flowcharts. I was a Computer Officer in charge of the student programming labs, and we had MUSS running on VME/10s, using Atari STs as terminals (so all 68000 systems). The students used a simplified point and click front end to MUSS that I was involved in porting to a SUN system, and I remember my first assignment was to add debugging symbols to compiled MUSL programs so that they could be debugged inside dbx on the SUN. I’ve always thought it would be great for nostalgic reasons to get a MUSS system up and running again, and have done a bit of browsing over the years to see if anything turned up, and there’s been nothing much until I just discovered this. (I also worked with Brian Tompsett at Hull University from 1990 to 1994. I’m not surprised at all that he had a tape!)

    • rjarratt says:

      Great to hear from you. I have what I think are binaries for the 68000 machines, but no machine to try them on. I would really like to get MUSS running on my MU5 emulator and that is still my main goal, and I have reached a point where I need to put some serious time into it and so my effort has faltered a little in the last couple of years, but I do still want to take this further.

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s