I've been seeing a lot of stuff like this over the last few months. (Mostly because I've been looking for it.) The tagged memory possibilities in RISC-V and aarch64 v8.5+ architectures, combined with the natural suitability for vectorization that lisp programs seem to have make the Lisp machine a natural fit, and IMHO something that will come to us sooner than later. I'm very excited to see these and work on them, and intend to throw my own hat into the ring on it, sooner rather than later.

Maybe I'll start a blog. Anyway, godspeed lisp hackers!

I sure hope so! Mezzano has been great fun to follow progress on. Though its seems covid killed the project as it hasn't had a prebuild image update since 2020.

> Lisp is known for its overwhelming parentheses…

I have never understood this common perception. They are so common you don’t really notice them.

What does weird me out about most other languages is the semicolons, and even more, the distinction between statements and expressions.

The emulator for the MIT Lisp Machine doesn't take hours to boot and it seems to run stuff at similar speeds to the real hardware.

I would suggest that anyone contemplating a new system take a really good look at how the MIT Lisp Machine was implemented, maybe look at the K-Machine sources afterwards for a possible way of using native code.

Lisp Machines, Plan 9, Forth, RISC V- this may be the most Hacker News post ever.

It also include the messianic lisp resurrection comment. We are entering the HN 10th bolge.

We can use it to create a zettlekasten system.

(10th bolge == 10th level of Hell)

> Since Lisps stand over heavy usage of list data structures, it is only natural that someone would want fine-tuned hardware to deal with those, so these machines carefully reduced execution costs with specific hardware, CPU instructions, and specific memory management.

Kind of, classical Lisp as it was born, yes.

The Lisp Machines variant, as well as Common Lisp, provide all the features of regular programming languages, structures, arrays, stack allocation.

I'm puzzled about the forth layer. I'm pretty sure the lisp machines I used were sexps all the way down to assembly, and was really quite nice. to be able to address any layer of the stack from the repl really.

Almost all the ones that I know of compiled Lisp to an abstract instruction set, then had an interpreter for this written in assembler. The GC was also written in assembler. The SCHEME-79 chip [1] was sexps all the way down.

If you were doing it today with the same hardware then writing a LLVM backend for the hardware instruction set might be a useful first step. You could then write the abstract instruction set interpreter and GC mostly in C.

[1] https://dspace.mit.edu/handle/1721.1/6334

This caught my eye. It could be a great template engine:

"I've been discussing a lot with friends about the possibility of "web" pages built using S-expressions instead of HTML itself."

As an actual HTML templating technique, this idea has been around a long time. e.g. see CL-WHO.

It would be cool to see a RISC-V implementation with Lisp specific instructions!

I wonder though if you would get a speed bump fast enough to make it worthwhile.