I had a chance to sit down with Mr Sorensen some years back and talk PL design.

I can easily recommend Extempore (xtlang) especially if you're a bit more advanced programmer. The underlying core is a tasteful mix of C-aligned semantics (think LLVM) that manifests as S-expressions with the usual goodies. It is statically typed with inference.

Another forte is scheduling via temporal recursion.

It has a solid memory allocation strategy, via memory arenas, oriented to high performance and low latency. Higher level constructs like closures can live in arenas. You can also introduce some custom dynamic cleanup routines for RAII-like behavior.

I seriously think it could work well outside of its niche as well.

I’ve tried several live audio programming languages (though not to any great extent), and have found Extempore to be easily the best. It’s the only language I’ve found which lets me control both the low-level details of synthesis and the high-level details of musical structure, and — more importantly — edit them both live. The low-level language is C-like and statically typed with all the advantages that brings, and as a Haskeller I find it intuitive to structure the high-level details around recursion (in Scheme in this case). My only real frustration with it is the lack of documentation, though the source seems pretty readable. (That, and the fact I haven’t found anything to use it for yet!)

Have you tried out the ChucK language? I haven't tried Extempore yet, but it looks like the way they handle timing could be similar. ChucK has a very elegant system for synchronizing synthesizers and sequencers where you can write code in a simple imperative style (within a sequencer you can "wait" until the next note needs to be played). The language runtime keeps all of the coroutines running in sync with a global clock. I don't know of other languages that use this style of timing, so I'd be very curious to hear how they compare.

What is "cyberphysical coding"? I didn't see any definition on the website, and no, I haven't seen any live examples of it either. It sounds cool, but from looking at this site, I have no idea what they are talking about.

See https://en.wikipedia.org/wiki/Cyber-physical_system and https://en.wikipedia.org/wiki/Extempore_(software).

Here are some lectures: https://www.youtube.com/watch?v=yY1FSsUV-8c, https://www.youtube.com/watch?v=GSGKEy8vHqg

I've had the pleasure of watching Andrew Sorensen perform with Extempore multiple times. The improvisational and creative musical capability of Extempore is astonishing.

Interesting, I haven't seen a lot of Lisps with static type inference. The language seem very interesting, especially the multi-threading.

There used to be an emacs/lisp library that did this, does anyone remember the name ?

Overtone? https://overtone.github.io/

Overtone was/is Clojure over SuperCollider. There are a number of other similar lisp things though. Incudine might be the one you're thinking of?

Nyquist [1] is a XLisp derivative that shares temporal recursion with Extempore. Not sure it had any connection to Emacs though.

1: https://www.cs.cmu.edu/~music/nyquist/

Yeah Nyquist is cool too, just got the book. I believe Common Music preceded both Extempore and Nyquist in that regard, and also uses a TinyScheme descendent, s7 Scheme. I use s7 in Scheme For Max for temporal recursion too.

Demo of temporal recursion in Scheme for Max here: https://youtu.be/pg7B8h4yHkU

And my tutorial on it: https://iainctduncan.github.io/s4m-stk/

That is what I was thinking of yes! Thank you.