vonuvoli-scheme VS racket

A few years ago I've written my own (still experimental) in Rust:

https://github.com/volution/vonuvoli-scheme

Racket: 16

I used Racket a few times, which is designed to write new languages. Well worth a look: https://racket-lang.org/#easy-dsls

Oversimplifying, there are three big variants: Common Lisp, Scheme, Clojure. Each of them has a lot of somewhat similar implementations:

* Clojure: A lot of support for immutable data. It runs in the JVM so you will have a lot of the libraries you are use to. Probably the best option for you. https://clojure.org/

* Scheme, in particular Racket: Mostly functional, and in particular Racket has a lot of support to make your own variant. This is the option I prefer but I have to disclaim it's a biased recommendation. https://racket-lang.org/

* Common Lisp: I heard a lot of good things about SBCL, in particular to add anotations to make the code faster https://www.sbcl.org/

> why this language is so special

Macros, everyone use macros, too many at the beginning, but a few where they are really necessary later.

  #lang racket

This reminds me a bit of the octree quantization implementation I hacked up to improve speed of generating Racket's animated gifs.

* https://github.com/racket/racket/commit/6b2e5f4014ed95c9b883...

Racket! https://racket-lang.org/

“Whenever an engineer changes one of these programs, we run all the programs through our custom model checker (written in Racket + Rosette)”

- pipe operator

It compiles to either erlang or JavaScript, so I was able to jump right into building something fun with a new language.

>I previously gave Clojure a try, that was a pretty good fit, but the JVM / ecosystem put me off.

I felt similarly w/ leiningen (too much boilerplate) but was lisp-curious still so gave racket (https://racket-lang.org/) a try and appreciated the batteries included philosophy of the standard library and was inspired to learn more about writing a programming language (also see: https://beautifulracket.com/)

Biased recommendation: Try racket https://racket-lang.org/ It's not pure functional, but the preferred style is to use mostly functional constructs. (But you can cheat when it get's too difficult or you need some extra speed.) (And you can download packages like Qi that enable a new language inside Racket that has more support for functional style.)

(Most Schemes have a similar mostly-functional style, so you can also try one of them.)

It's a replacement for make, but definitively not a drop in replacement. To understand why, it's better to read the initial announcement/pull-request by Matthew https://github.com/racket/racket/pull/4179