Star History and Development
In 1981, Xerox released the Xerox 8010 Information System
(codenamed “Dandelion” during development) and commonly referred to as the
Star. The Star took what Xerox learned from the research and experimentation
done with the Alto at Xerox PARC and attempted to build a commercial product
from it. It was envisioned as center
point of the office of the future, combining high-resolution graphics with the
now-familiar mouse, Ethernet networking for sharing and collaborating, and
Xerox’s Laser Printer technology for faithful “WYSIWYG” document reproduction. The Star’s operating system (called “Star” at
the outset, though later renamed “Viewpoint”) introduced the Desktop Metaphor
to the world. In combination with the
Star’s unique keyboard it provided a flexible, intuitive environment for creating
and collaborating on documents and mail in a networked office environment.
Xerox later sold the Star hardware as the “Xerox 1108
Scientific Information Processor” – In this form it competed with Lisp
workstations from Symbolics, LMI, and Texas Instruments in the burgeoning AI
workstation market and while it wasn’t quite as powerful as any of their
offerings it was considerably more affordable – and sometimes much smaller. (The Symbolics 3600 workstation, c. 1983 was
the size of a refrigerator and cost over $100,000).
The Star never sold well – it was expensive ($16,500 for a single workstation and most offices would need far more than just one) and despite being flexible and powerful, it was also quite slow. Unlike the IBM PC, which also made its debut in 1981 and would eventually sell millions, Xerox ended up selling somewhere in the neighborhood of 25,000 systems, making the task of finding a working Star a challenge these days.
Given its history and relationship to the Alto, the Star seemed appropriate for my next emulation project. (You can find the Alto emulator, ContrAlto, here). As with the Alto a substantial amount of detailed hardware documentation had been preserved and archived, making it possible to learn about the machine’s inner workings… except in a few rather important places:
Fortunately, Al Kossow at Bitsavers was able to provide extra documentation that filled in most of the holes. Cross-referencing all of this with the available schematics, it looked like there was enough information to make the project possible.
The Dandelion Hardware
Much like the Alto, the Dandelion’s Central Processor (referred to as the “CP”) is microcoded, and, again like the Alto, this microcode is responsible for controlling various peripherals, including the display, Ethernet, and hard drive. The CP is also responsible for executing bytecode macroinstructions. These macroinstructions are what the Star’s user programs and operating systems are actually compiled to. The CP is sometimes referred to as the “Mesa” processor because it was designed to efficiently execute Mesa bytecodes, but it was in no way limited to implementing just the Mesa instruction set: The Interlisp-D and Smalltalk systems defined their own microcode for executing their own bytecodes, custom-tailored and optimized to their environments.
Mesa was a strongly-typed “high-level language.” (Xerox hackers loved their puns…) It originated on the Alto but quickly grew too large for it (a smaller, stripped-down Mesa called “Butte” (i.e. “a small Mesa”) existed for the Alto but was still fairly unwieldy.) The Star’s primary operating system was written in Mesa, which allowed a set of very sophisticated tools to be developed in a relatively short period of time.
The Star architecture offloaded the control of lower-speed devices (the keyboard and mouse, serial ports, and the floppy drive) to an 8-bit Intel 8085-based I/O processor board, referred to as the IOP. The IOP is responsible for booting the system: it runs basic diagnostics, loads microcode into the Central Processor and starts it running. Once the CP is running, it takes over and works in tandem with the IOP.
Since the IOP brings the whole system up, it seemed that the IOP was the logical place to begin implementing the emulator. I started with an emulation of the 8085 processor and hooked up the IOP ROMs and RAMs. Since the first thing the IOP does at power up or reset is execute a vigorous set of self-tests, the IOP was, in effect, testing my work as I progressed which was extremely helpful. This is one important lesson Xerox learned from the Alto and applied to the Star: on-board diagnostics are a good thing. The Alto had no diagnostic facilities built in so if anything failed that prevented the system from running the only way to determine the fault was to get out the oscilloscope and the schematics and start probing. On the Star, diagnostics and status are reported through a 4-digit LED display, the “Maintenance Panel” (or MP for short). If the IOP finds a fault during testing, it presents a series of codes on this panel. During a normal system boot, various codes are displayed to indicate progress. The MP was the first I/O device I emulated on the IOP, for obvious reasons.
Development on the IOP progressed nicely for several weeks (and the codes reported in the emulated MP kept increasing, reflecting my progress in a quantitative way) and during this time I implemented a source-level debugger for the IOP’s 8085 code to help me along. This was invaluable in working out what the IOP was trying to do and why it was failing to do so. It allowed me to step through the original code, place breakpoints, and investigate the contents of the IOP’s registers and memory while the emulated system was running.
Once the IOP self-tests were passing, the IOP emulation was
running to the point where it attempted to actually boot the Central
Processor! This meant I had to shift
gears and switch over to implementing an emulation of the CP and make it talk
to the IOP. This is where the real fun began.
For the next couple of months I hunkered down and implemented a rough emulation of the CP, starting with system’s 16-bit ALU (implemented with four 4-bit AM2901 ALU chips chained together). The 2901 (see top portion of the following diagram) forms the nexus of the processor; in addition to providing the processor’s 16 registers and basic arithmetic and logical operations, it is the primary data path between the “X bus” and “Y bus.” The X Bus provides inputs to the ALU from various sources: I/O devices, main memory, a handful of special-purpose register files and the Mesa stack and bytecode buffer. The ALU’s output connects to the Y bus, providing inputs back into these same components.
One of the major issues I was confronted with nearly immediately when writing the CP emulation was one of fidelity: how faithful to the hardware does this emulation need to be? This issue arose specifically because of two hardware details related to the ALU and its inputs:
- The AM2901 ALU has a set of flags that get raised based on the result of an ALU operation (for example, the “Carry” flag gets raised if the result of an operation causes a carry out from the most-significant bits). For arithmetic operations these flags make sense but the 2901 also sets these flags as the result of logical operations. The meaning of the flags in these cases is opaque and of no real use to programmers (what does it mean for a “carry” flag to be set as a result of a logical OR?) and exist only as a side-effect of the ALU’s internal logic. But they are documented in the spec sheet (see the picture below).
- With a 137ns clock cycle time, the CP pushes the underlying hardware to its limits. As a result, some combinations of input sources requested by a microinstruction will not produce valid results because the data simply cannot all make it to its destination on time. Some combinations will produce garbage in all bits, but some will be correct only in the lower nibble or byte of the result, with the upper bits being undefined. (This is due to the ALU in the CP being comprised of four 4-bit ALUs chained together.)
I spent a good deal of time pondering and experimenting. For #1, I decided to implement my ALU emulation with the assumption that Xerox’s microcode would not make use of the condition flags for non-arithmetic operations, as I could see no reason to make use of them for logical ops and implementing the equations for all of them would be computationally expensive, making the emulation slower. This ended up being a valid assumption for all logical ops except for OR — as it turns out, some microcode assumed that the Carry flag would be set appropriately for this class of operation. When this issue was found, I added the appropriate operations to my ALU implementation.
For #2 I assumed that if Xerox’s microcode made use of any “invalid” combinations of input sources, that it wouldn’t depend on the garbage portion of the results. (That is, if code made use of microinstructions that would only produce valid results in the lower 4 or 8 bits, the microcode would also only depend on the lower 4 or 8 bits generated.) Thus the emulated ALU always produces a complete, correct result across all 16-bits regardless of input source. This assumption appears to have held — I have encountered no real-world microcode that makes assumptions about undefined results thus far.
The above compromises were made for reasons of implementation simplicity and efficiency. The downside is that it is possible to write microcode that will behave differently on the emulation than on the real hardware. However, going through the time, trouble, and expense of a 100% accurate emulation did not seem worth it when no real microcode would ever require this level of accuracy. Emulation is full of trade-offs like this. It would be great to provide an emulation that is perfect in every respect, but sometimes compromises must be made.
I implemented a debugger and disassembler for the CP similar to the one I put together when emulating the IOP. Emulation of the various X bus-related registers and devices followed, and slowly but surely the CP started passing boot diagnostics as I fixed bugs and implemented missing hardware. Finally it reached the point where it moved from the diagnostic stage to executing the first Mesa bytecodes of the operating system – the Star was now executing real code! At that time it seemed appropriate to implement the Star’s display controller so I could see what the Star was trying to tell me – and a few days and much debugging of the central processor later I was greeted with this display from the install floppy (and there was much rejoicing):
Following this I spent two weeks of late nights hacking — implementing the hard disk controller and fixing bugs. The Star’s hard drive controller doesn’t use an off-the-shelf controller chip as this wasn’t an option at the time the Star was being developed in the late 1970s. It’s a very clever, minimal design with most of the heavy lifting being done in microcode rather than hardware. Thus the emulation has to work at a very low level, simulating (in a sense) the rotation of the platters and providing data from the disk as it moves under the heads, one word at a time (and at just the right time.)
During this period I also got to learn how Xerox’s hard disk formatting and diagnostic tools worked. This involved some reverse engineering: Xerox didn’t want end-users to be able to do destructive things with their hard disks so these tools were password protected. If you needed your drive reformatted you called a Xerox service engineer and they came out to take care of it (for a minor service charge). These days, these service engineers are in short supply for some reason.
Luckily, the passcodes are stored in plaintext on the floppy disk so they were easy to unearth. For future reference, the password is “wizard” or “elf” (if you’re so inclined):
Having solved The Mystery of the Missing Passwords I was at last able to format a virtual hard disk and install Viewpoint, and after waiting nervously for the installation to finish I was rewarded with:
Everything looked good, until the hard disk immediately corrupted itself and the system crashed! It was very encouraging to see a real operating system running (or nearly so), and over the following weeks I hammered out the remaining issues and started on a design for a real user interface for the emulator.
I gave it a name: Darkstar. It starts with a “D” (thus falling in line with the rest of the “D-Machines” produced by Xerox) contains “Star” in the name, and is also a nerdy reference to a cult-classic sci-fi film. Perfect.
Darkstar is available for download on our Github site and is open source under the BSD 2-Clause license. It runs on Windows and on Unix systems using the Mono runtime. It is still very much a work in progress. Feedback, bug reports, and contributions are always welcome.
Fun with the Star
You’ve downloaded and installed Darkstar and have perused
the documentation – now what? Darkstar
doesn’t come with any Xerox software, but pre-built hard disk images are
available on Bitsavers
(and for the more adventurous among you, piles of floppy disk images are available
if you want to install something yourself).
— this contains hard disk images for Viewpoint 2.0, XDE 5.0, and The Harmony
release of Interlisp-D.
You’ll probably want to start with Viewpoint; it’s the crowning achievement of the Star and it invented the desktop metaphor, with icons representing documents and folders.
To boot Viewpoint successfully you will need to set the emulated Star’s time and date appropriately – Xerox imposed a very strict licensing scheme (referred to as Product Factoring) typically with licenses that expired monthly. Without a valid license code, Viewpoint grants users a 6-day grace period, after which all programs are deactivated.
Since this is an emulation, we can control everything about the system so we can tell the emulated Star that it’s always just a few hours after the installation took place, bypassing the grace period expiration and allowing you to play with Viewpoint for as long as you like. Set the date to Nov. 10, 1990 and start the system running.
Now wait. The system
is running diagnostics.
Viewpoint is loading.
Go get a coffee.
Seriously, it takes a while for Viewpoint to start up. Xerox didn’t intend for users to reboot their
Stars very often, apparently. Once everything
is loaded a graphic of a keyboard will start bouncing around the screen:
Press any key or click the mouse to get started and you will be presented with the Viewpoint Logon Option Sheet:
You can login with user name “user” with password
“password”. Hit the “Next” key (mapped
to “Home” on your computer’s keyboard) to move between fields, or use the mouse
to click in them. Click on the “Start”
button to log in and in a few moments, there you are:
The world is your oyster. Some things work as you expect – click on things to select them, double-click to open them. Some things work a little differently – you can’t drag icons around with the mouse as you might expect: if you want to move them, use the “Move” key (F6) on your keyboard; if you want to copy them, use the “Copy” key (F4). These two keys apply to most objects in the system: files, folders, graphical objects, you name it. The Star made excellent use of the mouse, but it was also very keyboard-centric and employed a keyboard designed to work efficiently with the operating system and tools. Documentation for the system is available online – check out the PDFs at http://bitsavers.org/pdf/xerox/viewpoint/VP_2.0/, as they’re worth a read to familiarize yourself with the system.
If you want to write a new document, you can open up the
“Blank Document” icon, click the “Edit” button and start writing your magnum
One can change text and paragraph properties – font type,
size, weight and all other sorts of groovy things by selecting text with the
mouse (use the left mouse to select the starting point, and the right to define
the end) and pressing the “Prop’s” key (F8):
If you’re an artist or just want to pretend that you are one,
open up the “Blank Canvas” icon on the desktop:
Need to do some quick calculations? Check out the Calculator accessory:
There are of course many more things that can be done with Viewpoint, far too many to cover here. Check out the extensive documentation as linked previously, and also look at the online training and help available from within Viewpoint itself (check the “Help” tab in the upper-right corner.)
Viewpoint is only one of a handful of systems that can be run on Darkstar. Stay tuned for future installments, covering XDE and Interlisp-D!