When I started focusing on Scheme as an elegant Lisp for a rapid R&D platform (Web, AI, programming languages, etc.) ~20 years ago, Kawa was one of the implementations on which I tested my libraries.
I'd been using Java previously for research prototypes, Java was getting popular, and Kawa's property of running on the JVM seemed potentially practically very useful or critical, and I wanted it in my pocket.
I ended up moving primarily to PLT Scheme (aka Racket), but I would (and still do) always tell people about keeping some of the special Scheme implementations as backups. Kawa for JVM, Gambit for large numbers of threads and other properties, Chicken for its C compilation approach and significant community.
I think the JVM aspect was one of the keys to Clojure achieving more popularity than Racket. Though Clojure was also led from the top with a better command of industry application, and also focused outreach on the wealth of Common Lisp (CL) (sometimes called simply "Lisp" without qualification) developers, who as a whole seemed to be more seasoned veterans than our average Scheme/Racket developer. (Whereas Racket, though it also had and gained some very skilled developers, was led from the top towards research and CS education goals, and early developer outreach was maybe mostly about being out there among dozens of Scheme implementations, and trying to be attractive to move to, or to be tried first. Industry application understanding came up from the bottom, the funding at the top remained for academic goals, and none of the people with industry experience got into leadership. So, in hindsight, I suppose it's not surprising that Racket and all the Scheme people who went there never took off commercially, beyond a few random success stories, and that Clojure would end up winning more in that regard.)
If I get time to do more on Scheme/Racket, other than the occasional package maintenance, I'd probably re-focus on portability to at least a few Schemes, and Kawa would be among them. (Right now, I'm leaning towards investing side-project time in leveraging various background towards Rust -- partly for its merits, and partly to keep learning and integrating a breadth of topics. But Scheme is still worth learning beyond school assignments level, and very powerful and a joy to work with practically, iff you have the time to invest in leveling up, filling in missing bits, and pulling off the occasional magic. Scheme even has some influences on Rust, and maybe with additional influences possible.)
There was (and still is)a project called Bigloo (https://en.wikipedia.org/wiki/Bigloo) that was interesting by allowing to get C, JVM and .Net code from scheme programs. We were a Scheme shop and experimented a lot with MzScheme (our main implementation, Bigloo and Kawa)
P.S. regarding success stories for Scheme - we had a commercial product written in it, quite successful. I wrote the article about it in Russian - should be ok to read via google translate: https://translate.google.com/translate?sl=auto&tl=en&u=http:...
Oh yeah, Bigloo was also on my list of promising Schemes, and I tested with it.
At the time, Bigloo looked like one of those projects that seemed to have a lot of energy, and didn't seem to be as well-known on my side of the pond as it should be.
(Another time I experienced a kind of geopolitical diversity: I was working with a Web-native language, Curl, which started in the US, but took off with some industry in Japan, never in the US. I suppose that "tech" not being fully homogenized is a very good thing, but we do very often have the situation of some group A missing out on goodness that B has discovered, and vice versa. I think is just another reason to embrace diversity in general, to learn and benefit from goodness others have found, while also letting that diversity machine keep finding new goodness in parallel.)
Clojure and Scheme are very different languages in the Lisp family.
I see Kawa as an option if you need JVM, and you know you want Scheme.
From another direction: If the situation is that you have to be heavily integrated into a Java environment (at the library/linking level, not microservices, etc.), such as due to enterprise legacy systems, tech policy, or maybe an embedded system... but you'd get big wins by using a non-Java language with that... then I suppose your options might include Clojure, Scala, and maybe Kawa. (Maybe other options right now; one would have to look into it.)
I'd argue not. They're in the same family of languages, but Schema and Clojure feel offer very different programming experiences. Neither is really better or worse than the other, they're just different.
Personally, I would probably pick Clojure as a primary implementation language because it's big and enterprisey and heavyweight and has all the tools and whatnot that come with that. And I would be more inclined to pick Kawa for high-level scripting, DSLs, and suchlike, for the same reason.
If you have Scheme code that you, for some reason, want to run on top of Java (or the JVM), then Kawa is still relevant. Clojure is similar to Scheme (in some ways, but mostly by virtue of also being in the Lisp family and being a Lisp-1), but is not the same, compatibility with Scheme code was not the intent.
I guess pretty much all the languages around the world use some variation of the work kava/kafe, don’t they? I can’t think of any language that wouldn’t use the word. Obviously I don’t speak all the world languages.
More interesting situation is with the tea - half of the world uses some variation of the word tea, the other half uses some variation of the word chai.
The original Kawa was an interpreter written by Alex Milowski, who is (I assume based on the last name) of Polish backgound. I essentially took over Kawa (with his permission), changed to be compiler-based, and over time re-wrote most or all of it.
As far as I know, Kawa is the oldest non-Java language still in use and development that compiles to the JVM. It dates from 1996. (NetRexx is from the same era, but as far as I know is basically an interpreter.)
I really wish programming language websites had example code snippets on the front page. How the code looks and feels, what makes the language unique, how things compare to another widely-known language.
Personally, it is the first thing I am looking for, and usually it’s buried deep in the third chapter of a tutorial, which, in turn, is buried deep inside a dull documentation section.
I had a lot of fun with Kawa back about a decade ago, and one thing I was missing was something like Maven support, but that eventually led me to Clojure which I really like. But the simplicity of Scheme is really great too.
I'd been using Java previously for research prototypes, Java was getting popular, and Kawa's property of running on the JVM seemed potentially practically very useful or critical, and I wanted it in my pocket.
I ended up moving primarily to PLT Scheme (aka Racket), but I would (and still do) always tell people about keeping some of the special Scheme implementations as backups. Kawa for JVM, Gambit for large numbers of threads and other properties, Chicken for its C compilation approach and significant community.
I think the JVM aspect was one of the keys to Clojure achieving more popularity than Racket. Though Clojure was also led from the top with a better command of industry application, and also focused outreach on the wealth of Common Lisp (CL) (sometimes called simply "Lisp" without qualification) developers, who as a whole seemed to be more seasoned veterans than our average Scheme/Racket developer. (Whereas Racket, though it also had and gained some very skilled developers, was led from the top towards research and CS education goals, and early developer outreach was maybe mostly about being out there among dozens of Scheme implementations, and trying to be attractive to move to, or to be tried first. Industry application understanding came up from the bottom, the funding at the top remained for academic goals, and none of the people with industry experience got into leadership. So, in hindsight, I suppose it's not surprising that Racket and all the Scheme people who went there never took off commercially, beyond a few random success stories, and that Clojure would end up winning more in that regard.)
If I get time to do more on Scheme/Racket, other than the occasional package maintenance, I'd probably re-focus on portability to at least a few Schemes, and Kawa would be among them. (Right now, I'm leaning towards investing side-project time in leveraging various background towards Rust -- partly for its merits, and partly to keep learning and integrating a breadth of topics. But Scheme is still worth learning beyond school assignments level, and very powerful and a joy to work with practically, iff you have the time to invest in leveling up, filling in missing bits, and pulling off the occasional magic. Scheme even has some influences on Rust, and maybe with additional influences possible.)