Just creating a freeware game with your new language as a proof of concept may be sufficient to convince others of its utility. You would at least attract potential “modders” who would be prepared to learn your language in order to script new AI behaviours, etc.

I say this because I have been working on an entirely new language for very many years, struggling to find the exact ingredients to “bake the perfect cake”. My fear being that I will need some feature or programming paradigm in the future and curse the tools at my disposal for not supporting those semantics – something that would be made all the more infuriating by having the knowledge that I was in the ideal position to avoid all of these problems if I had only anticipated them in the design at the outset. That said, I also wanted to keep my language “small” in the sense that it could be described by a thin manual as I felt that there were many ‘full featured’ languages out there already that just seemed to have musty annexes that one didn’t come into regular enough contact with to retain a degree of mastery and which, as a result, forced you back into reading a huge reference manual.

I don’t want to sound negative as I quite understand the desire to tell people who may be “in a position to understand what you are on about” what you have been able to achieve. I know no one who I can talk about the specific details of what I have been working on and have, eventually, come to accept this. In fact, if I were to find that someone wanted to really know I wouldn’t tell them because I would not want them to steal my ideas and implement something similar to my work long before I got around to doing it (as I am quite a slow worker). I also want my ideas to be taken as a package, rather than “cherry-picked” as it is how they all fit together that makes it significant.

Anyway, best of luck with Animus. I can say that designing a language makes for an extremely diverting intellectual pursuit – even if there is no money at the end of it…

I don’t think you understand the idea. C is static and native compiled too, of course, but an in-memory representation of C code in Lisp can be compiled out to object code. The Lisp layer becomes just syntax and a build system, effectively.

Languages with their own runtime are a bit trickier. If you wanted, say, to write Python in Animus but target CPython, Animus somehow has to get its hooks into running and managing CPython. Or say you’re writing Javascript in Animus but targeting the browser: there’s no way to do it, really, except to generate actual Javascript source (like GWT, I suppose). In any of these scenarios, you’re bridging over “legacy” layers, which is never ideal. The idea, though, is that we would eventually ditch these intermediate layers. But in the mean time, I admit, things would be a bit messy.

That’s a very superficial analysis.

The reason it doesn’t make sense to embed Haskell in Lisp is that it is
statically typed, so we can use that to optimize it extremely
aggressively before compiling to native code. It undergoes full type
erasure statically, resulting in a significant performance benefit over
runtime dynamic typing, a la Lisp.

http://shootout.alioth.debian.org/u64q/benchmark.php?test=all&lang=all

i.e. 1 – 5x faster

Finally, the worthy semantics of note is referential transparency by
default, making parallelisation trivial. Something that’s not going to
happen in Lisp anytime soon.