Skip to content

A more than minimal JVM written in Go and capable of running Java 17 classes.


Notifications You must be signed in to change notification settings


Folders and files

Last commit message
Last commit date

Latest commit


Repository files navigation

Go version Workflow GitHub commit activity


A more-than-minimal JVM written in Go.


Intended feature set:

  • Java 17 functionality, but...
  • No JNI (Oracle intends to replace it; see JEP 389)
  • No security manager (Oracle intends to remove it; see JEP 411)
  • No JIT
  • Somewhat less stringent bytecode verification
  • Does not enforce Java 17's sealed classes

What we've done so far and what we need to do:

Command-line parsing

  • Gets options from the three environment variables. Details here
  • Parses the command line; identify JVM options and application options
  • Responds to most options listed in the java -help output

To do:

  • Handling @files (which contain command-line options)
  • Parsing complex classpaths

Class loading

  • Correctly reads and parses most classes
  • Extracts bytecode and parameters needed for execution
  • Automated pre-loading of core Java classes (Object, etc.)
  • java.*, javax.*, jdk.*, sun.* classes are loaded from the JAVA_HOME directory (i.e., from JDK binaries)
  • Handles JAR files

To do:

  • Handle more-complex classes
  • Handle interfaces
  • Handle inner classes

Verification, Linking, Preparation, Initialization

  • Performs format check of class file.
  • Linking, preparation, and initialization -- minimally and only as needed at execution time

To do:

  • Verification
  • Robust preparation and initialization


  • Execution of bytecodes ✏️ The primary focus of current coding work
    198 bytecodes fully operational, including one- and multi-dimensional arrays
  • Static initialization blocks
  • Throwing exceptions
  • Running native functions (written in go). Details here.

To do:

  • invokedynamic
  • Calls to superclasses
  • Inner and nested classes
  • Exception-tree walking
  • Annotations


  • Instruction-level tracing (use -trace:inst to enable this feature)
  • Extensive logging data (use -verbose:finest to enable. Caveat: this produces a lot of data)

To do:

  • Emit instrumented data to a port, for reading/display by a separate program.

Garbage Collection

GC is handled by the golang runtime, which has its own GC

Understanding the Code

A detailed roadmap to the code base can be found in the wiki.

If you want to test Jacobin

At present, we're not looking for testers because we know the missing features and we're working on them. Testing, at this point, will likely result in frustration. However, if for your own enjoyment, you still want to try it out, see directions and cautions on our Release Page. (If you want some fun, run your program on Jacobin with the -trace:inst option and watch the executing Java bytecodes whiz by along with the changing contents of the op stack.)

We expect/hope/trust that in 2024, we'll be ready to ask interested users to test Jacobin on real programs and share their feedback with us.


The project's home page carries a lengthy note at the bottom that expresses our thanks to vendors and programmers who have made the Jacobin project possible. They are many and we are deeply grateful to them.


A more than minimal JVM written in Go and capable of running Java 17 classes.