Hansen Hsu, Paul McJones
Revised 8 November 2023
A walk through the archive: software and
Graphics and Text for Cedar/Mesa
Imaging Science Laboratory Software
Databases, File Systems, and Client/Server Applications
Programming Languages other than Cedar/Mesa, Smalltalk, Lisp
More on the archive
Raw files: endianness
This archive is a collection of source code and digital text documents, image files, and other files from Xerox Palo Alto Research Center (PARC). This came from the same IFS backup file repositories that the earlier 2013 release of the Xerox Alto source code archive came from, and is a superset of that archive, containing files related to projects from the 1980s, up to 1994, that were not included there. Information pertaining only to Alto systems was covered on the previous Alto archive walkthrough and will be omitted here.
This walkthrough is intended to introduce the source code and
documentation newly made available and the projects they pertain
to: two different programming environments created at PARC: Cedar/Mesa,
and Interlisp, as well as applications
written on top of these various environments. These applications
include word processing, graphics, printing, client/server,
networking, email, calendar/reminders, music, math, AI, speech
recognition, help systems, interactive data analysis, UI design,
and hypertext. It also includes VLSI chip design tools, hardware
designs and microcode for the D series of computers that succeeded
An alternate view of this archive, which allows the viewer to
browse the archive directly from the root of each PARC IFS file
server, can be found at this index page.
The index page also contains some useful resources, including a link to a Cross-reference page that lists every filename and every directory in which the filename appears, along with metadata to differentiate files with the same name or different versions of the same file. (Warning: this page takes a long time to load.)
You can read more about the story of this digital archive, its preservation and recovery, and a sample of what interesting discoveries can be made in it at this blog post, "A Backup of Historical Proportions," by CHM curator David Brock.
Cedar was a further development of the Mesa programming language,
libraries, and integrated development environment. The Mesa
programming language was designed by Charles M. Geschke, Butler
Lampson, Jim Mitchell, James H. Morris, Jr., and Edwin H.
Satterthwaite, with contributions from Alan Kay, Charles Simonyi,
and John Wick. Mesa had a rich type system and strong type
checking, with syntax based on Pascal; its type system was
influenced by Pascal and Algol 68. Mesa supported modular
programming with separate interface and implementation modules,
features which in turn influenced Niklaus Wirth's Modula-2. Mesa
would also eventually influence the design of Java. Java’s threads
and exceptions can be traced back (via Modula-3, Modula-2+, and
Cedar/Mesa) to Mesa, though Mesa didn’t have objects (as did
Modula-3) or garbage collection (as did all three successor
More information about Mesa can be found on the original Xerox
Alto source code archive's Mesa section.
Cedar/Mesa was not just a language and a set of libraries but a
full integrated development environment (IDE) with its own
mouse-driven graphical user interface (GUI), that, although taking
some cues from Smalltalk's interface, also differed from it in
many ways. A demo of Cedar by PARC researcher Eric Bier, recorded
at the Computer History Museum, can be seen here.
One example is that Cedar does not support overlapping windows,
and text selection and copying is supported differently by the use
of the middle and right mouse buttons. Both code editing and
document preparation were done with Tioga, a WYSIWYG text editor
that, like Bravo, supported multiple fonts and styles. This meant
that source code could be rich text containing different fonts and
styles for different types of code.
Dennis Arnon et al., “CaminoReal: An Interactive Mathematical Notebook,” in Proceedings of the International Conference on Electronic Publishing on Document Manipulation and Typography (USA: Cambridge University Press, 1988), 1–18, https://dl.acm.org/doi/10.5555/51292.51293.
R. Atkinson et al., “Experiences Creating a Portable Cedar,” in Proceedings of the ACM SIGPLAN 1989 Conference on Programming Language Design and Implementation, PLDI ’89 (New York, NY, USA: Association for Computing Machinery, 1989), 322–29, https://doi.org/10.1145/73141.74847.
Richard Beach, “Experience with the Cedar Programming Environment for Computer Graphics Research,” in Proceedings of the Graphics Interface ’84, GI 1984 (Toronto, Ontario, Canada: National Research Council of Canada, 1984), 65–74, https://doi.org/10.20380/GI1984.12.
Eric A. Bier, “EmbeddedButtons: Supporting Buttons in Documents,” ACM Trans. Inf. Syst. 10, no. 4 (October 1992): 381–407, https://doi.org/10.1145/146486.146547.
Eric A. Bier and Maureen C. Stone, “Snap-Dragging,” in Proceedings of the 13th Annual Conference on Computer Graphics and Interactive Techniques, SIGGRAPH ’86 (New York, NY, USA: Association for Computing Machinery, 1986), 233–40, https://doi.org/10.1145/15922.15912.
M. Brown, K. Kolling, and E. Taft, “The Alpine File System,” Xerox PARC Technical Report CSL-84-4, October 1984, http://www.bitsavers.org/pdf/xerox/parc/techReports/CSL-84-4_The_Alpine_File_System.pdf.
Mark R. Brown, Roderic G. G. Cattell, and Norihisa Suzuki, “The Cedar DBMS: A Preliminary Report,” in Proceedings of the 1981 ACM SIGMOD International Conference on Management of Data, SIGMOD ’81 (New York, NY, USA: Association for Computing Machinery, 1981), 205–11, https://doi.org/10.1145/582318.582350.
L. Peter Deutsch and Edward A. Taft, “Requirements for an Experimental Programming Environment,” Xerox PARC Technical Report CSL-80-10, June 1980, http://www.bitsavers.org/pdf/xerox/parc/techReports/CSL-80-10_Requirements_for_an_Experimental_Programming_Environment.pdf.
James Donahue, “Integration Mechanisms in Cedar,” in Proceedings of the ACM SIGPLAN 85 Symposium on Language Issues in Programming Environments, SLIPE ’85 (New York, NY, USA: Association for Computing Machinery, 1985), 245–51, https://doi.org/10.1145/800225.806845.
James Donahue and Willie-Sue Orr, “Walnut: Storing Electronic Mail in a Database,” Xerox PARC Technical Report CSL-85-9, November 1985, http://www.bitsavers.org/pdf/xerox/parc/techReports/CSL-85-9_Walnut_Storing_Electronic_Mail_in_a_Database.pdf.
R. Hagmann, “Process Server: Sharing Processing Power in a Workstation Environment,” in ICDCS, 1986.
R. Hagmann, “Reimplementing the Cedar File System Using Logging and Group Commit,” in Proceedings of the Eleventh ACM Symposium on Operating Systems Principles, SOSP ’87 (New York, NY, USA: Association for Computing Machinery, 1987), 155–62, https://doi.org/10.1145/41457.37518.
Carl Hauser et al., “Using Threads in Interactive Systems: A Case Study,” in Proceedings of the Fourteenth ACM Symposium on Operating Systems Principles, SOSP ’93 (New York, NY, USA: Association for Computing Machinery, 1993), 94–105, https://doi.org/10.1145/168619.168627.
David Kurlander and Eric A. Bier, “Graphical Search and Replace,” in Proceedings of the 15th Annual Conference on Computer Graphics and Interactive Techniques, SIGGRAPH ’88 (New York, NY, USA: Association for Computing Machinery, 1988), 113–20, https://doi.org/10.1145/54852.378495.
Butler W. Lampson, “A Description of the Cedar Language: A Cedar Language Reference Manual,” Xerox PARC Technical Report CSL-83-15, December 1983, http://bwlampson.site/32a-CedarLang/32a-CedarLangAbstract.htm.
Butler W. Lampson et al., “The Dorado: A High-Performance Personal Computer: Three Papers,” Xerox PARC Technical Report CSL-81-1, January 1981, http://www.bitsavers.org/pdf/xerox/parc/techReports/CSL-81-1_The_Dorado_A_High-Performance_Personal_Computer_Three_Papers.pdf.
Butler W. Lampson and Eric E. Schmidt, “Organizing Software in a Distributed Environment,” in Proceedings of the 1983 ACM SIGPLAN Symposium on Programming Language Issues in Software Systems, SIGPLAN ’83 (New York, NY, USA: Association for Computing Machinery, 1983), 1–13, https://doi.org/10.1145/800226.806846.
Ken Pier, Eric Bier, and Maureen Stone, “An Introduction to Gargoyle: An Interactive Illustration Tool,” in Proceedings of the International Conference on Electronic Publishing on Document Manipulation and Typography (USA: Cambridge University Press, 1988), 223–38, https://www.computerhistory.org/collections/catalog/102653424.
Paul Rovner, “On Adding Garbage Collection and Runtime Types to a Strongly-Typed, Statically-Checked, Concurrent Language,” Xerox PARC Technical Report, CSL-84-7, July 1985), http://bitsavers.org/pdf/xerox/parc/techReports/CSL-84-7_On_Adding_Garbage_Collection_and_Runtime_Types_to_a_Strongly-Typed_Statically-Checked_Concurrent_Language.pdf.
Eric Emerson Schmidt, “Controlling Large Software Development In a Distributed Environment,” Xerox PARC Technical Report, CSL-82-7, December 1982), http://www.bitsavers.org/pdf/xerox/parc/techReports/CSL-82-7_Controlling_Large_Software_Development_In_a_Distributed_Environment.pdf.
Michael D. Schroeder, David K. Gifford, and Roger M. Needham, “A Caching File System for a Programmer’s Workstation,” in Proceedings of the Tenth ACM Symposium on Operating Systems Principles, SOSP ’85 (New York, NY, USA: Association for Computing Machinery, 1985), 25–34, https://doi.org/10.1145/323647.323632.
Daniel C. Swinehart et al., “A Structural View of the Cedar Programming Environment,” ACM Trans. Program. Lang. Syst. 8, no. 4 (August 1986): 419–90, https://doi.org/10.1145/6465.6466.
Daniel C. Swinehart, Polle T. Zellweger, and Robert B. Hagmann, “The Structure of Cedar,” in Proceedings of the ACM SIGPLAN 85 Symposium on Language Issues in Programming Environments, SLIPE ’85 (New York, NY, USA: Association for Computing Machinery, 1985), 230–44, https://doi.org/10.1145/800225.806844.
Warren Teitelman, “The Cedar Programming Environment: A Midterm Report and Examination,” Xerox PARC Technical Report, CSL-83-11, June 1984, http://www.bitsavers.org/pdf/xerox/parc/techReports/CSL-83-11_The_Cedar_Programming_Environment_A_Midterm_Report_and_Examination.pdf.
Warren Teitelman, “A Tour Through Cedar,” IEEE Transactions on Software Engineerin 11, no. 3 (March 1985): 285–302, https://doi.org/10.1109/MS.1984.234050.
Douglas B. Terry and Donald G. Baker, “Active Tioga Documents: An Exploration of Two Paradigms,” Electron. Publ. Origin. Dissem. Des. 3, no. 2 (April 1990): 105–22, https://www.computerhistory.org/collections/catalog/102786291.
John Warnock and Douglas K. Wyatt, “A Device Independent Graphics Imaging Model for Use with Raster Devices,” SIGGRAPH Comput. Graph. 16, no. 3 (July 1982): 313–19, https://doi.org/10.1145/965145.801297.
Cedar — starting 1984, programming environment based on
Cedar5.3 — 1986 release of Cedar
[indigo]<cedar>documentation>.Catalog.tioga!6.html>this is Cedar 5.0.
Cedar6.0 — 1986 release of Cedar
Cedar6.1 — 1987 release of Cedar
Cedar7.0 — 1989 release of Cedar, includes MakeBoot scripts (documentation: see http://www.bitsavers.org/pdf/xerox/parc/cedar/Cedar_7.0/), 1989
CedarChest6.0 — 1986 libraries/applications written in Cedar: Abutters, ACFind, AIS*, AlgebraStructures, AlpineBackup, AlpineServer, AlpineShared, AlpineUser, … MazeWar, … Summoner, Walnut … Yodel
CedarChest6.1 — 1986–1987 libraries/applications written in Cedar
CedarChest7.0 — 1987 libraries/applications written in Cedar,
CedarFonts — 1988–1989 fonts
CedarGraphics — 1988 low level graphics libraries for Cedar
CedarHacks5.2 — 1986 miscellaneous libraries/tools written in Cedar
CedarLang — 1988 Cedar Mesa compiler snapshot
CedarViewers — 1988 Cedar window system and graphical user interface libraries
Nucleus — 1986 snapshot of core component of Cedar (operating system, etc.) Includes Bringover, SModel, file system, LoadState, MakeBoot, MesaRuntime, Dialup, Networking, etc.
Controlling Large Software Development in a Distributed EnvironmentPostCedar5.2 — 1985/1986 snapshot of Cedar libraries, tools, etc.
Eric E. Schmidt [advisor: Robert S. Fabry]
U.C. Berkeley PhD thesis, 1982.
Organizing Software in a Distributed Environment
Butler W. Lampson and Eric E. Schmidt
Proc. 1983 ACM SIGPLAN Symposium on Programming Language Issues in Software Systems.
PreCedar — 1986 snapshot of Cedar tools — mostly MakeBoot and AMProcess — perhaps part of port to a new environment?
Trinity — 1986 release of Cedar compiler, binder, SafeStorage, and runtime modules.
UserExec — 1986 snapshot of Cedar User Executive component, including DWIM (do what I mean) functionality.
CD8/cedardocs/* — 1978–83 design documents, manuals, papers
CD8/cedarlib/* — 1979–86 Cedarnetexec and cedar floating point. Mesa code.
Bonsai2.0 — 1993–1994 Small version of Cedar built with Cedar-to-C translator
CedarCommon2.0 — 1992 collection of Cedar Mesa libraries
3DGraphics — 1990 libraries for 3D graphics
AIS — 1985 scanned image examples
AlgebraicSurfaces — 1990 for CedarChest6.1: James Rauen: Algebraic Surface Tool Interactive Rendering of Algebraic Surfaces
ArtWork — 1984 extension to Tioga editor for graphics, circa 1984
Gargoyle — 1987 illustration tool by Eric Bier and Ken Pier
Griffin — 1990 illustration tool by Maureen Stone
Imaging — 1986 projects of the Imaging Sciences Lab, project directory for Griffin, Gargoyle, etc.
Juno — 1985 Greg Nelson's two-view constraint-based drawing editor. Nelson moved from PARC to DEC SRC by 1985, and later did a follow-on at DEC SRC called Juno-2 with Allan Heydon.
Greg Nelson. 1985. Juno, a constraint-based graphics system. In Proceedings of the 12th annual conference on Computer graphics and interactive techniques (SIGGRAPH '85). Association for Computing Machinery, New York, NY, USA, 235–243. DOI:https://doi.org/10.1145/325334.325241Mesa — 1989–1990 snapshot of final Alto Mesa (Mesa 6.0?)
Solidviews — 1983–88 Eric Bier's 3D solid modeling system, documentation and sample pictures
Tex — 1985 MesaTex79 sources
Tioga — 1986 text editor
Tioga2 — 1988 later version of Tioga?
Whiteboard — 1986 whiteboard viewer
XPort — 1989 C-to-Mesa translator, X Windows System interface in Mesa
Straw — 1980 Mesa 6 system for manipulating Press files with a SIL-like editor by Joe Maleson
ISL — 1985 assortment of imaging/graphics libraries and tools
ISLCedar — 1985 assortment of imaging/graphics libraries — converted to Cedar Mesa?
JaM, for authors John Warnock and Martin
Newell (with contributions from Doug Wyatt), was an interpretive
language that could represent anything on a printed page in a
device-independent way, using an imaging model based on Bézier
curves. JaM would influence the later design of Interpress and
then Postscript. For more information on the development of
PostScript see Warnock's article "The Origins
of Postscript", see also
Brian Reid, "PostScript and Interpress: a comparison", LASER-LOVERS distribution list, March 1985.
JaM — 1988 John and Martin, the Postscript-like language
PreISL — 1985 various libraries and tools for images and typesetting
A good snapshot of the implementation may be located in
PreISLCedar — 1985 many libraries and tools, including mockingbird, juno, etc.
CaminoReal — 1990 A User Interface for Mathematics (Arnon, Waldspurger, McIsaac, Beach)
MathEditor — 1990
QuantifierElimination — 1990 Arnon: small package of i/o routines for quantifier elimination datatypes, to enable revival of Jim Rauen's Algebraic Surfaces package
MAXC was a timeshared mainframe, a PDP-10 clone running TENEX, the standard operating system used in the ARPA-funded computer science laboratories that PARC researchers came from, that engineers at the Computer Science Laboratory (CSL), led by Chuck Thacker, created in part because they were not allowed to purchase a DEC PDP-10, due to Xerox having recently acquired Max Palevsky's rival minicomputer maker SDS. The experience gained from building MAXC (pronounced "Max," as the 'C' was silent) was useful in the subsequent design of the Alto, which reused elements of the MAXC design and components, including the Intel 1103 DRAM chips. MAXC was later used as a server for Alto clients.
Maxc — 1985–86 diagnostics, microcode, operations memos for MAXC computer
Pup (PARC Universal Packet) was a set of internetworking protocols and packet format designed and first implemented (in BCPL) by David R. Boggs, John F. Shoch, Edward A. Taft, and Robert M. Metcalfe. It became a key influence on the later design of TCP/IP.
Pup — 1984–86 Pup implementation for Maxc
David R. Boggs, John F. Shoch, Edward A. Taft, and Robert M. Metcalfe. Pup: An Internetwork Architecture.
Other code for interfacing with the ARPANET and other network protocols is also included.
Arpanet — 1988 Mesa code to implement TCP/IP, etc, circa 1988
Portola — 1979–91 BCPL gateway code, documentation, configuration, etc. (Portola was one of the early Nova-based gateways)
PupGateway — 1986–88 Mesa code for gateway between XNS and Pup networks
NCP — 1989 Mesa code to interface with Arpanet
M. R. Brown, K. N. Kolling, and E. A. Taft. 1985. The Alpine file system. ACM Trans. Comput. Syst. 3, 4 (Nov. 1985), 261–293. DOI:https://doi.org/10.1145/6110.6111RAlpine — 1981-1987 Client access for Alpine File Server
Hickory — 1986 reminder and calendar system based on the Cypress database in Cedar
Grapevine — email server (also on CD8 in previous Alto source code release)
CD8/indigogv/* — 1981–85 Snapshot of Mesa source code for the Grapevine email/FTP system
CD8/indigoifs/* — 1981–85 Snapshot of IFS (Interim File Server) BCPL source code
Squirrel — 1986 Cedar database tool
Walnut — 1986 Cedar mail tool
Yggdrasil — 1988(?)–1990 large scale, persistent information storage server
The Alto "Interim" File Server (IFS) was designed and implemented by David R. Boggs and Ed Taft.
CD8/mockingbird/* — 1980–84 Music editor by John Maxwell and Severo Ornstein
http://hdl.handle.net/2027/spo.bbp2372.1981.052 or https://archive.org/details/byte-magazine-1984-01
Press was the Alto's device-independent print file format, designed by William Newman and Robert F. Sproull, extended by Joe Maleson for digitally sampled (scanned) images, which were printed via halftoning. Press files could specify mixtures of text, outline (vector) graphics, and bitmapped images on the same page. Applications such as word processors or paint programs would write Press files, which could then be sent to a number of different printers. For more information see Sproull's article The Xerox Alto Publishing Platform".
CedarPeach — 1990 Peach printer drivers for a few devices: inkjet?
CedarPrinter6.1 — 1987 Cedar print server
CedarPS — 1987 Cedar print server
FontWorld — 1990 font code (Mesa) and data by Michael Plass
Imager — 1990 Cedar library for image processing
InterpressDoc — 1990 mostly Gargoyle documents for figures for an Interpress book
InterpressSamples — 1990 mostly .ip (Interpress?) files
Press — 1990 original BCPL-based Press printing software (also on CD8 in previous Alto source code release)
Peach — 1984–1986 experimental Dicentra-based printer software
CD6/xdepeach/* — 1984–1986 XDE version of Peach printing software
Demers/Russell — 1985 Russell programming language by James Donahue, Alan Demers, and (later) Hans Boehm.
https://www.researchgate.net/publication/277157833_An_Informal_Description_of_RussellPrologCore — 1986–1987 — Larry Masinter: "Quintus Prolog was a port written in Interlisp by Quintus and included in the draft memo of software Xerox licensed to Venue."
At PARC, Deutsch, with contributions from Bobrow and Willie Sue Haugeland (now Willie Sue Orr), wrote a microcoded implementation of Interlisp for the Xerox alto. So far, none of the source code for this Alto implementation of Lisp has been located. However, the system was the basis for Interlisp-D, which ran on various microcoded "D machines", including the Dorado, Dolphin, Dandelion, and Daybreak. Variants of these D machines would be commercialized by Xerox as Lisp machines in the 1980s when Larry Masinter was chief scientist of the group. A later implementation of the virtual machine in C led to an implementation for Sun and other Unix workstations and Linux. Interlisp-D differed from previous Interlisp environments by being a fully integrated development environment with a graphical user interface, taking cues from Smalltalk and Cedar/Mesa, and running on personal workstations, rather than on timesharing mainframes.
Xerox's Interlisp-D environment was eventually renamed Medley (after the code name of Xerox's final 1988 release of Interlisp-D) and spun out to a third party called Venue.
More information about Interlisp and Interlisp-D, the D machines
implementation, and also their predecessors, predecessors,
Deutsch’s PDP-1 Lisp and the BBN PDP-1 Lisp can be found at http://www.softwarepreservation.org/projects/LISP/interlisp_family.
Additional documents can also be found on the original Xerox Alto source code archive's Lisp section.
A group of former PARC Interlisp developers led by Larry Masinter have created a project to restore Medley Interlisp to run on modern operating systems. Find out more at https://interlisp.org/. The group also has compiled additional historical resources on Interlisp here.
The expanded PARC archive contains directories of code and documentation for versions of Interlisp-D, CommonLisp and other Lisp dialects, and various applications that were written in Interlisp-D and ran in that environment. Notable applications include TEdit, the text editor, Rooms, a window manager, Trillium, a UI design environment, and Notecards, a hypertext system.
What follows are the various Interlisp-related directories in the expanded PARC archive, some applications written in Interlisp, followed by other non-Interlisp Lisp dialects:JLisp — 1986 Interlisp with Japanese fonts
Lisp — 1984–1987 various snapshots of INTERLISP/Interlisp-D
LispARs — 1984 Lisp Action Requests
LispCore — mid-1982 Lisp snapshot
lispcourse — 1988 courses on Interlisp language and workstation usage
LISPFONTS — 1989 Strike-format fonts
LispLibrary — 1989 various libraries for Interlisp
LispManual — 1984 Interlisp manual
LispUsers — 1984 packages by non-Xerox and Xerox people, distributed in source form
Loops — 1985 Object-oriented extension to Interlisp (pre-Common Lisp)
Medley — 1989 small set of patches, circa 1989
TEdit — 1986 Interlisp text-editing tool
Notecards — 1984–1989: An Interlisp-D-based hypertext system designed by Randall Trigg, Thomas Moran and Frank Halasz. Main system in QV, Phylum contains demo data.
Rooms — 1986–1987: An Interlisp-D window manager/workspace management tool (sources, demo configurations) by Austin Henderson and Stuart Card
Trillium — 1987 Nick Briggs' Trillium UI Design Environment project in Interlisp
CD6/franchi/CENTAUR/lelisp/v15.22/* — 1990–1991 Le_Lisp version
15.22, from I.N.R.I.A. This is only the runtime environment for
the SUN 4 OS4 workstations, not the entire system.
3-LISP — 1988 Smith and Rivieres reflective Lisp
CommonLisp 1996 — this is actually a snapshot of CMU Spice Lisp from 1984, and was released into the public domain at that time. It was in fact a basis for Common Lisp — see here for details: http://www.softwarepreservation.org/projects/LISP/maclisp_family/#Spice_Lisp_
IDL — 1989 Ron Kaplan's IDL (Interactive Data Analysis) project
KRL — 1987 snapshot of frame-based knowledge representation language by Bobrow and Winograd. The project began in the mid-1970s and was a collaboration between Bobrow at PARC and Winograd at SAIL. See https://en.wikipedia.org/wiki/KRL_%28programming_language%29
Speech — 1985 Lisp-based code for speech recognition
The new portions of the archive contain information on the D-series of successors to the Alto, also created by Chuck Thacker, Butler Lampson, and other members of the PARC Computer Science Laboratory (CSL) and Systems Development Division (SDD). These include the D0 aka Dolphin, the Dorado, the Dandelion, Wildflower, Daffodil, Daybreak, and Dragon.
D0 — 1985 microcode and test programs (D0 was also known as Dolphin — not a product except a few Lisp workstations)
D0Docs — 1985 hardware and microcode documentation for D0
D0Logic — 1985 logic diagrams for D0
D0Source — 1985 more microcode plus source for low-level tools for D0
Daffodil — 1985 logic diagrams and documentation for LSI version of Dandelion for second version of Star
Dandelion — 1988 files for Extended version of Dandelion processor, intended to run Cedar
Daybreak — 1990 Dandelion successor (Xerox 6085) — files describe a SPARC softcard for the 6085
Dicentra — 1982–87 Multibus-based D machine for routers, etc.
DLion — 1990 snapshot of Cedar(!) and Mesa microcode for various processors: Dandelion, Daybreak
Dorado — 1979–86 microcode for high-performance (ECL) Alto follow-on
DoradoBuildDocs — 1989 documentation for cabling, etc. of Dorado workstations
DoradoDocs — 1979–86 documentation for testing, assembling microcode, etc. of Dorado workstations
DoradoDrawings — 1989 documentation for Dorado hardware — board layouts?
DoradoLogic — 1989 logic diagrams for Dorado CPU
DoradoSource — 1979–85 microcode and documentation for Dorado workstation
CD8/doradomicrocode/* — 1980–1990 microcode source code and tools for PARC Dorado workstation
Dragon — 1984–1988 The Dragon computer, VLSI processor
Dragon7.0 — 1984–1988 The Dragon computer, VLSI processor
OMouse — 1986 Optical mouse
CTamarin, Tamarin — 1989 Alan Bell research project to build VLSI Lisp processor
WF — 1984 WildFlower, Butler Lampson's 1978 design sketch for what became Dandelion
Chipndale — 1984 graphical editor for VLSI layout and schematics
Cholla — 1990 Laurel-based IC fabrication line control program. (Laurel was an email reader developed for the Alto)
Crystal — 1985–1986 Cedar transliteration of John Ousterhout's VLSI worst-case timing program (original in C)
DA — 1988 Design Automation Tools
DATools6.0 1985/1986 release of Design Automation tools
DATools6.1 1986/1987 release of Design Automation tools
DATools7.0 1987–1990 release of Design Automation tools
Rosemary — 1987 A logic simulator
TeleSil — 1986 remote version of Sil. (Sil was Chuck Thacker’s original drawing editor)
Thyme — 1986 A timing tool (similar to SPICE)
Beads — 1980–1981 Will Crowther circuit-design program: "Wires is intended to be the middle phase of a three phase program to compile logic equations into the masks for nMOS integrated circuits."
Chipmonk — 1981–1984 VLSI layout program
Sakura — 1981 Nori Suzuki and Rod Burstall: "Sakura is a language for specifying the behaviour of hardware devices. It is based on Mesa, but has facilities for concurrency which we hope will be easier to use for hardware description than the Mesa facilities."
The following contains directories related to Alto that were not included in the previous Xerox Alto source code archive. (All of these are repeated from their respective categories above.)
Fiala/BitBlt — 1988 early code and documents from FRED
(Baudelaire font editor), Gypsy (Tesler/Mott editor), etc.
Mesa — 1989–1990 snapshot of final Alto Mesa (Mesa 6.0?)
Press — 1990 original BCPL-based Press printing software (also on CD8 in previous Alto source code release)
Grapevine — email server (also on CD8 in previous Alto source code release)
Also included in this release is a CD previously publicly released and open sourced by Xerox accompanying Xerox PARC Computer Science Laboratory Technical Report CSL_93-16, and contains Cedar, Tioga, emacs, fonts, and other source code.
The following is a list of directories included in the original
Xerox Alto source code archive. Some directories may
contain additional files or subdirectories not present in the
earlier archive. Links provided are to the new versions in this
The files in the archive are named according to the conventions of the Alto Operating System. Each file has a name consisting of letters (upper and lower case can be used interchangeably), digits, and any of these special characters: + - . ! $
The name is usually divided into two part by a period: the main
name before the period, and the extension after
the period. A name can also have a version number, which is a
number that comes at the end of the name, preceded by an
exclamation point. For example, in the name "
the main name is "
bravomanual", the extension is "
and the version number is 2.
When Alto files were stored on an IFS file server, they were
grouped in directories and subdirectories. A directory name can
contain the same characters as a file name. A directory path is
a list of names of directories, with "<" at the beginning and
">" after each directory name. An example is "
The archive includes files that had been stored on several
different IFS file servers, so a full name for a file specifies
a server (with square brackets around the name), a directory
path, and a file, for example: "
The servers present in this archive include Filene, Ibis,
Indigo, Io, Ivy, and Pixel. There are two additional
"pseudo-servers", _cd6_ and _cd8_, corresponding to additional
files that had been restored in an earlier project at Xerox
The archive has a web page listing the servers. For each server there is a web page listing the top level directories, with an additional web page for each subdirectory. Each directory page lists subdirectories and files in separate sections. Each file is generally presented in two different ways: in a viewable format (e.g., HTML, PDF), and in its original format (referred to as "raw" in the directory listings).
An Alto file with the extension "
dm" or "
is called a Dump/Load file and contains a collection of files,
analogous to a Windows "
zip" file or a Unix "
file. In this archive, each Dump/Load file has been unpacked to
a new directory with the same name as the Dump/Load file. For
example, corresponding to "
The corresponding web URL is "
with an underscore at the end.
An Alto file with the extension "
altodisk" or "
copydisk" is an image of an entire Alto disk
pack, analogous to an "
iso" CD-ROM image. In this
archive, each disk image file has been unpacked to a new
directory with a name based on that of the disk image file. For
example, corresponding to "
The corresponding web URL is "
with an underscore at the end.
Many of the files (such as most of the program source code
files) consisted of ASCII text; each of these has been rendered
as an HTML file with a
surrounding the body of the file. Some files (such as
documentation, memos, and, sometimes, program source code) were
created by the Bravo word processor, which embedded formatting
information along with the text. Each of these files has been
rendered as an HTML file that uses CSS styles to mimic the
intended Bravo formatting (such as font changes, bold and
italic, and indentation). Some files originally created by
document editors such as Bravo had been converted to the Press
device-independent print file format. Each of these has been
rendered as a PDF file that attempts to mimic the intended Press
formatting (including font changes, bold and italic, etc.) and
graphical elements (including rectangles, Bezier curves, and
scanned images). All other files have been rendered as an "octal
dump" of up to the first 100,000 bytes, using the Unix command
od -t oC -N 100000".
The renderings of Bravo and Press files is still buggy and
incomplete, but in most cases is good enough to convey the
intended content. In particular, support is lacking for the
various Alto fonts: encodings, metrics (widths), and glyphs. The
Bravo document profile is currently ignored, as are named tabs.
Press graphics — rectangles, dots, and objects (filled paths
consisting of straight and curved line segements) — are
Tioga documents, rich text documents that combine text and
graphics used in the Cedar/Mesa environment for both formatted
publications as well as source code, have also been converted
into HTML, preserving much of the original formatting, fonts and
styles. The converter lacks support for embedded graphics and
proper table alignment, which would require using a more
sophisticated JaM parser. It does, however, support math and
Greek symbols. Much of the logic for the converter was borrowed
Thanks to Josh Dersch for writing the converter, and Paul
McJones for integrating the code into the
tool to automatically generate these web pages. A separate
converter to convert Tioga files into Unicode-standard plain
text, for compatibility with Unix-based tools such as Git, was
also created by Dersch and integrated into
by McJones, so Tioga files are viewable either in a rich text
form, a modern plain text form, or their original Xerox-era raw
There should be viewers for Sil documents and fonts (.al and .strike for the screen and various formats for the printer — see http://www.bitsavers.org/pdf/xerox/alto/printing/).
Each link of the form (raw) in the directory listings gives access to the original sequence of bytes for the corresponding file. This will only be of use when you understand the file type for that file. Note that the Alto had 16-bit words, and was "big-endian": the high-order byte of a 16-bit word is stored at an even byte address, and the low-order byte of the same word is stored at the next higher odd byte address.
Often, the type of the file can be determined from the extension in the file's name. Here is a short glossary of file types:
The metadata accompanying each file includes a field called “Author.” Note that this does not necessarily name the person who originally created the file; it apparently specifies the user name in effect when the file was transferred to the IFS server.
The files in this archive originally lived on a set of IFS file servers at Xerox PARC. Over the years various techniques were used to archive the files to offline storage, in the form of 9-track magnetic tapes. First this was done via a program called BSYS running on MAXC, which was a computer that ran the TENEX operating system. Later this was replaced by a program called Archivist that ran on a Dorado (a much-faster successor to the Alto), which allowed a user to specify a set of files to be archived. By around 1991 the IFS servers and the Archivist program were no longer being used, and a new suite of programs were written to transfer files from the old 9-track tapes to 8mm digital tape cartridges, preserving the original record structure as defined by the Archivist program but including one extra record consisting of a file named rosetta.tar containing, as explained in a README file:
... the C sources for the programs used to read the maxc and archivist 9 track, 1/2" tapes, the shell scripts used to drive those programs during the transfer of the 9 track, 1/2" tape data to the 8mm tapes, and the Cedar/Mesa sources for the Archivist program which was originally used to archive the data to 9 track, 1/2" tape.
In 2003, Al Kossow, working as an independent consultant to
PARC, transferred the 8mm tapes to a set of DVD-ROMs, copying
each as a complete sequence of records. Furthermore, he copied a
subset of the records consisting mainly of Alto-related software
and documentation onto a separate CD-ROM. In 2011, Xerox PARC
donated this CD-ROM to the Computer History Museum, as catalog
In addition to the copies of the Archivist records, that CD-ROM
included two additional directories, cd6 and cd8, extracted from
two CD-ROMs that had been restored from archived files at some
time before 2003. Starting in the fall of 2013, Paul McJones
wrote a program named restore_alto_files to read the archive
tape images, unpack Alto Dump/Load files and Alto disk images,
and create web pages for browsing the directories and CDs and
viewing various file types (including Bravo and Press). The
resultant web site was released in 2014 as xeroxalto.computerhistory.org.
In 2018, PARC and CHM agreed to extend the 2011 agreement to
include a much larger subset of the IFS files, covering much of
the 1980s (the earlier Alto release had focused on the 1970s).
Paul McJones agreed to work under NDA to review the full list of
IFS files, propose a subset to PARC for release to CHM, and once
that subset was refined and approved, to extract them and put
them in an appropriate form for transfer to CHM. This new
donation constitutes this present archive, and has been
catalogued 102791364, lot X8506.2018.
Here are copies of rosetta.tar.gz and restore_alto_files.tar.gz.