Together with some other people, I've built a Uiua track on Exercism: https://exercism.org/tracks/uiua/ It has 90+ exercises which makes for a lot of fun content.
The stack makes it feel completely different from the other array languages. Instead of using infix functions with reusable variables, code runs RTL (for various reasons https://www.uiua.org/docs/rtl) and you can manipulate the stack with the various primitives, which I find nicer than the other array languages (APL, J, BQN, etc...).
Once you get a hang of the glyphs and their meanings you can really start writing code, which turns out to be very readable due to the colors the language gives to glyphs and user-defined functions, as well as the simplicity of how the stack works and how the language is designed overall.
I love the unicode glyphs and the color coding which makes it much more readable. I might take a look at the Exercism track.
I wonder if this might make for a nice embedded array DSL in order languages? In particular could this compile into numpy or Jax expressions?
It's difficult for me to express just how fun Uiua can be to use. It's rather like one of those Zachtronics games - both in that figuring out how to fit your task into the array-programming model can be a bit of a puzzle sometimes, and in that once you've done that it's an extremely quick and non-frustrating process to make it work. The pure essence of what makes programming enjoyable, for better and for worse. There's also just a lot less plumbing and documentation-reading involved; the flexibility and terseness of the glyphs means that a lot of things you might have to call out to a standard library for in other languages you can Just Write because the entire implementation could easily be of length comparable to the name. (There's also a lot less plumbing and documentation-reading involved because there's only, like, four Uiua libraries anyway. Less to plumb together. Like I said, what makes programming enjoyable, for better and for worse.)
(Why Uiua and not, like, APL? I actually find APL enormously more difficult to read, due to the syntax - APL glyphs have two context-dependent readings, depending on whether they're being used as an binary infix or a unary prefix, and figuring out how the parse tree breaks down when squinting at a sea of glyphs is painful. It's like a whole language of garden path sentences. Uiua glyphs have fixed arity and always mean exactly one thing; so there's twice as many glyphs, but parsing by sight-reading is way more straightforward.)
OpenGL did it first. :)