I'm interested by what seems to attract people to a VM/runtime enough to re-implement another language on top of it while preferring a new language to whatever the VM's flagship is. Sticking just to Joxa and the more common ones showing up here, the claimed motivations[0] seem to be:

Joxa - fault tolerance; concurrency/scaling; "tool set in which to build DSLs"; (A Lisp on Erlang VM)

MagLev - native code & data persistence scaling to very large stores; distributed cache; heavily optimized JIT (Ruby on Gemstone/S Smalltalk VM - http://maglev.github.com/)

Clojure - multithreading; Java library access; portability/scaling (A Lisp on JVM - http://clojure.org/)

JRuby - performance; multithreading; Java library access (Ruby on JVM - http://jruby.org/)

Jython - performance; Java library access/extension; optional static compilation (Python on JVM - http://www.jython.org/)

Parrot/Rakudo - Such an oddball case (and not a reimplementation) that I'm reluctant to toss it in here, but the Parrot VM is explicitly designed for multiple languages (Perl6 - http://rakudo.org/how-to-get-rakudo/)

All three VMs have been around for quite a long time and been the focus of huge engineering efforts, but none of the re-implementations seem to have displaced the originals or the VM's default language[1], so my question is whether there's any re-implimentation that did? The obverse (replacing the old VM/compiler for a language with a new one) isn't uncommon what with all the browsers that have done it, the huge changes in the JVM, etc. and usually those end up being complete swaps, so is there one decisive factor that makes the difference?

[0] Ignoring the obvious, worthy, and most importantly fun factor of "because it would be cool" [1] [1] Arguably in the case of the Lisps there's no original to displace. [2] JSLinux, anyone?

Because some people are not able to master several languages and prefer to always use the same regardless of the task at hand.

One problem with JRuby replacing MRI or Jython (or IronPython) replacing CPython is MRI and CPython's C API.

How does it compare to Robert Virding's LFE (Lisp Flavored Erlang)?

https://github.com/rvirding/lfe

An explanation of how they are different, and why creating Joxa was necessary, from the creator of Joxa, Eric Merritt.

http://news.ycombinator.com/item?id=3610985

Full disclosure: Eric and I are co-founders of the company he references in that writeup.

Just at a quick glance, I think LFE is a Lisp-2? At least, it bears more resemblance to Common Lisp than Scheme. I don't see any 'funcall' function though, so I could be wrong.

Erlang vm is a lisp 2.

To me this looks like a not as well developed version of LFE.

It depends on what you mean by not as well developed. If by that you mean maturity. Probably, its much newer and has just had its very first early alpha release.

Wasn't wondering about namespace count as much as maturity/completeness.

LFE is a Lisp 2. It has ':' which is the equivalent of funcall.

Add a code sample to the home page. It gives an instant feeling of how the language is. Does it have long-scheme-like-names? Do you have to sharpquote the #’functions? ...

I will do that (its a great idea by the way)

Yes it does have scheme like names. No you do not have to sharpquote. Its a lisp 1 not a lisp 2