lumo VS janet

Is this similar to Lumo (https://github.com/anmonteiro/lumo)? I would assume Lumo has a faster start time since it boots from a V8 snapshot, but otherwise I'd assume the two projects are similar (except that, of course, lumo is EOL)

Lumo: a standalone ClojureScript environment, runs on Node.js. Doesn't seem to have its own reader conditional, uses :cljs.

Lumo and Planck (standalone Clojurescript environments, based on Node and on JavaScriptCore with some additional functionality to make it suitable for scripting, respectively), and Clojerl (Clojure implemented on BEAM). Startup times are comparable to e.g. Racket.

I first came across something like this in janet, which includes a PEG system in the standard library. It definitely changed how I think about text processing. Very much of the time what I find myself doing with regex is defining a grammar, but I didn't realize that. I wish more languages included the tools for it, it's a core operation of practical programming.

https://janet-lang.org

...I of course would rather embed Janet [1], but I realize what is going to have an easier time gaining popularity %) Also, Lua has Löve [2] which could be immediately usable, among other things.

[1]: https://janet-lang.org/

[2]: https://www.love2d.org/

I don't think it has absolutely all that, but janet might be close?

https://janet-lang.org/

> Would you write your own JSON parser, is it that easy in LISP?

I only dally with Lisp(s) but probably not, I'd reach for a library in quicklisp.

However, in Janet (https://janet-lang.org/) there's a PEG parser and I wrote a JSON parser for fun in 134 lines that passes most of the test suite by Nicolas Seriot.

So I'd say it's reasonably easy for a better-skilled programmer than I am.

Only tangentially related, but for anyone interested in the idea of a simple, quick Python-like scripting Lisp, there are two Clojure-style languages to look at:

1) Hy (https://hylang.org/, compiles to Python bytecode, usually slower than Python but compatible with all Python libraries)

2) Janet (https://janet-lang.org/, very light Lua-style embeddable VM ~1 Mb, roughly twice as fast as Python for similar ops, very easy C interop)

Seems like a perfect use-case for Janet. (https://janet-lang.org/) A fast minimal VM like Lua, but even more extensible than Lua by being a "Lisp" with macro and C extension capabilities. Not a true Lisp, it's very pragmatic and performance-oriented. But it keeps the good stuff.

You might be looking for: https://janet-lang.org/

It comes with a build tool `jpm` which installs dependencies globally by default, but you can have it be installed in your project folder as well.

I like Clojure, but I never had any good opportunities to use it other than for a few small hobby projects. It is unfortunate that it is so huge with tons of dependencies and no simpler native implementation. I started looking at various LISPs and Schemes to find something lighter to use instead and ended up settling for Janet that I think is Clojure-like enough to be comfortable to use, but in a small native binary with no dependencies and can be embedded in other native programs. I am sure for big, real, projects that Clojure makes more sense, but for my hobby projects and scripts I do not think I will install it again. I am still happy for the things I learned from learning Clojure. It was a real eye-opener for an old OO-programmer.

https://janet-lang.org/