21

What LISP or LISP-like language compilers and interpreters were available for 8-bit microcomputers? Criteria for "8-bit" include that it should certainly run and execute non-trivial programs given no more than 64 KB of RAM, and ideally it should run in much smaller amounts of RAM or RAM+ROM, the just as the common 8-bit BASICs do.

In answers, the following information would be interesting to me:

  • Pricing information, if it was commercial software.
  • Historical and current availability of source and binaries.
  • The dialect of LISP (LISP1.5, MACLISP, Interlisp, Scheme, etc.) that the implementation is most similar to, if any.
  • Anything that's unusual about the language (special features, significant differences from a standard dialect it otherwise adheres to, etc.)
  • What kind of editor it provided, or what editors were expected to be used if none was.
  • Memory and offline storage usage.
  • Any interesting details about how it was implemented, or links to such.

I'm especially interested in implementations that have been used to write substantial programs (or large parts of them) and/or commercial software, though of course information about even "toy" interpreters is also welcome.

If you're not sure if a language is "LISP-like," one criterion you could consider is whether functions passed to other functions (as in map) is an easy and common idiom in it.

cjs
  • 25,592
  • 2
  • 79
  • 179
  • 1
    Generally speaking, LISP is not a compiled language - it is threaded-interpretive. The simple answer to this question is therefore none. Why do you specifically require information about LISP compilers. – Chenmunka Jun 02 '19 at 11:14
  • 1
    Please do not add additional answers; instead edit the existing, community wiki answer. – wizzwizz4 Jun 02 '19 at 11:18
  • 7
    @Chenmunka LISP compilers have existed from the start (Hart and Levin's compiler for LISP 1.5 in 1962, the world's first self-hosting compiler) to the modern day (Clojure), and as Wikipedia states, "most substantial Lisp systems also include a compiler" and "some Lisp systems compile every expression to native machine code." – cjs Jun 02 '19 at 13:14
  • 6
    @Chenmunka Particularly for smaller machines (which is of course what we're talking about here), a compiler may be required if one wants to write substantial programs in LISP. (L Peter Deutsch's PDP-1 port of LISP 1.5 was apparently not terribly usable for practical programs because there was simply not enough RAM left after the interpreter used its part of the 4 Kword (≃ 8-12 Kbytes) address space.) I'm particularly interested in non-toy implementations that might be used to write commercial sofware, so I'd definitely like to hear about compilers, if there were any. – cjs Jun 02 '19 at 13:21
  • @Chenmunka That said, I ask about interpreters, too; that's directly in the original title and first line of the post. Thus even were there only interpreters, the answer would not be "none." – cjs Jun 02 '19 at 14:24
  • 4
    @Chenmunka the whole "Lisp is interpreted" thing is a long dead myth and misunderstanding. – Will Hartung Jun 02 '19 at 17:27
  • 6
    @WillHartung: Anybody who knows the slightest bit about programming languages knows that compilation or interpretation are not traits of the programming language but the compiler or interpreter (duh!). I think it was Shriram Krishnamurthi who said that if English were typed, "compiled language" and "interpreted language" would be type errors. The question "Is Lisp interpreted" cannot even be answered with "No", since the question is fundamentally non-sensical. – Jörg W Mittag Jun 02 '19 at 21:37
  • 4
    The only sensible question would be "is this particular piece of code, running on this particular version of this particular implementation in this particular environment, at this exact point in time, currently being interpreted or has it been compiled?" Because, due to dynamic optimizations and hybrid execution engines, even the exact same code running on the exact same computer with the exact same version of the exact same implementation may at one time run interpreted and at another time run compiled. – Jörg W Mittag Jun 02 '19 at 21:39
  • I'm aware that there are full compilers for Lisp on many machines. My comment was aimed at the retro dsys when all, or almost all, Lisps were TILs. – Chenmunka Jun 03 '19 at 07:14
  • 5
    @Chenmunka It doesn't seem to have been the the case in the late 70s and early 80s, when 8-bit micros were most popular, that "almost all" Lisps were TILs, and I don't know if it was ever really the case. But if you're concerned, perhaps you could ask a question about that. (I makes little difference as far as this question goes, since I explicitly included interpreters in the question.) – cjs Jun 03 '19 at 08:27
  • 1
    Your experience is clearly more extensive than mine. – Chenmunka Jun 03 '19 at 09:02
  • 1
    FWIW, it seems the compiler was there from the start in LISP I, two years or more before the "new" LISP 1.5 compiler I linked above. See What was the first LISP compiler?. – cjs Sep 09 '19 at 03:47
  • Re, "the whole "Lisp is interpreted" thing is a long dead myth." A lisp program can cons up an expression (i.e., Lisp language source code) and then eval it at run-time. That feature is very much easier to implement IF the program is running in an interpreter. I think that when anybody says "X is an interpreted language" where language X has that same feature, what they're really saying is "I personally don't know how I could implement a run-time system in which eval compiles the given source to native code and then executes it on-the-fly." – Ohm's Lawman May 22 '20 at 16:19
  • 1
    @besmirched Or they don't understand that a language can be a mixture of compiled and interpreteted code, as the original LISP was. You can use an interpreted version of a function while developing, and compile it when you are done with developing that function. – cjs May 24 '20 at 05:22

3 Answers3

26

To volunteer a few:

Acornsoft LISP. First released in 1982 on tape, disk and ROM chip for the BBC Micro and rereleased as a cartridge for the Acorn Electron in 1984; possibly related to the Apple II's Owl LISP.

SpecLISP. Released in 1983 for the ZX Spectrum, a subset of Stanford LISP. It wasn't well-documented at the time, so is a little obscure. Includes Logo-style drawing functions.

Microsoft LISP. A CP/M product originally, later ported to machines including the 8-bit Apple II and TRS-80. Not just an interpreter, also a compiler (at least for the two 8080/z80 platforms).

Micro-LISP. A public domain LISP interpreter from 1986 for the Commodore 64 by Nick Vrtis.

LISP 64. Another LISP interpreter from 1986 for the Commodore 64 (author: Peter Feldtmann).

Inter-LISP/65 for Atari 8-bit computers.

PLisp for the Apple II.

cjs
  • 25,592
  • 2
  • 79
  • 179
Tommy
  • 36,843
  • 2
  • 124
  • 171
  • 7
    Community Wiki, as I haven't provided a great deal of detail and perhaps somebody else can. – Tommy Jun 02 '19 at 01:22
  • 4
    Microsoft Lisp :-o Now THERE would have been an interesting language for extending newer Microsoft products instead of VBA. – Thorbjørn Ravn Andersen Jun 02 '19 at 18:12
  • 8
    @ThorbjørnRavnAndersen: Microsoft has done a lot of cool stuff they never productized or abandoned along the way. They did the first Unix for PCs (Xenix), Windows NT started out as a very nicely designed OS that was highly portable (x86, PowerPC, Sparc, MIPS, Alpha, IA-64, ARM, AMD64) and had clear abstraction layers that allowed multiple "personalities" on top of the kernel (Win16, Win32, DOS, OS/2, POSIX), their Research Division is incredible (they employ Simon Peyton Jones, for example, lead designer of Haskell and GHC, and Tony friggin Hoare!), the Singularity OS was brilliant. – Jörg W Mittag Jun 02 '19 at 21:48
  • 1
    Over the past 10-15 years, they have been working to get Windows back into the shape it was when NT first came out, and ports to ARM, as well as stuff like Windows Subsystem for Linux are the result. I think it started with the XBox, which forced them to revive the abandoned PowerPC port. – Jörg W Mittag Jun 02 '19 at 21:49
  • My parents had a Lisp interpreter for the Commodore Pet. I can't remember what it was called though. – JeremyP Jun 03 '19 at 09:10
  • Microsoft LISP was originally called muLISP, created by Soft Warehouse (Honolulu, Hawaii) (see https://de.wikipedia.org/wiki/MuLISP and https://en.wikipedia.org/wiki/MuMATH). I played with it on CP/M in the 1980s. – Ralf Kleberhoff May 22 '20 at 14:40
8

The following answer isn't strictly speaking a version of LISP. That's why I didn't add it to the community answer.

ZIL, the Zork Implementational Language, was intended to allow interactive fiction games to run on desktops. ZIL was derived from MDL which, in turn, was derived from LISP. But ZIL wasn't really a full blown Lisp.

Infocom's original compiler for ZIL, Zorch, was never made publicly available, but there is also an open source compiler, ZILF, which includes a incomplete ZIL language description

cjs
  • 25,592
  • 2
  • 79
  • 179
Walter Mitty
  • 6,128
  • 17
  • 36
  • This answer is quite useful to me since I'm interested in any LISP-like languages especially if they've been used to write substantial and/or commerical programs for 8-bit micros. – cjs Jun 02 '19 at 13:35
  • 2
    @CurtJ.Sampson Okay, then another not-actual-Lisp non-answer would be Logo. This mostly-educational language was available for quite a number of 8-bit machines. – RichF Jun 02 '19 at 13:39
  • 1
    @RichF Wow. I just had a scan through the Apple Logo II Reference Manual; I had no idea that Logo was so LISPy, passing code blocks for IF etc. and with even the ability to rewrite its own definitions. That said, it doesn't seem to use the "passing functions to functions" idiom, as ZIL does, that would make it feel truly LISPy to me. – cjs Jun 02 '19 at 14:33
  • 1
    In fact DR LOGO was included with Amstrad disc-based CPC machines. However, LOGO is a long way sorry of being LISP, despite some great list processing functionality. – Mark Williams Jun 02 '19 at 16:11
  • https://www.google.com/url?sa=t&source=web&rct=j&url=https://en.m.wikipedia.org/wiki/Seymour_Papert&ved=0ahUKEwj0i6WBscviAhXDUt8KHQeVCPgQmhMIdjAN&usg=AOvVaw2If_CMO1XXuE8GQnwttbVB – Walter Mitty Jun 02 '19 at 18:07
  • The Logo thing should probably be its own answer, with an explanation of how it does and does not meet the criteria of the question. (This may also help me to clarify my question.) – cjs Jun 03 '19 at 01:24
  • 1
    Back to ZIL: further research makes it peretty clear that it is indeed a LISP at its core (it's basically a variant of MDL designed to execute code originally written in MDL with extensions). I am not clear on how much has been removed, but it's looking like it may have been too much to make this a general-purpose LISP. – cjs Jun 03 '19 at 01:26
  • MDL was really a language in the Lisp family. It implemented data types and arrays, but was otherwise pretty much like Lisp 1.5. – Walter Mitty Jun 03 '19 at 01:37
  • This post goes into some detail about which parts of MDL are missing from ZIL: http://blog.zarfhome.com/2019/04/what-is-zil-anyway.html?m=1 – Tara McGrew Jun 12 '19 at 17:56
  • 1
    In short, ZIL is a DSL implemented on top of MDL, such that the full expressiveness of MDL is available at compile time for macros and type checking, but the runtime environment has no garbage collector, so the compiled subset of the language has no dynamic allocation. – Tara McGrew Jun 12 '19 at 18:06
8

There was a variant of InterLisp for Atari 8-bit systems.

There was Gnosis P-Lisp for Apple II, which was very simple.

There were a number of Lisp implementations for Z-80 running CP/M.

And, straddling the 8/16-bit divide, there was Golden Common Lisp for IBM PC, which ran on 8088 (and runs nicely on my HP 95LX as a result) but actually was a real Common Lisp implementation.

Of course the various 16 bit systems got more “real” Lisp implementations, especially as memory available grew.

Chris Hanson
  • 732
  • 5
  • 11
  • 1
    I'm not actually interested in (most?) 16-bit implementations, and this helped me figure out why: "small memory" turns out to be an integral characteristic I'm looking for. So thanks for helping out with that. The two implementations you linked are helpful. – cjs Jun 03 '19 at 06:07