Bringing the Wonder of the 1970s to Life

A story about the process of reviving and launching in an emulator another legendary system that existed before I was born and was never officially supplied to the USSR. As a bonus, there will be a Pascal compiler from the distant 70s.

Story

Let's start with a short excursion into history:

PERQ (also known as Three Rivers PERQ or ICL PERQ) — computer workstationwhich was released at the beginning 1980s years.

The workstation was conceived by five graduates and employees Carnegie Mellon Universitywho organized the company in 1974 Three Rivers Computer Corporation (3RCC) One of the founders, Brian Rosen, also worked at Xerox PARC above the workstation Dolphin. The PERQ project was inspired by the original workstation Xerox Altoand was the first commercially produced personal workstation. A prototype was shown at a conference SIGGRAPH in 1979. The name “PERQ” comes from the word “perquisite” (rus. extra income, additional earnings).[1]

Of course, it will arouse great interest first of all hardware:

CPU PERQ was implemented as microprogrammable discrete logic rather than microprocessorIt was based on separate ALU 74181 and address controller Am2910. The PERQ processor was unusual in that it had 20-bit registers and a writable control code store (WCS), which allowed the firmware to be changed.^[3] The central processor had a micro-instruction execution cycle of 170 ns (5.88 MHz).^[4]

Such systems were not supplied to the USSR, so most likely neither you nor your parents had the opportunity to see all this beauty in person.

A short video from those years demonstrating the workstation and its interface:

And this is what the Perq emulator looks like in a modern environment:

For comparison, here is a rare color photo of this workstation in real life:

And in the advertising of those years:

Emulator

It all started when I accidentally stumbled upon article about this amazing system, in which something completely incredible was discovered:

Just when I was thinking there was no hope of me ever seeing the Perq software in action, Josh Dersch has created a Perq emulator! Give this guy a medal!

One of the former users was able to implement a full-fledged emulator for such a unique system from the 70s!

True, with a broken download link and already a bit abandoned, but it was at least something to start from. Further search led to github author, from where the original source code was downloaded.

The emulator is written in C# for the old 3.5 version of the .NET Framework, but can still be built under modern versions of Windows.

In the case of Linux, things are not so simple:

Although the emulator had support for building with Mono, active development of Mono itself has ceased and its builds are gradually disappearing from distributions.

Instead of Mono, now it is being promoted .NET Corewhich is being developed by Microsoft itself with official support for key Linux and MacOS distributions (in addition to Windows).

Unfortunately, .NET Core is very different from previous versions and has compatibility issues – in the official words of Microsoft itself:

Your project needs to be ported from “.NET Framework” to “.NET Core” for normal operation and further development.

So I took the liberty of porting the emulator project to “.NET Core 7”, which is now quite good is going to and it even works under FreeBSD – that's how far progress has come!

The porting process was not particularly difficult, but since the project is very specific, a description of the porting process is unlikely to be of interest to the general public, so I did not describe this part.

All steps, although performed on FreeBSD, can be repeated under any Linux, MacOS and even Windows.

Assembly

Let's grab the source code from the Github repository:

git clone https://github.com/alex0x08/PERQemu.git

Then we install the packages using nuget:

cd /opt/src/PERQemu
/opt/app/dotnet/dotnet restore

.NET Core is deployed to the /opt/app/dotnet directory, the second dotnet in the path – the executable file itself, which launches both the emulator itself and its assembly.

If everything went well, at the very end the message “All projects are up-to-date for restore” will appear:

Now we start building the emulator:

/opt/app/dotnet/dotnet build

If the build was successful, there should be a message at the end saying “0 Error (s)”:

The directory “bin/Debug/net7.0/PERQemu” will contain the emulator assembled and ready to use.

Launch

The launch is carried out as follows:

alex@albuquerque:/opt/src/PERQemu/PERQemu % /opt/app/dotnet/dotnet run bin/Debug/net7.0/PERQemu

You need to launch it from the directory with the emulator project, specifying the relative path to the binary compiled above.

The launch result will surprise you a little:

The emulator produces such effects in the original version, so I left them as is – for history. In addition to the window with special effects, an interactive shell will appear, in which you need to enter commands to control the emulator.

First of all, you need to download the disk image, enter:

load harddisk Disks/f1.phd

Then you need to run the emulation:

go

The loading will begin and instead of special effects the world's first commercial graphical interface will appear.

With a mouse.

This is what the entire process of launching the PERQ emulator looks like, recorded on video:

Of course, I couldn’t help but share with readers what the most looks like stylish the compilation process on all seen:

Here is the entire process, recorded on video and saved for posterity:

Moreover, Pascal serves as the main development language in Perq:

The original PERQ command system is similar to p-code (called Q-Code) has been optimized for Pascal (especially the extended PERQ Pascal). Q-Code commands could be executed at speeds up to 1 million commands per second.^[12] This gave rise to an alternative abbreviation for the name PERQ: Pascal Evaluation Real Quick.

I managed to find development guide from 1984 for this rare system, which included source code examples that were remarkably similar to my school Turbo Pascal from the early 90s:

How about this, for example:

RS232 (the same “COM port” for users) turns out to have a very long history of use – the document above was printed for 20 years before my school years when we used RS232 and null modem connections to play Doom on the school computers.

In short, I am once again convinced that all the well-known, obvious and popular things in IT have a long and complicated history, which few ordinary users know about.

If any of the readers have encountered such machines, please respond, I am very interested in your experience, without which not much can be done with the emulated system.

This is a slightly edited and edited version of the article, original which was published on LORE and is available on our blog.

0x08 Software

We are a small team of IT industry veterans, we create and refine a wide variety of software, our software automates business processes on three continents, in a wide variety of industries and conditions.

Bringing it to life long dead, we fix what never worked and we create impossible — then we talk about it in our articles.