If you find Lisp to C compilers interesting, then Common Lisp has a bunch for you. The first CL to C compiler was KCL (Kyoto Common Lisp from Japan in the mid 80s). It is the parent for several other compilers.

Gnu Common Lisp, Embeddable Common Lisp, mkcl, mocl. There are also attempts at C++ as a target language. See CLASP.

https://www.gnu.org/software/gcl/

https://common-lisp.net/project/ecl/

https://common-lisp.net/project/mkcl/

https://wukix.com/mocl

https://github.com/drmeister/clasp

Cool, but then you have to actually deal with Common Lisp, which is not the kind of lisp that interests me. The more functional-oriented lisps like this Owl, and Clojure, are quite different in many ways from CL.

I agree that Chicken is based on a brilliant idea that turned out to work really well in practice. It's a very practical language / implementation.

It's my favorite Scheme. It's minimalist, but practical, and usable for Real Work. It's everything I like about Racket, without all thinks I don't like about Racket (Racket's a fine language, it's just not my thing).

It is not practical enough for me to have a language which does not support native threads.

Only Guile does that, AFAIK. And Chicken's threads are perfectly usable in most cases. And you can always fork(2), if you really want to.

And as I read it sometime ago while searching for Scheme implementations with native threads, Cheney on the MTA is inherently single threaded.

Not necessarily, it can be extended to support multithreading:

https://github.com/justinethier/cyclone

Cyclone is a new Scheme with native threads that uses cheney.

There are ways to use native threads with Chicken; it's a bit hairy, though.

Chicken 5, the upcoming partial rewrite, is worth keeping an eye on.

I've got an upcoming talk at EuroClojure on the subject:

http://euroclojure.org/speakers#mreitzenstein

Taking advantage of immutability and using clojure.spec generators at the top level, it specializes/simplifies the code using really simple transformations.

Demo of the specialization here:

http://reitzenwebserv.s3.amazonaws.com/opt/index.html

How does Chicken compare to Gambit?

http://dynamo.iro.umontreal.ca/wiki/index.php/Main_Page

https://github.com/gambit/gambit

The perf is generally comparable (each has optimizations the other does not, although gambit is a bit faster in the general case), but Chicken has really fast call/cc. Also, Gambit has a very small library collection, especially compared to Chicken's, which is among the best of all the schemes, Library-wise. Neither supports native threading, and Chicken isn't fully re-entrant, which can lead to some problems integrating some libraries. Both have excellent FFI, but Chicken's is a bit better, IMHO.

What's so novel about Chicken's GC? Cheney on the MTA is quite clearly novel (Chicken compiles to CPS and essentially GCs its stack frames IIRC, making call/cc as fast as any other procedure call), but the algorithm itself is quite ordinary, IIRC.