paka VS passerine

I think bins/boot.bc in the paka repo is a minivm binary file that does bootstrapping for paka.

Personally, I find it pretty impressive that it performs as well as these runtimes despite not having a JIT compiler. I'm pretty sure Shaw's written more benchmarks, but as the README explains, it's really hard to tell what the performance characteristics of a language are without writing a larger application. So far the largest applications written with MiniVM is Paka[0], a self-hosted language similar to Lua that targets MiniVM; os49[1], an operating system built on Paka/MiniVM in the spirit of lisp machines; and xori[2], an online playground for the language.

[0]: https://github.com/FastVM/paka

Some similar languages from this community: my Paka (even down to the println), and someone else's Cthulhu.

It's still a long way from being complete, but I'm working on something like that[0]. Eventual plans are to have good Rust library interop (e.g. bindings to hyper for http) while also being able to compile to Wasm (to run on an erlang-style distributed runtime / the browser). The language is currently interpreted, but one I get typechecking working, I should be able to merge in the Wasm codegen backend I'm working on (with eventual plans for LLVM). Current compiler has zero external dependencies.

Language itself could be described as a mix of OCaml, Scheme, and Lua. Currently working on the hygienic procedural macro system and system injection through algebraic effects.

[0]: https://github.com/vrtbl/passerine

Passerine was the next language i decided to try to fit onto paka, but alas this one too was eventually put aside for the time being.

Tossing my hat in for Passerine [1]. Gorgeous ML inspired syntax. Built for scripting Rust applications.

Dreaming here: Lua is a fantastic scripting language, but the Rust FFI isn’t as ergonomic as it could be. Enter Luster [2], which is basically LuaJIT rewritten in Rust.

Embedding a scripting language in a Rust application gives you tons of power (e.g. scripting Rust structs from Lua [3]), and setting this up isn’t terribly difficult.

[1] https://github.com/vrtbl/passerine

[2]: https://github.com/kyren/luster

[3]: https://git.sr.ht/~ioiojo/kiwi

Seed7 and https://github.com/vrtbl/passerine (and seemingly more as others have suggested) have direct / first-class support of syntax declaration/definition in a homoiconic way, as powerful as LISPs, but feels more "natural" compared to a LISP.

It used to work pretty well only if the core PL makes semicolons programmable, but given the development of effect systems, plus customizable syntax as in https://github.com/ThomasMertes/seed7 and https://github.com/vrtbl/passerine , I'd say, there are much more we can do about it.

git clone https://github.com/vrtbl/passerine