Personal tools
You are here: Home Projects LISP Standard LISP Family
Document Actions

Standard LISP Family

by Paul McJones last modified 2023-12-31 17:17




Standard LISP

Standard LISP arose from a desire to port REDUCE (see Stanford LISP 1.6 Applications) to other systems.


  • A.C. Hearn. Standard LISP. 1969.
    • Memo AIM-90, Stanford Artificial Intelligence Project, Stanford University, May 1969, 33 pages. PDF
    • In: Lisp Bulletin #1, page 9, which was published as: SIGPLAN Notices, Volume 4, Number 9, September 1969, pages 25-45. ACM DL
    • Reprinted in SIGSAM Bulletin, ACM, Issue 13, 1969, pages 28-49. ACM DL
  • J. B. Marti, A. C. Hearn, M. L. Griss, and C. Griss. Standard LISP Report.
    • University of Utah Symbolic Computation Group Report No. 60, Salt Lake City, Utah, 1978.
    • SIGPLAN Notices, Volume 14, No. 10, ACM, October 1979, pages 48-68. ACM DL
    • SIGSAM Bulletin Volume 14, Number 1 (February 1980), pages 23–43. ACM DL
    • The report gives the date for Hearn's original Standard LISP article in SIGPLAN Notices as Volume 4, Number 9, September 1966, but the actual year was 1969.

  • I. B. Frick. Manual for Standard LISP on the DECSYSTEM 10 and 20. Technical Report TR-2, Utah Symbolic Computation Group, University of Utah, July 1978.

    [Is this PSL or a "wrapper" for another implementation?]

  • John Fitch. Manual for Standard Lisp on IBM System 360 and 370. Technical Report No. TB-6, Symbolic Computation Group, University of Utah, 1978?

    "There was an EVALQUOTE lisp called Lisp/360 which was used at Utah in the 1970s; it came from Stanford and had been heavily modified by Kevin Kay. ... there was a Standard LISP for IBM 360 based on the same code, and renamed SLISP/360. It was an EVAL system. The reason I know is because I did some of the modifications after Kevin left Utah. I used it subsequently at Leeds, and in my archives I still have the source. Also 2 Japanese, Kanada-san and a student I think, transcribed this SLISP/360 into Motorola 68K assembler, and got it to run! It had a number of terrible features, but it did support REDUCE." [J. P. Fitch, comp.lang.lisp, February 18, 1994]

    • Kenji Namba. Some improvements on Utah Standard Lisp. SIGSAM Bulletin, Volume 20, Numbers 1-2 (February 1986), pages 29-36. ACM Digital Library

      "The Assembly comments indicate the following personnels: J. G. Kent, J. F. Bolce, R. I. Berns, K. R. Kay and J. Fitch."

    See also: [Padget 1988] under Cambridge Lisp Papers.

  • Joel Bartlett. TNS/II (sub)Standard LISP. Tandem Computers Inc., March 15, 1985. PDF

    "Abstract: This document describes an implementation of Standard LISP which runs on Tandem Computers Inc. NonStop II and NonStop TXP systems. It is intended to be a reference document to be used in conjunction with the "Standard Lisp Report", Marti et al, SIGPLAN Notices, Volume 14, Number 10, October 1979 (here after refered to as the Standard)."



  • A.C. Hearn. REDUCE 2 User's Manual, Memo No. AIM-133, Stanford Artificial Intelligence Project, October 1970.
  • A.C. Hearn. REDUCE 2: A system and language for algebraic manipulation. In Proceedings of the Second Symposium on Symbolic and Algebraic Manipulation, Los Angeles, March 1971, pages 128-133. ACM DL
  • A.C. Hearn. REDUCE 2 Users Manual. Report UCP-19, Symbolic Computation Group, Department of Computer Science, University of Utah, 1973.


UOLISP for the Zilog Z80 microprocessor

Jed Marti developed this LISP system for the Zilog Z80 microprocessor at the University of Oregon. The implemenation included an interpreter and a compiler.


  • J. Marti. Little Big LISP. University of Oregon Department of Computer and Information Science Technical Report CIS-TR-80-18, 1980. Online at

    "Little Big LISP is a subset of Standard LISP [Marti et al. 1979] implemented for the Z80 microprocessor. It runs in a minimum of sixteen thousand bytes of storage-and most effectively with thirty two thous~nd or more. The system consists of the following:

    1. An interpreter
    2. A program to load precompiled object files ("fast load" files)
    3. A compiler for generating either fast load files or directly executable code
    4. A parser for a subset of RLISP [Hearn 1973]
    5. A function trace feature
    6. A small LISP structure editor"
  • See also "Executable code" below.


  • Jed Marti. An optimizing compiler for LISP for the Z80. In Proceedings of the 5th ACM SIGSMALL symposium on Small systems (SIGSMALL '82). Association for Computing Machinery, New York, NY, USA, pages 3–8. ACM DL
  • Jed Marti and John Fitch. REDUCE 2 for CP/M. SIGSAM Bull. Volume 17, Number 1 (February 1983), pages 26–27. ACM DL
  • Jed Marti. The little META translator writing system. Software: Practice and Experience, Volume 13, Number 10, October 1983, pages 941-959. Wiley Online Library

Executable code

  • Jed Marti. UO-LISP for the TRS-80. Northwest Computer Algorithms, Version 1.5b of 3 June 1982. Posted by permission of Jed Marti. David Librik purchased this copy in 1985, and gave it to Michael Wessel in 2022; Michael imaged the floppy disk, scanned the documentation, and tested the disk image on the trs80gp TRS-80 emulator.
    • UOLISP disk image. .dmk format / .jv3 format
      • LISP48/CMD - interpreter for 48K memory configuration (use Model 1 mode with trs80gp TRS-80 emulator)
      • COMP - compiler
      • OPT - optimizer for compiler
      • EDIT - structure editor
      • TRACE - trace package
      • LAPP - LAP pretty printer
      • RLISP - RLISP parser (ALGOL-like syntax, from REDUCE computer algebra system)
      • DEMO/RED - demo program written in RLISP
      • VECTORS - vector package for RLISP
      • PRETTY - pretty printer
    • TRSDOS disk image. Version 2.3. .dmk format
    • UO-LISP Documentation.
      • Cover photo and table of configurations supported. PDF
      • Legal Information: Trademarks, warranty, copyrights, license, update policy. PDF
      • Jed Marti. UO-LISP MANUAL Version 1.5b. Northwest Computer Algorithms, July 1984. Version for Z80 Base CPU, TRS-80 Model's I and III with TRSDOS or TRSDOS like Operating Systems. PDF

        "Abstract: This manual describes the Z80 based LISP system, UO-LISP, its data structures, built in functions, operating procedures, the compiler and optimizer, an RLISP parser, a trace package, and a structure editor."

      • [Jed Marti?]. Installation Guide for UO-LISP Version 1.5b. Northwest Computer Algorithms, undated (circa 1984?). Version for Z80 Based CPU, TRS-80 Model's I and III with TRSDOS or TRSDOS like Operating Systems. PDF
      • [Jed Marti?]. Learn Lisp Tutorial Guide Supporting the UO-LISP Programing Environment. Northwest Computer Algorithms, 1984. Version for CP/M based UO-LISP V2. PDF
    • Newsletters. Far West Systems and Software, Inc. and Northwest Computer Algorithms. Vol. 1 No. 1 (January 1984) through Vol. 2 No. 4 (October 1985). PDF
    • Flyers. Northwest Computer Algorithms, versions 1, 2, and 3. PDF
    • REDUCE marketing materials.
      • Announcement. Northwest Computer Algorithms, undated. PDF

        "WELL .... we've been working on a very important project. We took on the computer algebra System called REDUCE. We put on the blinders and produced 27,000 lines of LISP. REDUCE now runs on the 8086 family of computers in less than 640k. More about REDUCE in our next issue of the newsletter."

      • Flyer. Northwest Computer Algorithms. REDUCE 3.2, undated. PDF
      • REDUCE and UO-LISP advertisement. Northwest Computer Algorithms, undated. PDF


    PASLISP, an implementation of Standard LISP in PASCAL

    PASLISP was a precursor to Portable Standard LISP, based on the Standard LISP definition.

    • M. L. Griss, R. Ottenheimer, S. Voelker, K. Boekleheide. A PASCAL Based Standard LISP for the PERQ. Unpublished technical report, Department of Computer Science, University of Utah. Online at

      "Abstract: This report describes an interim implementation of Standard LISP for the PERQ. This LISP is based upon the Standard LISP report, and a newly developing Portable Standard LISP. This interim implementation is designed to explore LISP implementations in PASCAL on the PERQ and similar machines. The system consists of a kernel, handcoded in PASCAL, with the rest of the system written in LISP and compiled to PASCAL."

    • M. Griss and W. Galway. PASLSP source code, Department of Computer Science, University of Utah, 1981-1983. Online at


    REDUCE 2 and Standard LISP for Burroughs B6700

    "The REDUCE system for the B7000/B6000 series consists of four parts: The REDUCE algebraic processor itself, a LISP processor, a LISP compiler which converts LISP programs to an intermediate language, and an assembler which converts the intermediate language to Burroughs ALGOL. The INTEGRATOR has a fifth part which is the integrator package.

    The algebraic processor, the compiler, the assembler and the integrator package are written in RLISP, a sort of LISP with ALGOL-like syntax. The LISP processor is written partly in ALGOL and partly in RLISP. All these parts are combined into a single large ALGOL program. The parts written in RLISP must first be translated to ALGOL. The algebraic processor does this translation.

    The algebraic processor was largely written by Anthony Hearn, the compiler is the work of Anthony Hearn and Martin Griss, the assembler was done by John Fitch, the part of the LISP processor written in RLISP was done by John Fitch and Jed Marti. The integration package was developed at Cambridge by Arthur Norman, John Fitch, and Maryann Moore. The ALGOL portion of the LISP processor, originally an SDL program for the B1700 that was written by Fitch and Marti, was translated to ALGOL and subsequently modified by Dave Dahm." [From DOC.INSTALLATION]

    Source code

    In the 1980s, Burroughs Corporation distributed a tape of free (presumed to be public domain) software called tbe Higher Education Software Library, Release 2.0. Around 2013, Nigel Williams located a copy belonging to Paul Cumberworth, then of Adelaide, Australia, who is a former Burroughs employee. The tape had a creation date of 1990-07-25, which is presumed to be the date it was copied from one medium to another. Cumberworth sent the tape to Dennis Boone at Michigan State University, who imaged the tape to a SimH .tap file. Williams then supplied the .tap file to Paul Kimpel, who converted it back to a native Burroughs MCP CD-R, and then extracted files and converted them from Burroughs format (EBCDIC character codes, numeric file type information) to Windows/Unix format (ASCII character codes, filename extensions).

    "Most of the files have creation dates in the 1985-86 range, with a few going back to 1979. Those later dates can be misleading, though, because the MCP source code editors recopy files when updates are saved, which gives the new file the current date. From those dates and the references mentioned above, I suspect the conversion from the B1700 to A Series MCP took place around 1980, but it could have been later than that." [Paul Kimpel, personal communication, 16 October 2022]

    • Burroughs Corporation. Table of Contents, Higher Education Software Library, Release 2.0. REDUCE2/LISP appears on page 22. Text
    • Anthony Hearn, Martin Griss, John Fitch, Jed Marti, and Dave Dahm. REDUCE 2 / Standard LISP for Burroughs B6700 RLISP and ALGOL source code. Includes Integration Package by Arthur Norman, John Fitch, and Maryann Moore.
      • Installation document. Transcoded from EBCDIC to ASCII by Paul Kimpel. Text / Original RUNOFF version
      • Paul Kimpel, editor. Burroughs MCP wrapped container of the REDUCE2LISP files. REDUCE2LISP.con
      • Paul Kimpel, editor. Version with EBCDIC-to-ASCII conversion and filename extensions.
      • Selected files from (note there are also MCP "patch files"):
        • TORECREATE/COMPILER.sqd_m is the Standard LISP compiler, written in RLISP -- Standard LISP with REDUCE (essentially ALGOL 60) syntax. As it notes, the machine dependent parts are in a separate file. COMPILER.RLISP
        • TORECREATE/B6700.sqd_m, also written in RLISP, contains the code specific to the B6000/7000 series. B6700.RLISP
        • TORECREATE/ASSEMBLER.sqd_m is an RLISP program that converts LAP (LISP assembly code as output by the compiler) to a Burroughs ALGOL program. See GENERATED/LISP/ALGOL.alg_m for the output of compiling/assembling INCLUDE/ALGOL.alg_m. ASSEMBLER.RLISP
        • INCLUDE/ALGOL.alg_m is the core of the Standard LISP interpreter/runtime, written in Burroughs ALGOL. ALGOL.ALGOL

          "It looks to me like this is the piece (or at least the main piece) that was originally written in B1700 SDL. I don't know SDL, but there's a spec for it on bitsavers. There are references in comments to things that sound B1700-ish (e.g., "Twinkle-Box lights") and SEGMENT directives that have been commented out (and are definitely SDL). The language was quite ALGOL-like, and I suspect that from a syntax perspective you could do pretty much a line-for-line conversion of SDL to Burroughs ALGOL, especially for a project like this." [Paul Kimpel, personal communication, 17 October 2022]

        • INCLUDE/RLISP/LISP.sqd_m is the portable portion of the Standard LISP interpreter/runtime, written in RLISP. LISP.RLISP


    Portable Standard LISP (PSL)

    A portable compiler for the Standard LISP language. This became the main platform for REDUCE.

    Source code

    • Martin L. Griss and Anthony C. Hearn. A portable LISP compiler. Appendix B is the listing of the compiler.
      • Report UCP-76, Utah Symbolic Computation Group, University of Utah, June 1979; revised August 1980. PDF
      • Software--Practice and Experience, Volume 11, June 1981, pages 541-605. Wiley Online Library
    • The Utah Symbolic Computation Group, Department of Computer Science University of Utah. Portable Standard LISP. Versions 3.1 and 3.2, circa 1982. Included as historical/psl-1983 subdirectory. Online at
    • Utah Portable Artificial Intelligence Support Systems Project, Hewlett-Packard Company, Herbert Melenk and Winfried Neun. Portable Standard LISP. Version 4.2. Included as psl directory of REDUCE Computer Algebra source distribution.
    • E. Karabudak, G. Üçoluk, and T. Yilmaz. Portable Utah Standard LISP, public release 6.1, June 1993. Online at



    • Utah Symbolic Computation Group. The Portable Standard LISP Users Manual. Technical Report TR-10, Department of Computer Science, University of Utah, March 1981.
      • PSL version 3, July 26, 1982. PDF
      • PSL version 3.2, March 16, 1984. PDF

      "Abstract: This manual describes the primitive data structures, facilities and functions present in the Portable Standard LISP (PSL) system. It describes the implementation details and functions of interest to a PSL programmer. Except for a small number of hand-coded routines for I/O and efficient function calling, PSL is written entirely in itself, using a machine-oriented mode of PSL, called SYSLISP, to perform word, byte, and efficient integer and string operations. PSL is compiled by an enhanced version of the Portable LISP Compiler, and currently runs on the DEC-20, VAX, and MC68000."

    • Herbert Melenk and Winfried Neun. Portable Standard Lisp Implementation for Cray X-MP Computers : Release of PSL 3.4 for COS. Technical Report TR 87-2, Konrad-Zuse-Zentrum für Informationstechnik Berlin, September 1986. Online at
    • J. B. Marti, A. C. Hearn, M. L. Griss, and C. Griss. Standard LISP Report. Date? Online at



    • M.L. Griss. BIL: A Portable Implementation Language for LISP-Like Systems. Operating Note No. 36, Symbolic Computation Group, University of Utah, 1977.
    • J. Fitch and J. Marti. A Small Standard LISP Interpreter. Symbolic Computation Group, University of Utah, 1978.
    • J. Fitch and J. Marti. SLISP - A Standard LISP Implementation in SDL. Operating Note 37, Symbolic Computation Group, University of Utah, March 1978. For the Burroughs 1700.
    • J.B. Marti and J. Fitch. SLISP, A Standard LISP Implementation in a High Level Language. REDUCE Newsletter, Vol. I, No. 2, April 1978, pages 14-17.
    • J. Fitch and J. Marti. SLISP - The B-Interpreter. Symbolic Computation Group, University of Utah, 1978.
    • Martin L. Griss, Robert R. Kessler, and Gerald Q. Maguire, Jr. TLISP – A Portable LISP Implemented in P-code. Proceedings of the International Symposium on Symbolic and Algebraic Computation, June 1979, pages 490-502. In E. W. Ng, Ed. Lecture Notes In Computer Science, vol. 72. Springer-Verlag, London, 490-502.
    • I.B. Frick. A Portable Lap and Binary Loader. Operating Note 52, Utah Symbolic Computation Group, University of Utah, November 1979.
    • Eric Benson and Martin L. Griss. SYSLISP: A Portable LISP-based Systems Implementation Language. UCP-81, Department of Computer Science, University of Utah, February 1981, (last revised 7 April 1981), 12 pages.
    • Martin L. Griss, Eric Benson, and Anthony C. Hearn. Current Status of a Portable LISP Compiler. Proceedings of the 1982 SIGPLAN Symposium on Compiler Construction, Boston, 1982, pages 276-283. ACM DL

      Originally appeared as Report UCP-82, Utah Symbolic Computation Group, Department of Computer Science, University of Utah, January 1982.

    • W. Galway and M.L. Griss. An Editor Interface for a Portable Lisp Programming Environment. Opnote 64, Utah Symbolic Computation Group, Department of Computer Science, University of Utah, January 1982.
    • I. G. Frick and R. Fogelholm. An Implementation of Standard LISP Built on Top of Franz Lisp. Institute of Physics, University of Stockholm, April 1982.
    • M.L. Griss. Some Notes on the Basic PSL Timing Tests. Opnote 66, Utah Symbolic Computation Group, Department of Computer Science, University of Utah, May 1982 (preliminary version).
    • Martin L. Griss, Eric Benson, and Gerald Q. Maguire Jr. PSL: A Portable LISP System. In Proceedings of the 1982 ACM symposium on LISP and functional programming, pages 88-97. ACM DL

      Originally appeared as Report UCP-83, Department of Computer Science, University of Utah, May 1982, 10 pages.

    • Tryg Ager and James McDonald. Yorktown LISP. Memo to Peter Hirsch, Institute for Mathematical Studies in the Social Sciences, Stanford University, July 26, 1983. PDF

      Ager and McDonald compared their new implementation of PSL on an IBM 3081 with the IBM Yorktown Research version of IBM's LISP/370. The PSL version was much faster and, they argued, more "mainstream".

    • R. R. Kessler, J. C. Peterson, H. Carr, G. P. Duggan and J. Knell. EPIC – a retargetable, highly optimizing Lisp compiler. Proceedings of the 1986 SIGPLAN Symposium on Compiler Contruction, Palo Alto, California, pages 118-130. ACM DL
    • Herbert Melenk and Winfried Neun. Portable Standard LISP for Cray X-MP Computers. Preprint SC 86-2, Konrad-Zuse-Zentrum für Informationstechnik Berlin, Dezember 1986. Online at
    • J. Wayne Anderson, William F. Galway, Robert R Kessler, Herbert Melenk and Winfried Neun. The Implementation and Optimization of Portable Standard Lisp for the Cray. Preprint SC 87-1, Konrad-Zuse-Zentrum für Informationstechnik Berlin, January 29,1987. Online at

      "A version of this paper appeared in the proceedings of the 20th annual Hawaii International Conference on Systems Sciences, January 1987. It has been revised to include the work of Melenk and Neun."

    • See also: [Padget 1988] under Cambridge Lisp Papers.
    • Mark Swanson, Robert Kessler, Gary Lindstrom. An implementation of Portable Standard LISP on the BBN Butterfly. Proceedings of the 1988 ACM Conference on LISP and Functional Programming, Snowbird, Utah, pages 132-142. ACM DL



    • Anthony C. Hearn. REDUCE. Website. Online at

      Bibliography, characteristics, documentation, available packages, related projects, and information about ordering latest release. In 2008, REDUCE was made available under an open source license.

    • Anthony C. Hearn. REDUCE: The First Forty Years. In Proceedings of the A3L 2005, April 3-6, Passau, Germany Conference in Honor of the 60th Birthday of Volker Weispfenning, Books on Demand. Online at


    Cambridge Lisp

    "Cambridge Lisp was developed in the period just after Lisp/370 and during the second phase of Standard Lisp, but before Portable Standard Lisp. The authors of Cambridge Lisp were individually involved in Standard Lisp and Lisp/370 and these experiences are reflected in the structure of Cambridge Lisp. As with Standard Lisp, Cambridge Lisp was borne out of a need to support algebra research but rather than following the Standard Lisp report word for word, there was a strong influence from the heavier emphasis placed on semantics by Lisp/370." [Padget 1988]

    Cambridge Lisp was written in BCPL. More recently, its authors produced a C-based successor under the Codemist brand.


    Source code

    • Codemist Standard Lisp. Included as csl directory of REDUCE Computer Algebra source distribution. Online at



    • J.P. Fitch and A.C. Norman. Implementing LISP in a High-level Language. Software Practice and Experience, Volume 7, 1977, pages 713-725. Online at
    • John Fitch and A. C. Norman. A Note on Compacting Garbage Collection. Computer Journal, Volume 21, Number 1, February 1978, pages 31-34. Online at Oxford Journals
    • Julian Padget and John Fitch. Closurize and concentrate. Proceedings of the 12th ACM SIGACT-SIGPLAN symposium on Principles of programming languages, New Orleans, Louisiana, 1985, pages 255-265. ACM DL
    • Julian Padget. Three Uncommon Lisps. Proceedings of the First International Workshop on LISP Evolution and Standardization, February 22-23, 1988, Paris France, Published by IOS, Amsterdam, 1988, pages 39-44. PDF


« February 2024 »
Su Mo Tu We Th Fr Sa
1 2 3
4 5 6 7 8 9 10
11 12 13 14 15 16 17
18 19 20 21 22 23 24
25 26 27 28 29

Powered by Plone CMS, the Open Source Content Management System

This site conforms to the following standards: