Clojure is a serious contender.

To be sure, it's still niche but it has a good ecosystem, piggybacks on mature java libs, and has an active community.

It's thoughtfully opinionated, which I appreciate. Also clojurescript is almost the only front end dev experience I will tolerate.

The hot reloading is magic and it is gangsta as F to use the exact same logic on the fast jvm (or CLR if you're nasty) backend as in the js front end.

Common Lisp was created and used by the DARPA and its community of public research labs and private companies to support all kinds of industrial and scientific projects, I don't think there is more practical Lisp. It's fast both in compile time and runtime, supports any programming paradigm you want, and it's one of the most interactive programming environments ever. There are multiple open-source implementations, and there are at least two commercial implementations with paid support.

If you want to start, install the new IDE for Common Lisp called Lem [0] and follow the free online book Practical Common Lisp [1]. If you have any questions, the community can help you on Discord with the language itself [2] and the IDE [3].

[0] https://github.com/lem-project/lem/releases

[1] https://gigamonkeys.com/book/

[2] https://discord.gg/cuVpwZXJ

[3] https://discord.gg/sBYyjyC6

Emacs lisp is one of the worst lisps for most things, though it's a decent fit for its specific purpose.

People are suggesting clojure and clojure is great but it also has rigorous immutability semantics. If you're not familiar with that model you'll spend as much effort learning it as learning lisp, and it'll be unclear which things come from lisp weirdness and which from immutable weirdness.

Someone will also probably suggest racket, which has its strengths as a learning language but is also very large and complex, with numerous extensions to the core language that make it kind of a disorienting ecosystem.

I like janet a lot. It uses "normal" data structures as its primitives rather than the traditional cons cells. So if you want to understand and be connected to historical lisp it will feel very different, and be a poor choice. This also applies to clojure though now that I think of it. otoh if you just want to use parens & prefix notation and play with macros either will work.

common lisp is the most practical- its an industrial strength application language, gradually typed, very fast

it even includes the most complete oop system known to man which you can completely ignore if you want to and it'll still be the best choice

not that complex either, maybe halfway between lua and python?

there are some rough edges, which comes from being powerful and unopinionated, but they are trivially papered over as you work

What is practical depends on your goals. Clojure can do pretty much everything, though it's a bit less practical for things like high-FPS video games and desktop GUI.

My favourite right now is Chicken Scheme. Just the R7RS specification in general; the language is very minimal, yet has basically all you need. And Chicken has awesome C interop and a great little community on IRC in #chicken.

A Scheme, or Racket, which has the most packages of everything not Common Lisp.

I'd suggest Chez Scheme (the Racket fork if you've got an ARM Mac), that is fast and has (real) threads.