maru

that's an often repeated misconception about lisps. lisps are pretty good at low-level programming, but then you'll need to make some compromises like abandoning the reliance on the GC and managing memory manually (which is still a lot easier than in other languages due to the metaprogramming capabilities). there are lisps that can compile themselves to machine code in 2-4000 LoC altogether (i.e. compiler and assembler included; https://github.com/attila-lendvai/maru). i'm not saying that there are lisp-based solutions that are ready for use in the industry. what i'm saying is that the lisp langauge is not at all an obstacle for memory-limited and/or real-time programs. it's just that few people use them, especially in those fields. e.g. i'd easily prefer a lisp to put together a specialized byte-code interpreter to shrink firmware size f

Have you looked at Kernel and wat? They use a fundamental operator (vau) to make macros, instead of a special form: https://github.com/manuel/wat-js maru has this vau operator implicitly, rather than explicitly: https://github.com/attila-lendvai/maru

You might want to take a look at the piumarta branch of https://github.com/attila-lendvai/maru/tree/piumarta This is Attila's attempt at more formally evolving maru through several iterations, and includes gezeira etc. Personally I find able forth's meta compilation to be more manageable (https://github.com/ablevm/able-forth/tree/current) But your mileage may vary :) Disappointingly, the able gui etc was not open sourced, and I fear lost to time.

This is what the the COLA papers talk about as you're aware, a REPL where you can modify, recompile and use the environment dynamically. Smalltalk is also similar in this regard, with a nicer UX. One of the reasons why this style has not taken off (image-based) is that its very easy to lose track of changes while developing - there's no formal iteration boundary. This guy https://github.com/attila-lendvai/maru Has been experimenting with git branches for this. https://github.com/crcx/retroforth/blob/master/doc/RETRO-Boo... talks about this issue, and the Retroforth author's attempt to define more clean boundaries.

Well Forth is possibly the most minimal VM over a platform, as evidenced by openfirmware. It does have problems scaling though, in that if you've seen one Forth, you've seen one Forth ie. The variations required to fit a platform make them semi-incompatible. Also, only global scope, no types and no built-in threadsafe constructs are limiting. That's not to say that a more lispy Forth wouldn't be useful though, in that a concatenative syntax allows us to pass custom datastructures around like APL, and CPS (delimited continuations with lexically scoped dynamic binding would come from the lisp side (see https://github.com/manuel/wat-js). Memory management in Forth can handle multiple memory types eg. https://flashforth.com/ so adding something like ref counting (https://github.com/zigalenarcic/minilisp/blob/main/main.c) to handle the dynamic

It's a shame the maru compiler didn't get a mention: Self-hosted (x86) in 1800LOC, bootstrapped from C-maru compiled with gcc or clang, 70% the speed of C with gcc. Current maintainer is Attila Lendvai https://github.com/attila-lendvai/maru/tree/piumarta

Here's another interesting one I just noticed: https://github.com/attila-lendvai/maru/blob/maru.10/source/a...