Exactly: hardly anybody uses Jazelle because it's badly documented

Java ME can be unpleasant to use: lots of Java 1.4, 5, 6 and 7 goodies (both in terms of language features and in terms of class library), which people have enjoyed for years on Java SE, are not available.

Oh yeah, forgot about that topic

thats my only real worry

Java would be nice on the Nspire since a bunch of people know this language and this might increase the Nspire programmer audience considerably, although of course it won't be even close to Ndless (and maybe Lua?) performance.

Running Java code is generally faster than running Lua code, because of the type information available to the JVM. Take object field accesses for example - in Java, if you have a variable "Rectangle r", the JVM knows at class-loading time that it points to a Rectangle object, and therefore can determine in advance what location within the object will be accessed in an expression like "r.width". In an untyped language like Lua, on the other hand, fields have to be looked up by name at run-time every time they're accessed, which is much slower.

The main problem with Java isn't its execution speed, it's its size. JamVM brags about its executable being only 200KB, but how much memory does it use, and how big is the required class library? Porting the class library could also be a lot of work. I was considering porting the CLDC reference implementation (a Java environment with a much smaller class library) a while ago, after I had found out about Jazelle, but never did anything substantial to that end.

A good analogy of what you could expect for performance would be:
For 84+, BASIC < Hybrid BASIC/BBC < Axe < Asm
For Nspire, BASIC < Lua < Java < C

(Java's limitations compared to C are different than Axe's compared to Asm, but they basically come to the same concept: Lower level programming is faster. Higher Level programs add bulk and slow stuff down. It's the ever-present trade-off in tech of work vs performance, but Java gains cross-compatibility as a bonus)

After all, that lua interpreter was written by TI. If anything it would be worse than the standard implementation, making it a wider gap.

If anything can be done to improve the native SDK, I'm open to your suggestions.

Hello.

As you can guess my the title, I am starting a project to port a Java Virtual Machine to the Nspire.

So far I have found an open sourced JMV here

http://jamvm.sourceforge.net/

That I believe can be ported to the Nspire. It is also written almost entirely in C so I think that'll help.

What I want to do is basically be able to take any Java byte code, and be able to run it on the Nspire. (Possible Minecraft, anyone?)

However, I don't know where to start with this project. I downloaded the source for the JVM and found the main file, however I do not know what I need to do to port it to the Nspire.

I hope that this can become a community project where anyone can contribute, because if it were only myself, it might never come to fruition, which would be a shame.

So, first question, where do I start? ExtendeD suggested to me earlier to try to compile the project as is using the Ndless SDK to see what dependencies aren't supported, although I don't know what I should make for a makefile to do that.

First, understand precisely what a JVM is and how it works.
That means you need to read the Sun Spec for the Java VM. It will be invaluable for understanding the logic behind some of the superficially "WTF?" decisions that appear in the VM. Also, try to get your hands on the book "Inside the Java Virtual Machine." It's not quite as useful as the spec itself, but the depth it goes into can occasionally be helpful and it explains some of the algorithms used in the sun implementation, something the spec deliberately avoids doing.

Also, get comfortable with optimization and low level programming. They're the heart of a good VM.

Perhaps most importantly, understand the code you're trying to use as if you had written it yourself. If you're going to be maintaining it, then you'll quickly see why that's such a good idea.

So, long story short: Writing/porting a JVM is a very good way to learn precisely how much you don't know. You'll come out of it a better programmer either way and I highly recommend attempting it for the learning experience, even if you never manage to fully port it. If you do manage to fully port it, then I love you