wat-js

Interestingly Wat implements a callstack in a userland VM, to implement it's delimited continuations. Ergonomically it would be good to implement algebraic effects on top, but the basis is there, along with demos of exception handling, branching, fibres etc. https://github.com/manuel/wat-js Obviously with forths the callstack is already in userland to implement these things, might be a bit brain-bending in forth.

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

Interestingly Wat (https://github.com/manuel/wat-js) handles Dynamic Variables, which fit well with serialized code, in that the serialization boundary can be better partitioned into variables you need to serialize (locals etc.), and environmental (dynamic) variables which are subject to their runtime env. Wat also happens to have a good concurrency model, and a portable bytecode. Worth looking at in this space.

One evolution of (You're probably aware of re:axisofeval) Kernel is Wat (https://github.com/manuel/wat-js), which implements the Vau operator (hygenic F-exprs), full delimited continuations (as opposed to the usual Shift/reset functionality of most lisp-based langs) and dynamic variables (variables which can break out of the usual lexical ie. compile-time scope and take environmental ie. runtime values). It's quite fast with all of that. The continuations allow you to define promises, threads, channels, exceptions, branching and so on. Thing is, syntatically the continuations are required to carry quite a lot. Algebraic effects layered on top would have a nicer syntax. Similarly, I would suggest that dynamic variables and continuations are more understandable in a forth-like language where the return and data stacks are first class. What'

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

I didn't think callCC can do multiple resumptions? DDBinding certainly can, and can do partial environment closures so you can migrate a process to a different machine as well: https://okmij.org/ftp/papers/DDBinding.pdf The above is succinctly implemented in wat: https://github.com/manuel/wat-js (also see forks for more documented versions).

I'll drop this here: https://github.com/manuel/wat-js If you have delimited continuations then you can construct coroutines/threads/await/async, promises etc. I guess that this might be suitable for many scenarios thanks to nodejs, but the runtimes it relies on are not exactly small.

Kernel and it's successor wat (https://github.com/manuel/wat-js) has some great stuff, I personally prefer open composition from maru https://www.piumarta.com/freeco11/freeco11-piumarta-oecm.pdf as it combines fexprs and macros into one construct.

https://github.com/manuel/wat-js/ https://github.com/shadowcat-mst/wat-pl

Early versions of wat-js used ["the", "same", "syntax"]. You might find it interesting. https://github.com/manuel/wat-js

Much more relevant is Wat[1], a lisp-like JSON based language by Manuel Simoni, with continuations, dynamic binding, macros and all the other lisp goodies. [1] - https://github.com/manuel/wat-js