Sometimes, you wake up in the morning, check your RSS feeds, and you know you just hit the jackpot. From the AT&T archives comes a video and description of Blit, a UNIX graphical user interface from 1982, on a 800×1024 portrait display. It employs a three button mouse, right-click context menus, multiple windows, and lots, lots more. It was developed at Bell Labs, and is yet another case that illustrates how the technology industry doesn’t work in a vacuum.
Blit isn’t content with just being a graphical user interface with multiple windows and right-click context menus. The windows can also overlap, and the system employs, true to its UNIX base, full multitasking. The video below demonstrates how you could edit code in a text editor, switch to a different windowed terminal and execute
make, and play Asteroid in another overlapping window while the code compiled. Further along the video, it shows an application for integrated circuit design with a debugger running in a separate window.
It ran on a Motorola MC68000 processor in 1982, but would be ported to the Western Electric WE32000 microprocessor so it could be used on commercially available machines like the AT&T 5620 starting in 1984. It was created by Rob Pike and Bart Locanthi, and detailed in this paper on the subject. For instance, this is how windows (or layers, as they call them) were implemented:
The operating system is structured around asynchronous overlapping windows, called layers. Layers extend the idea of a bitmap and the bitblt operator to overlapping areas of the display, so a program may draw in its portion of the screen independently of other programs sharing the display. The Blit screen is therefore much like a set of truly independent, asynchronously updated terminals. This structure nicely complements the multiprogramming capabilities of Unix, and has led to some new insights about multiprogramming environments.
Interestingly enough, the goal behind creating Blit was to make graphical user interfaces run on less powerful, cheaper hardware than the Alto. “The original idea behind the development of the Blit hardware was to provide a graphics machine with about the power of the Xerox Alto, but using 1981 technology (large address space microprocessors, 64K RAMs and programmed array logic) to keep size, complexity and particularly cost much lower,” the paper notes. This may remind you of some other projects developed at around the same timeframe – you know, independent groups coming to the same conclusions because they’re working in the same constraints set by available hard and software.
The Blit was connected to a timeshared host through RS-232, but this wasn’t a big problem due to its relatively powerful hardware. It was also small and “portable”, and could even be used on 1200 baud connections from the engineers’ own homes; not as smoothly as on higher-speed connections, of course, but “a Blit at 1200 baud is much nicer than a regular terminal at 1200 baud”.
Despite being a relatively early graphical user interface, it already sports some interesting ideas. For instance, inactive windows receive a dotted texture to indicate they are not the currently selected window. Furthermore, Blit doesn’t have focus-follows-mouse:
One decision which differs from the usual, but in which we are on firmer ground, is our requirement that a mouse button hit changes the current layer. In most systems, the location of the mouse defines the current window, but when the current window may be partially or even wholly obscured, this is unworkable.
The conventions around mouse operations are also incredibly fascinating. Blit uses a three-button mouse, set to the following conventions:
The mouse has three buttons, and the Blit software maintains a convention about what the buttons do. The left button is used for pointing. The right button is for global operations, accessed through a menu that appears when the button is depressed and makes a selection when the button is lifted. The middle button is for local operations such as editing; a simple view of the situation is that the right button changes the position of objects on the screen and the middle button their contents. For example, pointing at a non-current layer and clicking the left button makes that layer current. Pointing outside the current layer and pushing the right button presents a menu with entries for creating, deleting and rearranging layers. Clicking a button while pointing at the current layer invokes whatever function the process in that layer has bound to the button; the next section discusses a couple of programs and how they use the mouse.
The mouse cursor is modal; it will change its appearance depending on the actions one can perform. “For example, when the user selects New on the
mpxterm menu, the cursor switches to an outlined rectangle with an arrow, indicating that the user should define the size of the layer to be created by sweeping the screen area out with the mouse,” the paper explains, “Similarly, a user who has selected the Exit menu entry is warned by a skull-and-crossbones cursor that confirmation is required before that potentially dangerous operation will be executed.”
There’s a whole boatload of interesting stuff in the paper about Blit, and it’s definitely recommended reading – easy to read, too. There’s also a detailed FAQ on the AT&T 5620, the commercially available machine from 1984 which ran Blit.
This is once again more proof that the industry heavily studied, implemented, and experimented on graphical user interfaces in the ’70s and early ’80s. It also shows that, unlike what some want you to believe, it wasn’t just one company that saw the value in bringing the graphical user interface to the masses – even UNIX people at Bell Labs saw its potential and ran with it. You wouldn’t believe it from reading about entitled corporations competing in courtrooms, but it almost seems like this is how the technology industry has always worked.
Truly fascinating stuff, and you owe it to yourself to dive into it.