About

Goals

The main goals of Jainja are:

Portability
Simplicity and Maintainability (keep the code base small and modular)

Motivation

Over time, many excellent JVMs have been developed. However, portability remains a significant challenge.

Mainstream JVMs

Some mainstream JVMs are highly portable if the following conditions are met:

Availability of a C/C++ compiler (mostly GNU C).
Availability of pthread.

Issues:

Some target platforms do not provide a C compiler. This issue has been resolved for the web through significant efforts (Emscripten, NaCl, and now WebAssembly).
If pthread is unavailable, some JVM implementations allow disabling threads at compile-time, but this means running single-threaded applications, making many libraries unusable.

Specific JVMs

To address these portability concerns, some JVMs were implemented in languages that are native to their target platforms (e.g., JavaScript or C#).

However, this introduces another issue: if the target platform changes, the entire framework and language must often be re-ported.

Concepts

A JVM Focused on Low-Level Compliance

Jainja is a JVM that aims to comply with official specifications at a low level, ensuring support for all bytecodes. This approach allows the core logic of an application to run anywhere, adhering to Java's "Write Once, Run Anywhere" (WORA) philosophy.

However, portability is Jainja’s primary goal. To achieve this, only a subset of the standard Java libraries is supported. Developers must adapt their code to work within this subset. WORA is respected only in one direction: if the code runs on Jainja, it will work on Oracle JDK/OpenJDK, but the reverse is unlikely.

Why Not Use the Standard OpenJDK Library?

The OpenJDK assumes certain conditions that make it difficult to port Java to non-standard platforms:

The underlying platform is POSIX or Windows.
Native threads are preemptive.
A JIT compiler is available (or the processor is very fast). For example, OpenJDK’s AWT/Swing relies on Marlin, a Java-based rasterizer that is slow without JIT.
High memory availability is assumed at startup (OpenJDK 11 loads over 400 classes for a simple "Hello, World").
Dynamic class generation is required. Since Java 8, invokedynamic is used for lambda expressions instead of anonymous inner classes (drawbacks)
Swing assumes a desktop environment where multiple resizable windows are available, which is not the case for many mobile or web platforms.

Due to these assumptions, previous attempts to port Java to other platforms have led to JVMs that only support a subset of the Java ecosystem:

At the source code level: GWT (initially developed by Google), Android.
At the bytecode level: Android.
At the library level: Android, GWT, TeaVM, JSweet, etc.

Jainja takes a different approach: it supports all bytecodes while maintaining a sufficiently large subset of the libraries so that GUI frameworks like MIDP, AWT, Swing, or Codename One only require adaptations rather than complete rewrites.

Thus, a Swing application using all OpenJDK features is unlikely to work directly on Jainja (or on Android, GWT, etc.), but it is possible with code adaptations.

A Different Approach to Portability: Transpilation

Instead of porting Java compilation tools to various platforms, Jainja translates the JVM into different languages via transpilation:

The JVM source code is written in Java, but it can be automatically converted to other languages/platforms.
A minimal Java subset is used to ensure compatibility with all Java platforms and facilitate transpilation.

Meta-Circularity ("Do Not Reinvent the Wheel")

Inspired by meta-circular interpreters, Jainja leverages existing features of the host language: instead of implementing its own object model and garbage collector, Jainja relies on the host language’s built-in mechanisms.

Pure Java Libraries ("Write Once, Run Anywhere")

Unlike standard JVMs that implement native components in C/C++, Jainja prioritizes Java-based implementations. Only a thin native layer is used when strictly necessary.

Green Threads ("DIY" to Keep It Simple)

Jainja implements threads at the VM level, making native multi-threading unnecessary.

I/O operations are handled with non-blocking native calls.
Green threads were used in the early Sun JVMs—and sometimes, "the old pipe gives the sweetest smoke."

Features

Jainja currently supports all major features of the Java 1.8 specifications.

Virtual Machine

Full thread support
Introspection
Fully reentrant
Invokedynamic support for lambda expressions

Runtime: Supported Standard Core Libraries

java.lang
java.lang.ref
java.lang.reflect
java.io
java.math
java.net
java.security
java.sql
java.text
java.util
javax.crypto

GUI Toolkits

Codename One: Fully supported
MIDP2
Jainja Graphical Toolkit (JAGT): A lightweight toolkit to support standard UI APIs
Current backends: AWT, GWT, MicroBackend

Conclusion

Jainja is designed for developers who want to run their applications with minimal effort on non-standard platforms. It is not intended for running complex GUI applications "out of the box" but can support them with adaptations.

By prioritizing portability over performance, Jainja offers a unique approach compared to mainstream JVMs.

Supported platforms

Page updated

Google Sites

Report abuse