Carp

You can build a Lisp to stay close to the metal with zero-cost abstractions. Most people drawn to Lisp are wanting productivity instead of max performance. Besides, the commercial Lisps and fastest in FOSS are really fast. There was a systems type of Lisp called PreScheme that was closer to what you're envisioning. Carp also aims at no-GC, real-time use. Finally, ZL was C/C++ implemented in Scheme with both their advantages compiled to C. Although done for ABI research, I've always encouraged something like that to be done for production use with tools to automatically make C and C++ library bindings. https://en.wikipedia.org/wiki/Scheme_48 https://github.com/carp-lang/Carp http://zl-lang.org/

Not exactly lisps, but Carp (https://github.com/carp-lang/Carp) and Scopes (https://bitbucket.org/duangle/scopes/wiki/Home) might be worth a look. I haven't tried the former, and couldn't get the latter to do anything useful, though. (it looks like the author stopped responding to issues, sadly).

Check out Carp: https://github.com/carp-lang/Carp

Very interesting, and thanks for answering. Could I ask what kind of project it is? I wonder if I'm just lucky that Clojure fits perfectly my use case, which is mostly a set of distributed systems of all kinds. So while as a whole there's tens of thousands of LOC. The components have very strong boundaries being as it's a set of services assembled together through RPC, PubSubs and DBs. Maybe that alleviate the lack of a static type checker. We've adopted Clojure about 3 years ago, team of 10. We've had a few people leave and join throughout. Only one person knew Clojure beforehand. Our stack is about 50% Clojure, 40% Java and 10% Scala. Of all three, Clojure has given us the least issues, has been pretty easy to maintain and generally has fewer defects. Java tend to have the most bugs, almost always related to some shared state. Scala I f

At a first glance seems similar to Carp [1] and Scopes [2]. [1] https://github.com/carp-lang/Carp [2] https://bitbucket.org/duangle/scopes/wiki/Home

Well, Go seems to have enabled a new wave of software renaissance - Kubernetes, Docker, you name it - Go seems to have filled the space that Java was too fat for, JavaScript too light for, and C/C++ too difficult/fun-less to use for (which is everything). After 20 years of coding, and having just recently discovered LISP and learned Clojure, I believe the perfect language will be a Clojure compiled to native with the ease of Go (e.g. w/ similar import system). One such direction seems to be Carp (https://github.com/carp-lang/Carp), but I haven't tried it yet.

The borrow checker comes with different trade-offs though, which I personally find, for many applications, the immutable data-structure + atomic references with GC route (or values over time semantics) is a better fit. The way you are forced to model things so that the borrow checker can successfully validate your code can often be frustrating, and it also comes at the cost of slow compile times and interactive programming, which Clojure is kind of a champion at, so I'm not sure it would be a good fit to add a borrow checker to it. I love the borrow checker for manually managed memory though, and for programs that need that kind of performance and tight memory usage, it is great. I've been following along the development of Carp because of that and my preference of Lisps: https://github.com/carp-lang/Carp

It is actually already in the list of research subjects in the docs folder of carp: https://github.com/carp-lang/Carp/blob/master/docs/Research....

I've not used it, but https://github.com/carp-lang/Carp/blob/master/docs/Manual.md seems to have details on integrating with C codebases, including exporting your code as a dylib.

Tangential question, but what Lisp is the most promising one to invest time on right now? Common Lisp still has some activity, mainly coming from SBCL, but is a bit stagnant. It has a fantastic literature and many mature implementations. Scheme is great, but a bit too fragmented. Racket seems to be gaining some momentum. The merge with Chez may be the tipping point to attract a critical mass of developers. Clojure has many interesting modern ideas, but I feel being so tied to Java and the JVM has hurt a bit in the long run. I miss a bit of innovation in the typed lisp area, like e.g. Qi or Shen which never took off. Carp [1] looks nice. [1] https://github.com/carp-lang/Carp

Re statically typed Lisp, I’m keeping an eye on Carp [1] which seems to be a quite active project. [1] https://github.com/carp-lang/Carp

If you like Rust and Lisp this is also a cool project: https://github.com/carp-lang/Carp.