Computer History
          Museum Logo

Xerox PARC file system archive

Hansen Hsu, Paul McJones
Revised 8 November 2023


A walk through the archive: software and projects
     Cedar/Mesa software
     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
     Interlisp software
     AI Applications
     Design Tools
     Alto Historical
     Previously Released

More on the archive
     File names
     Dump/load files
     Disk-image files
     Viewable formats
     Raw files: endianness
     File types

A walk through the archive: software and projects

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 the Alto.

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 Language, Libraries, Tools, and Applications

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 languages).

Chuck Geschke and Ed Satterthwaite designed and implemented the Mesa compiler for the Alto, and Richard Johnson and John Wick wrote a Mesa version of the Alto operating system, which also served as the runtime for Mesa programs. By the summer of 1976, the Mesa compiler had been rewritten in Mesa and brought up on the Alto. Mesa was used for much of the later Alto software, such as the Laurel email client and the Grapevine distributed email transport and name service. It was also used for products such as the Star Office Automation system, and its successor language, Cedar/Mesa, was used for many later research projects running on successors to the Alto. Cedar improved on Mesa by adding automatic garbage collection and runtime type discrimination.

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.

Cedar References:

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,

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,

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,

Eric A. Bier, “EmbeddedButtons: Supporting Buttons in Documents,” ACM Trans. Inf. Syst. 10, no. 4 (October 1992): 381–407,

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,

M. Brown, K. Kolling, and E. Taft, “The Alpine File System,” Xerox PARC Technical Report CSL-84-4, October 1984,

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,

L. Peter Deutsch and Edward A. Taft, “Requirements for an Experimental Programming Environment,” Xerox PARC Technical Report CSL-80-10, June 1980,

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,

James Donahue and Willie-Sue Orr, “Walnut: Storing Electronic Mail in a Database,” Xerox PARC Technical Report CSL-85-9, November 1985,

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,

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,

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,

Butler W. Lampson, “A Description of the Cedar Language: A Cedar Language Reference Manual,” Xerox PARC Technical Report CSL-83-15, December 1983,

Butler W. Lampson et al., “The Dorado: A High-Performance Personal Computer: Three Papers,” Xerox PARC Technical Report CSL-81-1, January 1981,

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,

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,

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),

Eric Emerson Schmidt, “Controlling Large Software Development In a Distributed Environment,” Xerox PARC Technical Report, CSL-82-7, December 1982),

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,

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,

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,

Warren Teitelman, “The Cedar Programming Environment: A Midterm Report and Examination,” Xerox PARC Technical Report, CSL-83-11, June 1984,

Warren Teitelman, “A Tour Through Cedar,” IEEE Transactions on Software Engineerin 11, no. 3 (March 1985): 285–302,

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,

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,

Cedar Archive:

Cedar — starting 1984, programming environment based on Cedar/Mesa.

According to [indigo]<cedar>documentation>.Catalog.tioga!6.html> this is Cedar 5.0.
Cedar5.3 — 1986 release of Cedar
Cedar6.0 — 1986 release of Cedar
Cedar6.1 — 1987 release of Cedar
Cedar7.0 — 1989 release of Cedar, includes MakeBoot scripts (documentation: see, 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
[indigo]<cedarviewers>, [ivy]<cedarviewers>
Nucleus — 1986 snapshot of core component of Cedar (operating system, etc.) Includes Bringover, SModel, file system, LoadState, MakeBoot, MesaRuntime, Dialup, Networking, etc.
SModel is probably the "System Modeler" package. This was work done by Eric Schmidt for his Ph.D. thesis, based on an idea of Butler Lampson. Basically, there were immutable descriptions of particular snapshots of a system, and repeatable scripts for building executable versions.
Controlling Large Software Development in a Distributed Environment
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.

PostCedar5.2 — 1985/1986 snapshot of Cedar libraries, tools, etc.
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

Graphics and Text for Cedar/Mesa

CD6/interscript/* —    1981–4 editable document format (see
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.
[cyan]<imaging>, [indigo]<imaging>, [pixel]<imaging>
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:

[cd8]<juno>, [indigo]<juno>
Mesa — 1989–1990 snapshot of final Alto Mesa (Mesa 6.0?)
Solidviews — 1983–88 Eric Bier's 3D solid modeling system, documentation and sample pictures
[cd8]<solidviews>, [indigo]<solidviews>
Tex — 1985 MesaTex79 sources
Tioga — 1986 text editor
[cd6]<tioga>, [cyan]<tioga>, [pixel]<tioga>
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 — Imaging Science Laboratory Software

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

A good snapshot of the implementation may be located in [indigo]<jam>pilot>
PreISL — 1985 various libraries and tools for images and typesetting
PreISLCedar — 1985 many libraries and tools, including mockingbird, juno, etc.


AlgebraStructures — 1990 also in CedarChest6.0: Dennis Arnon: package for building complex algebraic structures and computing with their elements
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.

David R. Boggs, John F. Shoch, Edward A. Taft, and Robert M. Metcalfe. Pup: An Internetwork Architecture.

Pup — 1984–86 Pup implementation for Maxc
[cd8]<pup>, [indigo]<pup>

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)
[cd8]<portola>, [indigo]<portola>
PupGateway — 1986–88 Mesa code for gateway between XNS and Pup networks
[cd8]<pupgateway>, [indigo]<pupgateway>
NCP — 1989 Mesa code to interface with Arpanet

Databases, File Systems, and Client/Server Applications

Alpine — 1981–1985 Alpine File Server (transactional file server) by Mark R. Brown, Karen Kolling, E. A. Taft
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:

[cd6]<alpine>, [indigo]<alpine>
RAlpine — 1981-1987 Client access for Alpine File Server
[cd6]<ralpine>, [indigo]<ralpine>
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)
[cyan]<grapevine>, [indigo]<grapevine>, [ivy]<grapevine>, [pixel]<grapevine>
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.

Sources, documentation: [indigo]<ifs>, [pixel]<ifs>


Tripos — 1986 Martin Richard's TRIPOS (TRivial Portable Operating System).
TRIPOS was later incorporated into the Amiga OS. (See A demonstration version called Cintpos is available at
CD8/mockingbird/*   — 1980–84 Music editor by John Maxwell and Severo Ornstein or



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
Fonts 1990
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
[indigo]<peach>, [cd6]<peach>
CD6/xdepeach/* — 1984–1986 XDE version of Peach printing software


Voice — 1984 Cedar libraries and applications for Voice

Programming Languages other than Cedar/Mesa, Smalltalk, Lisp

Note, the graphics language JaM is covered above.

Casaba — 1988–90 compiler-compiler by Sturgis et al. used for Saffron — experimental Cedar compiler
Demers/Russell — 1985 Russell programming language by James Donahue, Alan Demers, and (later) Hans Boehm.

PrologCore — 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."
For more on Quintus Prolog, see

Lisp and Interlisp

Interlisp began as BBN-Lisp, initially implemented for the PDP-1 by Daniel Bobrow and D.L. Murphy at Bolt, Beranek and Newman, inspired by L. Peter Deutsch's earlier interactive PDP-1 Lisp written at MIT. Alice K. Hartley would write the subsequent PDP-10 TENEX implementation of BBN-Lisp. BBN-Lisp was renamed Interlisp when Bobrow, Warren Teitelman, and Ronald Kaplan left BBN to join Xerox PARC. The Interlisp project was to make a machine independent Lisp, and various implementations would be created for various other timesharing mainframes, including the SDS 940, IBM 360/370 and DEC VAX. Interlisp would go on to influence the Common Lisp standard.

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
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 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
[eris]<lisp>, [erinyes]<lisp>, [phylum]<lisp>
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
[eris]<lispmanual>, [erinyes]<lispmanual>
LispUsers — 1984 packages by non-Xerox and Xerox people, distributed in source form
[eris]<lispusers>, [phylum]<lispusers>
Loops — 1985 Object-oriented extension to Interlisp (pre-Common Lisp)
[indigo]<loops>, [phylum]<loops>
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.
[phylum]<notecards>, [qv]<notecards>
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

Other (non-Interlisp) Lisp dialects

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:

AI Applications

bluebonnet — 1984 Bluebonnet Expert Help System by Fikes
[phylum]<bluebonnet>, [qv]<bluebonnet>
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
Speech — 1985 Lisp-based code for speech recognition
[eros]<speech>, [ivy]<speech>, [phylum]<speech>, [eris]<speech>


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.
[cd8]<dicentra>, [indigo]<dicentra>
DLion — 1990 snapshot of Cedar(!) and Mesa microcode for various processors: Dandelion, Daybreak
Dorado — 1979–86 microcode for high-performance (ECL) Alto follow-on
[cd8]<dorado>, [indigo]<dorado>
DoradoBuildDocs — 1989 documentation for cabling, etc. of Dorado workstations
DoradoDocs — 1979–86 documentation for testing, assembling microcode, etc. of Dorado workstations
[cd8]<doradodocs>, [indigo]<doradodocs>
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]<doradosource>, [indigo]<doradosource>
CD8/doradomicrocode/*    — 1980–1990 microcode source code and tools for PARC Dorado workstation
Dragon — 1984–1988 The Dragon computer, VLSI processor
[cd4]<dragon>, [cd6]<dragon>, [indigo]<dragon>
Dragon7.0 — 1984–1988 The Dragon computer, VLSI processor
[cd4]<dragon7.0>, [cd6]<dragon7.0>, [indigo]<dragon7.0>
DragonWare0.1 1988–9
[cyan]<dragonware0.1>, [pixel]<dragonware0.1>
OMouse — 1986 Optical mouse
CTamarin, Tamarin — 1989 Alan Bell research project to build VLSI Lisp processor
[phylum]<ctamarin>, [phylum]<tamarin>
WF — 1984 WildFlower, Butler Lampson's 1978 design sketch for what became Dandelion

Design Tools

— see

CD6/autolayout/* — 1982–1989 Preas and Chow: Placement And Routing Algorithms For Topological Integrated Circuit Layout
Chipndale — 1984 graphical editor for VLSI layout and schematics
[cd6]<chipndale>, [indigo]<chipndale>, [pixel]<chipndale>
Cholla — 1990 Laurel-based IC fabrication line control program. (Laurel was an email reader developed for the Alto)
[cherry]<cholla>, [indigo]<cholla>
Crystal — 1985–1986 Cedar transliteration of John Ousterhout's VLSI worst-case timing program (original in C)
[cyan]<datools6.0>crystal>, [cyan]<datools6.1>crystal>
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
[cd4]<datools7.0>, [cyan]<datools7.0>, [pixel]<datools7.0>
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."

Alto Historical

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)
[cyan]<grapevine>, [indigo]<grapevine>, [ivy]<grapevine>, [pixel]<grapevine>

Previously Released

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 archive.

Alto        [cd8]<alto>
Alto-1822    [indigo]<alto-1822>
AltoDocs    [cd8]<altodocs>
AltoFonts    [indigo]<altofonts>
AltoGateway    [ibis]<altogateway>
AltoSource    [indigo]<altosource>
AltoTape    [cd6]<altotape>, [indigo]<altotape>
BasicDisks    [cd8]<basicdisks>, [indigo]<basicdisks>
Bootfiles    [cd8]<bootfiles>
BravoX    [indigo]<bravox>
CSLCopyDisk    [indigo]<cslcopydisk>
DLS    [cd8]<dls>
Dover    [cd6]<dover>
DMS    [indigo]<dms>
Grapevine    [cd8]<grapevine>
IFS    [cd8]<ifs>, [indigo]<ifs>, [pixel]<ifs>
Images    [pixel]<images>
Laurel    [cd8]<laurel>
Murray    [io]<murray>
Jasmine    [indigo]<jasmine>
JDS    [indigo]<jds>
PD    [indigo]<pd>
Poppy    [ivy]<poppy>
Press    [cd8]<press>
PressFonts    [indigo]<pressfonts>
PrintingDocs    [cd8]<printingdocs>, [indigo]<printingdocs>
PUP    [cd8]<pup>
SIL    [cd6]<sil>
Spruce    [indigo]<spruce>
Sweet    [ivy]<sweet>
TapeServer    [cd6]<tapeserver>, [indigo]<tapeserver>
XMesa    [indigo]<xmesa>

More on the archive

File names

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 "!2", the main name is "bravomanual", the extension is "press", 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 "<BravoX>Fonts>".

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: "[Indigo]<BravoX>NEPTUNE>NEPTUNE-MANUAL.PRESS!2". 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 PARC.

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).

Dump/Load files

An Alto file with the extension "dm" or "DM" is called a Dump/Load file and contains a collection of files, analogous to a Windows "zip" file or a Unix "tar" 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 "[Indigo]<AltoSource>ALTOUSERSHANDBOOK.DM!2" is "[Indigo]<AltoSource>ALTOUSERSHANDBOOK.DM!2>". The corresponding web URL is ".../Indigo/AltoSource/ALTOUSERSHANDBOOK.DM!2_", with an underscore at the end.

Disk-image files

An Alto file with the extension "altodisk" or "bfs" 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 "[Indigo]<BasicDisks>BcplProg.BFS!13" is "[Indigo]<BasicDisks>BcplProg.BFS!13>". The corresponding web URL is ".../Indigo/BasicDisks/BcplProg.BFS!13_", with an underscore at the end.

Viewable formats

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 <pre> element 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 line "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 supported.

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 from <_cdcsl_93-16_>1>viewtioga>. Thanks to Josh Dersch for writing the converter, and Paul McJones for integrating the code into the restore_alto_files 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 restore_alto_files by McJones, so Tioga files are viewable either in a rich text form, a modern plain text form, or their original Xerox-era raw format.

There should be viewers for Sil documents and fonts (.al and .strike for the screen and various formats for the printer — see

Raw files: endianness

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.

File types

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:

Alto screen font represented as a bitmap for each character
See .bfs
Alto assembler source program
Relocatable object file created by Mesa compiler
BCPL source program
Contents of a complete Alto disk pack represented as a file
A file from which an Alto can be boot-loaded (operating system, utility, etc.)
A configuration file used by the Mesa linker to build a bootfile
Relocatable object file created by BPCL compiler
Document created by Bravo word processor (viewable as HTML in the archive)
Command file interpreted by Alto Executive
See .bfs
BCPL definitions, incorporated into a program via a get statement
alias for .d
DumpLoad file, packaging a set of files
Executable form of program written in Mesa (started with
files interpreted by the device-independent page description language JaM, precursor to Interpress
Relocatable object file created by Mesa compiler intended as an add-on to the Laurel mail client application
Tenex PDP-10 assembly language
Microcode assembler source program — specifically for D0 ?????
Mesa source program
Alto microcode assembler source program
Device-independent print-ready file, created by various applications (viewable as PDF in the archive)
Document prepared as input to PUB formatting program (running on PDP-10 rather than Alto)
Executable form of program written in BCPL and/or assembler (created by BLDR)
Another format for Alto screen font, optimized for use with BitBlt (bit-boundary block transfer)
Symbolic debugging information associated with a Mesa .image file
Symbolic debugging information assocatiated with a BCPL .run file
Document created by Cedar/Mesa's WYSIWYG word processor Tioga (viewable as HTML in the archive)


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 number 102706061, lot X6195.2011. 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

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.