arpilisp

If you mean "Lisp" interpreter, then I also did something that's kinda what you're describing: https://github.com/marcpaq/arpilisp

Just for completeness sake, here's "arpilisp: A Lisp interpreter for Raspberry Pi implemented in a single ARM assembly file" : https://github.com/marcpaq/arpilisp *Includes the classic mark-sweep GC from McCarthy 1960

And here's a Lisp written in ARM Assembler :) https://github.com/marcpaq/arpilisp

Agreed. BYOL and MAL are excellent work. I had fun making an interpreter in ARM assembly: https://github.com/marcpaq/arpilisp Since the world obviously needs another book on Lisp-making, I'm thinking of porting it to arm64 and expanding it into a book.

This is my fav: https://github.com/marcpaq/arpilisp

An only slightly altered version for Raspberry Pi/ARM assembly: https://github.com/marcpaq/arpilisp

If you like this, you might like Lisp interpreter written in assembly in a single file. It is one of the best commented code ever written imo. https://github.com/marcpaq/arpilisp

I just saw this come up in an arpilisp discussion thread (https://github.com/marcpaq/arpilisp). ChrysaLisp is an Assembler/C-Script/Lisp 64 bit OS. MIMD, multi CPU, multi threaded, multi core, multi user, and will build from source in ~2 seconds on most OS X or x64 Linux desktops. Maybe this will let me live vicariously through someone who has actually built the project I always dream of creating in my free time.

The irony of implementing Lisp in assembly is that, almost for free (sorry about that), you get precise, convenient control of the memory situation. Just put the gc root exclusively in registers. I wrote a Lisp interpreter in assembly that dedicates 4-5 registers for the current expression, eval environment, and so on. The mark-sweep collector starts from these registers. https://github.com/marcpaq/arpilisp

It starts you from scratch and I'd say it's well done, maybe even be overdone for Lisp. But you get a good introduction to the essentials of language implementation for more complicated languages. Shameless self-promotion: I wrote a Lisp interpreter in a single assembly file for Raspberry Pi. It also starts from scratch at an even lower level, to the point of ignoring standard libraries. https://github.com/marcpaq/arpilisp I was inspired by jonesforth, which, if you haven't read it, is a beautiful piece of work.

Funny you should say that: https://github.com/marcpaq/arpilisp

(Somewhat of a repost, but I'm a fan of these things.) I had the same feeling, so I tried it out myself. Inspired by Jonesforth (highly recommended), I wrote an arguably complete Lisp interpreter in a single, heavily commented ARM assembly language file. Lisp is an obvious target, with its minimal syntax and simple concepts. The first Lisp was written in assembly on a machine with comparable capacity to your laptop keyboard's microcontroller, after all. I hope you find it useful: https://github.com/marcpaq/arpilisp

This is brilliant! I've failed more than once to wrap my stupid brain around lisp but after reading your code, something clicked. I dare say I think I get it! https://github.com/marcpaq/arpilisp/blob/master/arpilisp.s It's all extraordinarily clean and clear (and must set a new world record for most thorough comment --1120 lines!)