Wow. I need to clear up some misconceptions.
Volta utterly sucks. It's a project I could have written in a weekend
fundamentally will never work right unless someone actually spends
serious time and effort making it better. Let me repeat that: It's -
You can't use JRuby to write GWT because GWT uses a unique 'closed-
world, statically analysed code coverage' concept to take a batch of
java code and turn *ONLY* those parts that will actually be called
because it lazy loads: Well, one, Hello World downloads over a meg of
cruft in volta, in a gazillion files, and two, GWT also only loads the
used bits, just does it one go.
To accomplish this, GWT will begin at the entry point(s) and apply a
process somewhat similar to garbage collection, except that it
analyses the source itself instead of the runtime state. Basically,
any code not somehow invoked by the entry point itself or by anything
the entry point invokes, is not included because its never used. And
in order to get this right, GWT *MUST* disallow e.g. usage of
reflection. After all, if you can do this:
Class c = Class.forName(classBox.getText());
Method m = c.getMethod(methodBox.getText());
legally, in GWT, then - that one block of code would cause the GWT
compiler to include -every- single last method that is inside the
project set. There's no way to know what that will end up calling at
runtime, hence the need to do that. In one fell swoop GWT has to
include every emulated class, every widget, every library you linked
in (e.g. all of ext-gwt even if you're only using a fraction of it),
and you'll end up with a 5 MB disaster.
JRuby uses reflection extensively to make it work. After all, this is
same typing system, so in that sense they are equal in the eyes of
potential GWT languages):
And, as you can see, same issue. In order for GWT to allow Python,
Ruby, and JS as source languages, it would need to add lots of
limitations, such as never doing a named lookup on object members.
However, because those languages aren't statically typed, even that
won't help much. Besides, the whole point of those languages is that
you CAN do that stuff - they were designed with that in mind. If you
start taking the language apart and only allowing half the feature
set, you'll soon find you can't reasonably program anything in it
without tearing your hair out by the roots. It would be a stupid
exercise in futility.
Now, there are some languages where you may fare better. Scala, for
example. Or, here's a fun twist: .NET could be compiled quite easily
term (it would still take a month or two of good hacking to get there,
but at least you know where to start and where to go).