ferret

Ferret is a literate program! Check out the source/manual, it's quite a trip: - https://github.com/nakkaya/ferret/blob/master/ferret.org - https://en.wikipedia.org/wiki/Literate_programming

Seems like there has been no development since 2020 - https://github.com/nakkaya/ferret

The whole of ferret's source code is in a single org-mode file, following the literate programming style: https://github.com/nakkaya/ferret/blob/master/ferret.org

> I just with there was a Lisp like it that didn't run on the JVM. There are a few, with varying degrees of distance from the JVM and varying degrees of similarity to Clojure. - There's ClojureScript, which is Clojure transpiled to JavaScript. - See also Lumo (<https://github.com/anmonteiro/lumo>) and Planck (<https://planck-repl.org/guide-all.html>) - There's Babashka (https://github.com/babashka/babashka), which is a natively-compiled Clojure interpreter, implemented with the Small Clojure Interpreter (https://github.com/babashka/sci) and GraalVM for native compilation. - There's Joker (https://github.com/candid82/joker) with a similar mission to Babashka, but commonly used as a linter. - There's ClojureCLR (https://groups.google.com/g/clojure-clr) on the Common Language Runtime. - There's Cloture (https://github.com/ruricolist/clot

Another commenter already mentioned Gambit Scheme. That provides for inline C and therefore very easy interop with external libraries. It still has a runtime and GC though - those might pose a problem depending on your platform and task. Ferret (https://github.com/nakkaya/ferret) and Carp (https://github.com/carp-lang/Carp) are both Lisp-like low level languages. Both seem to be fairly experimental in nature though. > anything but C Taking you literally, Rust and D can both compile for bare metal. D in particular has a "Better C" subset. (https://dlang.org/spec/betterc.html) In the same vein, Terra is a C like language (manual memory management) that you metaprogram with Lua. (https://github.com/terralang/terra) Taking you very literally, Forth is also an option.

Another one for the Clojurists - https://github.com/nakkaya/ferret which compiles down to c++11. Though it doesn't offer a real lisp REPL or eval, so it's not a meaningful comparison with uLisp.

> it's not a great modern language for a lot of internet or IO stuff I think Clojure is a great language for internet stuff and possibly great even for IO stuff too, depending on what you mean by that. The LISP-iness is probably better for the former but builtin Java interop probably goes a long way towards being pretty-good for the latter. What exactly were you thinking-of by "IO stuff"? Graphics? Embedded systems programming? I'd think Clojure could be just as good as Java or Python for all of those, tho existing libraries aren't going to be quite as good as C/C++, and Go will probably be better-performing generally. And there are (because of course there are) LISPs for real-time embedded systems programming: - [nakkaya/ferret: Ferret is a free software lisp implementation for real time embedded control systems.](https://github.com/nakk

You might want to look at Ferret (https://github.com/nakkaya/ferret), which compiles a subset of Clojure to C++, it could be useful to help you understand. It's also written in a literate style, so it's also well-explained.

The vid made me smile :) Yes, maru was conceived as part of the STEPS program, to provide a minimal runtime base for an OS. As such it's focus was on being able to produce DSLs for a higher level of abstraction, and hence needed to provide the ability to extend composition (http://piumarta.com/freeco11/freeco11-piumarta-oecm.pdf). Personally I've been interested in replacing the GC part of maru with a structural method of managing memory (http://concurrency.ch/Content/publications/Blaeser_ETH_Diss_...), this would require extending the language with the Composita primitives, but not really sure how this'll go yet. The Lumen-C compiler sounds good! Yes the tricky part is the self compilation, I'm wondering if you'll just end up with a maru-like system if you follow this down? Alternatively the other way of doing this is via an explicitly g

I'm grateful for the interest! Not really thought about a location - I'll probably use my github account when I've got some material, and ping you when it's there. As an aside, most of the stuff I've on my account is higher level eg. https://github.com/alexisread/noreml deals more with a new method of visually programming cross-plaform UIs ie. using nodered dashboards and flow-based programming in a drag and drop fashion. Main influences at the moment are Maru, Composita, Ferret and Maude: http://piumarta.com/software/maru/ http://concurrency.ch/Research/Composita https://github.com/nakkaya/ferret http://maude.cs.uiuc.edu/overview.html

well that is very cool. Unfortunately the original HN posts title failed to mention that was meant for embedded control systems which is probablly why I missed reading it! The HN post can be found here :- https://news.ycombinator.com/item?id=14951116 and the literate source code is here ... https://github.com/nakkaya/ferret/blob/master/ferret.org

> imagine keeping code in Emacs's Org mode and being able to compile it. Something like this https://github.com/nakkaya/ferret The whole source code is in literate form in one org file.

Do you not see all the source code in https://github.com/nakkaya/ferret/blob/master/ferret.org?

ALL of the code seems to be stored inside the org-mode file, https://github.com/nakkaya/ferret/blob/master/ferret.org - which is the most unusual form of source code organization that I have ever seen.