Application virtual machines seem to be the way things are going, and it is nice to consider for portability options. I mean, jeesh, even Microsoft is moving to a virtual architecture, supporting rotor and all. (What, are they planning on going to a BSD kernel too?)

So I've decided I really need to master one or two of these, and it's preferred development language. Which leads to some questions...
What's the most compact, portable, and useful VM engine? What's their SMP and threading support like? Also, are any or all of them RISC-style, or are they trying for a really "complete" set of fundamental instructions? Will I be able to code in "VM assembly"? Which ones run well? (As in, don't run slow and break other things like a three-legged elephant in phone booth, as the Flash machine seems to.)

Here's the application VM's that I know of. Yes, I'm limiting myself to ones with open-source implementations. Comments? Am I missing anything significant? Do any of the small (could be embedded) ones support threads?

• P-code, preferring Pascal.
• JVM, preferring Java.
• Waba, subset of Java.
• CLR, preferring C#.
• Inferno, preferring Limbo.
• Parrot, preferring perl.
• WAM, preferring Prolog.
• Squeak
• Z-machine, started with ZIL (OK, perhaps silly, but rather portable...)
• LLVM

I also find myself wondering if these are really any lighter than full-on hardware style VM's where I can take old coding skills and port them to, say, that dual-ARM board I found in the abandoned DSL modem. In particular the grand-daddy "VM", the canonical IBM architecture, in the Hercules implementation. VM is old enough that it seems like it should run on some hardware that would now be considered fairly "lightweight", and certainly has some language and OS choices on top of that... but is it a good idea?

I figure I'll be using a "heavyweight" one for general Stuff (probably CLR or Java), and a lightweight one for portability to small architectures. Ideally, the small one would be compact, widely ported, thread-supporting, multi-lingual (both 18n and compilers), SMP ready, and astoundingly flexible. But which one is all that? And if there are more than one, which one has more RISC-nature?