Hubbry Logo
List of Java virtual machinesList of Java virtual machinesMain
Open search
List of Java virtual machines
Community hub
List of Java virtual machines
logo
7 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
List of Java virtual machines
List of Java virtual machines
List of Java virtual machines
View on Wikipedia
from Wikipedia

This article provides non-exhaustive lists of Java SE Java virtual machines (JVMs). It does not include every Java ME vendor. Note that Jakarta EE runs on the standard Java SE JVM but that some vendors specialize in providing a modified JVM optimized for enterprise applications. Much Java development work takes place on Windows, Solaris, Linux, and FreeBSD, primarily with the Oracle JVMs. Note the further complication of different 32-bit/64-bit varieties.

The primary Java VM reference implementation is the OpenJDK HotSpot, produced by Oracle Corporation and many other big and medium-sized companies (e.g. IBM, Redhat, Microsoft, Azul, SAP).

Free and open source implementations

[edit]

Active

[edit]
  • Codename One – uses the open source ParparVM
  • GraalVM – is based on HotSpot/OpenJDK, it has a polyglot feature, to transparently mix and match supported languages.
  • HotSpot – the open-source Java VM implementation by Oracle.
  • IKVM – Java for Mono and the Microsoft .NET Framework. Uses OpenJDK. Zlib License.
  • Jikes RVM (Jikes Research Virtual Machine) – research project. PPC and IA-32. Supports Apache Harmony and GNU Classpath libraries. Eclipse Public License.
  • leJOS – Robotics suite, a firmware replacement for Lego Mindstorms programmable bricks, provides a Java programming environment for the Lego Mindstorms RCX and NXT robots.
  • OpenJ9 – open-source from IBM J9, for AIX, Linux (x86, Power, and Z), macOS, Windows, MVS, OS/400, Pocket PC, z/OS.
  • Maxine – meta-circular open source research VM from Oracle Labs and the University of Manchester.

Inactive

[edit]
  • Apache Harmony – supports several architectures and systems. Discontinued November 2011. Apache License 2.0.
  • GCJ the GCC Java compiler, that compiles either to bytecode or to native machine code. As of GCC 7, gcj and associated libjava runtime library have been removed from GCC.[1]
  • JamVM – developed to be an extremely small virtual machine. Uses GNU Classpath and OpenJDK. Supports several architectures. GPL. Last update 2014.
  • JOP – hardware implementation of the JVM. GPL 3.
  • Juice – JavaME experimental JVM developed to run on the NUXI operating system.
  • Jupiter – uses Boehm garbage collector and GNU Classpath. GPL. Unmaintained.
  • Kaffe – uses GNU Classpath. GPL. 1.1.9 released on February 26, 2008.
  • Mika VM – intended for use in embedded devices. Cross-platform. BSD-style licence.
  • NanoVM – developed to run on the Atmel AVR ATmega8 used in the Asuro Robot, can be ported to other AVR-based systems.
  • SableVM – first free software JVM to support JVMDI and JDWP. Makes use of GNU Classpath. LGPL. Version 1.13 released on March 30, 2007.
  • Squawk virtual machine – a Java ME VM for embedded systems and small devices. Cross-Platform. GPL.
  • SuperWaba – Java-like virtual machine for portable devices. GPL. Discontinued, succeeded by TotalCross.
  • TakaTuka – for wireless sensor network devices. GPL.
  • TinyVM.
  • VMKit of LLVM.
  • Wonka VM – developed to run on Acunia's ARM-based hardware. Some code drawn from GNU Classpath. BSD-style licence. No longer under active development, superseded by Mika VM.

Java operating systems

[edit]

Some JVM's are intended to run without an underlying OS.

  • JX – Java operating system that focuses on a flexible and robust operating system architecture developed as an open source system by the University of Erlangen. GPL. Version 0.1.1 released on October 10, 2007
  • JavaOS – Original project from Sun Microsystems

Proprietary implementations

[edit]

Active

[edit]
  • Azul Platform Prime – a fully compliant, high-performance Java virtual machine based on OpenJDK that uses Azul Systems's C4 garbage collector and Falcon JIT compiler.
  • JamaicaVM (aicas) – a hard real-time Java VM for embedded systems.

Inactive

[edit]

Lesser-known proprietary Java virtual machines

[edit]
  • Blackdown Java was a licensed port to Linux of the reference SunSoft implementation. It was discontinued in 2007, after OpenJDK became available.
  • Sun CVM – CVM originally standing for "Compact Java Virtual Machine".
  • Gemstone – modified for Java EE features (application DBMS).
  • Intent (Tao Group).
  • PreonVM – a Java VM for embedded systems and small and resource constrained devices.

See also

[edit]

References

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

List of Java virtual machines

View on Grokipedia
from Grokipedia
The Java virtual machine (JVM) is an abstract computing machine that converts Java bytecode, the intermediate representation of Java programs compiled by the javac compiler, into machine instructions executable by a specific hardware platform, thereby enabling platform-independent execution of Java applications and other languages targeting the JVM. Defined in the Java Virtual Machine Specification maintained by Oracle, the JVM provides key features including automatic memory management via garbage collection, security through bytecode verification, and just-in-time (JIT) compilation for performance optimization. This specification allows for diverse implementations tailored to varying needs, such as high throughput, low latency, or resource-constrained environments, while ensuring compatibility through the Technology Compatibility Kit (TCK). Notable JVM implementations include the HotSpot JVM, the integrated into and JDK, which employs advanced compilation and garbage collection techniques for general-purpose . , originally developed by and now under the , focuses on low and fast startup, making it suitable for cloud-native and containerized applications. , also from , extends the JVM with polyglot capabilities for running multiple languages and ahead-of-time native to reduce startup times and usage. Commercial variants like Azul Platform Prime (formerly Zing) emphasize predictable low-latency and for mission-critical workloads through custom and optimizations. These implementations must pass the Java SE TCK to claim compatibility, fostering an ecosystem where developers can choose based on specific requirements like embedded systems, big data processing, or enterprise servers, with ongoing innovations driven by open-source communities and vendors.

Overview

Definition and Role in Java Ecosystem

The Java Virtual Machine (JVM) is an abstract computing machine designed to execute Java bytecode in a platform-independent manner, converting it into native machine code for the host operating system and hardware. This specification is formally defined in The Java Virtual Machine Specification, Java SE 25 Edition, released as part of JSR 400 in September 2025, which outlines the precise behavior required for JVM implementations to ensure compatibility and portability. At its core, the JVM comprises several interconnected components that facilitate secure and efficient execution. The class loader subsystem dynamically loads, links, and initializes Java classes from bytecode files. The bytecode verifier examines loaded code to prevent security vulnerabilities and ensure adherence to the JVM's type safety rules. The execution engine, including an interpreter and just-in-time (JIT) compiler, processes bytecode by either interpreting it directly or compiling it to optimized native instructions for better performance. Memory management is handled by the garbage collector, which automatically reclaims unused objects, while runtime data areas—such as the method area for class metadata, the heap for object storage, and per-thread stacks for method execution—provide the structured environment for program operation. Within the broader Java ecosystem, the JVM serves as the foundational runtime environment that realizes the "write once, run anywhere" principle, allowing developers to compile Java source code once into bytecode that runs consistently across diverse platforms without modification. It underpins the Java Platform, Standard Edition (SE) for general-purpose computing, the Enterprise Edition (EE, now Jakarta EE) for server-side applications, and Micro Edition (ME) for resource-constrained devices, with implementations required to pass the Technology Compatibility Kit (TCK) tests to certify adherence to these profiles. The JVM specification has undergone continuous refinement since its debut with the Java Development Kit (JDK) 1.0 in January 1996, culminating in Java SE 25 by September 2025. Notable advancements include the introduction of modularization via Project Jigsaw (JEP 200) in JDK 9 (2017), which enabled better encapsulation and scalability for large applications, and the integration of virtual threads through Project Loom, finalized in JDK 21 (2023) to enhance concurrency with lightweight threading models.

Historical Evolution

The origins of Java virtual machines trace back to Sun Microsystems' Green Project, initiated in December 1990 as a stealth effort to develop a programming language for consumer electronics and networked devices. Led by James Gosling, Mike Sheridan, and Patrick Naughton, the team—known as the Green Team—created an initial prototype called the Star7 set-top box and developed the language originally named Oak, later renamed Java in 1995 to avoid trademark issues. The first Java virtual machine was introduced with JDK 1.0 in January 1996, serving as a foundational interpreter-based runtime that executed bytecode for the nascent Java platform, though it lacked advanced just-in-time (JIT) compilation capabilities. Key milestones in JVM evolution included Sun's acquisition of Animorphic Systems in February 1997, which brought adaptive JIT compilation that formed of the HotSpot JVM, first released experimentally in April 1999 and becoming the default in JDK 1.3 in 2000. Concurrently, IBM launched its J9 JVM in 1999, emphasizing modular design for enterprise and embedded use, which was later open-sourced as Eclipse OpenJ9 in September 2017 to foster community contributions. A pivotal shift occurred in November 2006 when Sun open-sourced the HotSpot-based JDK under the GNU General Public License version 2 (GPLv2) with the Classpath exception, establishing OpenJDK as the reference implementation and transitioning Java from a predominantly proprietary model—where Sun distributed binary-licensed JDKs—to a dual-licensed open-source ecosystem that encouraged vendor participation while retaining commercial options. Oracle's $7.4 billion acquisition of Sun in January 2010 placed OpenJDK under new stewardship, prompting community responses like the formation of AdoptOpenJDK in 2017 (rebranded as Eclipse Temurin in 2021) for independent, TCK-certified builds, and Amazon's Corretto distribution in 2019 for AWS-optimized long-term support. The rise of polyglot capabilities marked another advancement with Oracle's release of GraalVM 1.0 in April 2018, a high-performance JVM extension supporting multiple languages like JavaScript and Python alongside Java, leveraging advanced JIT and ahead-of-time (AOT) compilation for broader interoperability. Ongoing projects like Valhalla, launched in March 2014, have driven language evolution, with value types—primitive-like classes without identity—reaching early-access implementation in October 2025 builds to improve performance for data-intensive applications. This open-source momentum contrasted with Oracle's proprietary extensions, reinforcing community-driven dominance through forks like Temurin and Corretto, which traditional references often overlook due to outdated coverage. In 2024–2025, developments emphasized efficiency and emerging technologies, culminating in Java 25's general availability on September 16, 2025, an LTS release incorporating Project Babylon for AI-driven code reflection and GPU-accelerated programming models, alongside Project Leyden's advances in AOT compilation to reduce startup times by up to 50% in cloud-native scenarios. These enhancements, built on OpenJDK's collaborative framework, highlight the licensing shift's lasting impact: from Sun's closed binaries to a vibrant, GPL-based ecosystem where proprietary stewardship coexists with widespread open-source adoption, enabling innovations like Babylon's meta-programming for machine learning without vendor lock-in.

Open-Source Implementations

Active and Maintained

The active and maintained open-source implementations of Java virtual machines (JVMs) compatible with Java SE form the backbone of the Java ecosystem, providing robust, community-driven alternatives for developers and enterprises as of 2025. These JVMs undergo regular updates, pass the Technology Compatibility Kit (TCK) tests, and support the latest Java releases, including Java 25, while emphasizing performance optimizations, broad platform compatibility, and permissive licensing to encourage widespread adoption. Key examples include the reference implementation and specialized variants tailored for high-throughput, low-latency, or polyglot environments. HotSpot serves as the reference implementation for OpenJDK, having been the default JVM since its integration in 2006. It features just-in-time (JIT) compilation via the C1 (client) and C2 (server) compilers for optimized bytecode execution, along with advanced garbage collection options such as the G1 collector for balanced throughput and the ZGC for low-latency pauses. Supported platforms include x86, ARM, and RISC-V architectures, enabling deployment across desktops, servers, and emerging hardware. Maintained collaboratively by Oracle and the OpenJDK community, HotSpot is licensed under GPL-2 with the Classpath Exception, with its latest release, JDK 25.0.1, issued in October 2025. Eclipse OpenJ9, originally developed as IBM J9 and donated to the Eclipse Foundation in 2017, is optimized for cloud-native and enterprise workloads with a notably low memory footprint and rapid startup times. It incorporates ahead-of-time (AOT) compilation to reduce runtime overhead, making it suitable for resource-constrained environments, and supports multi-architecture platforms including x86, Power, and z Systems. The project is governed openly under the Eclipse Foundation, with a dual license of Apache 2.0 or Eclipse Public License 2.0, and its latest release, version 0.56.0 in October 2025, integrates with OpenJDK versions up to 25. GraalVM Community Edition extends the JVM paradigm as a polyglot runtime, leveraging the Truffle framework to execute Java alongside languages like JavaScript and Python within a single process. Its standout feature is native image generation through SubstrateVM, which compiles Java applications to standalone executables for faster startup and smaller footprints—ideal for microservices and serverless deployments. Developed by Oracle Labs, it remains actively maintained in 2025 with full integration for Java 25, supporting diverse platforms via OpenJDK compatibility, under the GraalVM Free Terms and Conditions license that permits production use without fees; the latest release is GraalVM 25.0.1 from October 2025. Eclipse Temurin, produced by the under the , is a TCK-certified distribution of featuring the HotSpot JVM, with a strong emphasis on (LTS) releases such as 21 and now 25. It prioritizes cross-platform reliability and contributions, filling gaps in binary for enterprise users by offering rigorously builds without . Available on major operating systems and architectures like x86 and , it uses the GPL-2 with Exception license and saw its latest updates, including Temurin 25.0.1, in November 2025. Amazon Corretto is an AWS-maintained fork of using HotSpot, designed with extended patching and optimizations for workloads, including on AWS since its launch in 2019. It provides no-cost access to production-ready binaries with quarterly updates, supporting platforms such as (x86 and ), Windows (x64), macOS (x64 and ), and . Licensed under GPLv2 with the Exception, Corretto fully supports 25 as of its 2025 quarterly , ensuring compatibility through at least 2032. Azul Systems' open-source offering, known as Zulu Builds of OpenJDK (including the Kona variant for specific optimizations), is HotSpot-based and focuses on low-latency garbage collection to meet demands of high-performance applications. It includes support for CRaC (Coordinated Restore at Checkpoint) to enable fast application checkpointing and restoration, reducing startup times in dynamic environments. Compatible with x86 and ARM platforms across Linux, Windows, macOS, and others, it is licensed under GPL-2 with the Classpath Exception and actively updated, with the latest Zulu 25.0.1+8 release in October 2025.

Discontinued or Inactive

This section documents open-source Java virtual machines (JVMs) that have ceased active development, highlighting their historical roles, discontinuation timelines, and contributions to the Java ecosystem as of 2025. These projects, primarily from the late 1990s to early 2010s, paved the way for portable Java execution but were eventually overshadowed by more robust implementations like OpenJDK. Their inactivity stems from factors such as redundancy with dominant projects, legal challenges, and shifts in developer resources toward standardized efforts. Apache Harmony was an open-source Java class library and virtual machine project initiated by the Apache Software Foundation in 2006, licensed under the Apache License 2.0. It aimed to provide a modular alternative to proprietary Java implementations, supporting Java SE up to version 6. The project was discontinued in November 2011 following a community vote, largely due to the Oracle v. Google lawsuit over Android's use of Dalvik, which drew from Harmony's class libraries; this legal action raised concerns about ecosystem fragmentation and compatibility. Historically, Harmony influenced early Android development, as Dalvik (pre-ART) utilized its class library for bytecode interpretation, enabling Java-like applications on mobile devices before Oracle's legal pressures shifted focus to OpenJDK. Kaffe, one of the earliest portable JVMs released in 1996 by Transvirtual Technologies, was licensed under the GNU General Public License (GPL) and supported multiple architectures including x86, ARM, and PowerPC. It featured a just-in-time (JIT) compiler and used GNU Classpath for libraries, emphasizing cross-platform compatibility for embedded and desktop use. The last official release, version 1.1.9, occurred on February 22, 2008, after which development halted as HotSpot and other mature JVMs gained prevalence for better performance and Java specification compliance. Kaffe's significance lies in demonstrating clean-room implementation of the JVM specification without Sun Microsystems' proprietary code, fostering early open-source Java adoption. The GNU Compiler for Java (GCJ), integrated into the GNU Compiler Collection (GCC) since 1999, was an ahead-of-time (AOT) compiler and runtime under the GPL that targeted native code generation for improved startup times and reduced runtime overhead. It supported Java up to version 1.5 and used GNU Classpath, focusing on native performance for applications where JIT overhead was undesirable. GCJ was removed from GCC's main trunk on September 30, 2016, with its absence confirmed in the GCC 7.1 release in 2017, due to stalled development and lack of maintainers amid the rise of superior JIT-based JVMs like HotSpot. While it lacked a full dynamic JIT optimizer, GCJ advanced static compilation techniques and remains available in legacy GCC versions for historical or niche embedded uses. JamVM, a lightweight JVM designed for resource-constrained environments like embedded systems, was released under the GPL and emphasized minimal footprint (around 110 KB stripped on PowerPC) while conforming to JVM specification edition 2. It supported GNU Classpath and later OpenJDK class libraries up to Java 8. The final update, version 2.0.0, was issued on July 30, 2014, after which maintenance ended, as post-Java 8 advancements in OpenJDK rendered its small-size optimizations less critical. JamVM contributed to embedded Java by enabling efficient execution on devices with limited memory, influencing designs for IoT precursors. SableVM, developed at McGill University's Sable Research Group starting in 2001, was a strictly specification-compliant JVM under the GNU Lesser General Public License (LGPL), prioritizing portability, efficiency, and ease of extension for research purposes. It was the first free software JVM to fully support the Java Debug Wire Protocol (JDWP) and Java Virtual Machine Debug Interface (JVMDI), facilitating debugging tools integration with GNU Classpath. The last release, version 1.13, occurred on March 30, 2007, leading to abandonment as HotSpot's dominance provided broader ecosystem support and performance gains. SableVM's clean, modular architecture served as an educational framework for JVM internals and bytecode execution studies. Other notable inactive projects include JOP (Java Optimized Processor), a hardware-based JVM under GPL version 3 that implemented the JVM in FPGA or ASIC for time-predictable real-time systems; development stalled after with no updates beyond initial prototypes documented in handbooks. Squawk VM, ' GPL-licensed JVM for Java ME embedded devices, focused on small-footprint execution without an OS dependency but was discontinued around following 's acquisition by and shifts to newer mobile platforms. VMKit, an LLVM-based substrate for managed runtimes initiated in , aimed to modularize JVM components like JIT and garbage collection but stalled by 2012 due to integration challenges, with the project formally retired in 2014. Common reasons for these discontinuations include duplication of efforts by the OpenJDK project, which consolidated open-source Java development under a single, actively maintained umbrella since 2006; licensing tensions, such as Oracle's control over Java trademarks and the Technology Compatibility Kit (TCK) restricting non-OpenJDK implementations; and resource reallocations by contributors (e.g., IBM's pivot from Harmony to OpenJDK) toward modern, performant VMs supporting later Java versions. These factors ensured ecosystem unity but preserved these projects' legacies in open-source Java innovation.

Commercial Implementations

Major Vendor-Supported

Oracle JDK is a proprietary distribution of the Java Development Kit maintained by Oracle Corporation, built on the HotSpot JVM with additional enterprise-oriented features and extended support options. It includes premium capabilities such as Java Flight Recorder for advanced diagnostics and monitoring, enabling low-overhead production profiling and event-based tracing for troubleshooting performance issues in large-scale deployments. Since April 2019, Oracle has required a paid Java SE Subscription for commercial production use of Oracle JDK updates, governed by the Oracle Technology Network (OTN) License Agreement, which distinguishes between free personal/development use and subscription-based enterprise access. As of September 2025, Oracle JDK 25 is certified compliant with Java SE 25 specifications and designated as a Long-Term Support (LTS) release, with Premier Support extending through September 2030 and Extended Support until September 2033. Azul Platform Prime, formerly known as Zing, is a high-performance proprietary extension of the HotSpot JVM developed by Azul Systems, targeting latency-sensitive applications in finance and high-performance computing (HPC) environments. It features the Continuously Concurrent Compacting (C4) garbage collector, a production-ready pauseless generational GC that minimizes application stop-the-world pauses to sub-millisecond levels, significantly improving responsiveness compared to standard HotSpot collectors. Additionally, the ReadyNow! technology optimizes JIT compilation by pre-warming the JVM with application-specific profiles, reducing startup times and enhancing throughput in cloud-native and microservices architectures. Azul Platform Prime supports Java versions from 8 through 25, with commercial licensing that includes long-term maintenance for LTS releases, often extending up to a decade for critical deployments. IBM Semeru Runtime Certified Edition is a commercially supported JVM from IBM, based on the Eclipse OpenJ9 project but incorporating proprietary optimizations particularly for IBM zSystems mainframes, where it delivers enhanced memory efficiency and scalability for transaction-heavy workloads. It is fully compatible with Jakarta EE specifications, supporting enterprise applications with features like advanced just-in-time (JIT) compilation and shared classes for reduced footprint. As of late 2025, IBM provides active quarterly updates and security fixes for Semeru Runtime Certified Edition aligned with Java SE 25, with support commitments extending through at least the end of 2025 and beyond for LTS versions on z/OS platforms. BellSoft Liberica JDK is an OpenJDK distribution from BellSoft, offering builds with HotSpot and OpenJ9 JVMs and commercial support options tailored for emerging architectures like ARM and RISC-V, facilitating seamless deployment in edge computing and IoT scenarios. It includes native image profiling tools for ahead-of-time (AOT) compilation and performance analysis, enabling developers to optimize binaries for reduced memory usage and faster execution on resource-constrained devices. Liberica JDK ensures compatibility with Java SE 25 and incorporates updates for modern hardware support as of 2025, with paid support available for enterprise users. These major vendor-supported JVMs emphasize differentiated licensing models, such as Oracle's OTN-based subscriptions and Azul's extended LTS lifecycles, which provide predictability for enterprise environments beyond open-source community timelines. Performance enhancements, like Zing's reported reductions in GC pauses and startup overhead, underscore their value in high-stakes applications, with ongoing 2024-2025 innovations focusing on diagnostics and architectural adaptability.

Niche or Lesser-Known

JamaicaVM, developed by aicas GmbH, is a proprietary Java virtual machine designed for hard real-time applications in safety-critical embedded systems. It features a deterministic and preemptable garbage collector capable of sub-microsecond pause times, enabling predictable performance without reliance on underlying operating systems for its core functionality, though it supports integration with real-time OS like QNX. JamaicaVM supports Java SE up to version 8 and Java ME profiles, with optimizations for minimal footprint and ROMable code generation, making it suitable for resource-limited environments. It remains active as of 2025, primarily adopted in niche sectors such as automotive manufacturing, aerospace, and defense for applications like vehicle control systems and on-board aircraft communications. VMware Tanzu GemFire utilizes standard OpenJDK HotSpot JVM implementations for its in-memory data grid platform, certified for compatibility with JDK 8, 11, 17, and 21 as of October 2025. It is optimized for high-throughput enterprise scenarios involving distributed caching, serialization, and low-latency data replication, integrating seamlessly with Spring Data GemFire for cluster management. Primarily used in Java enterprise environments for financial services and large-scale analytics, the core receives ongoing updates through Tanzu GemFire releases. Its adoption remains limited outside GemFire ecosystems due to the platform's specialized focus on distributed data management. BEA JRockit, originally developed by BEA Systems, was a high-performance proprietary JVM emphasizing advanced just-in-time (JIT) compilation for throughput optimization and integrated mission control tools for diagnostics and tuning. Oracle acquired BEA in 2008 for $8.5 billion, incorporating JRockit into its portfolio alongside HotSpot. Key features like the adaptive JIT optimizer and low-latency garbage collectors were progressively merged into HotSpot starting in 2010, with full integration completed by 2016 through a dedicated migration guide for users. As a standalone product, JRockit became inactive post-2016, with extended support ending in December 2018 amid Oracle's consolidation of Java technologies. Other lesser-known proprietary JVMs include Sun's Compact Virtual Machine (CVM), a full-featured implementation for the Connected Device Configuration (CDC) in J2ME, targeted at higher-end consumer electronics and networked devices with support for personal Java profiles. Developed by Sun Microsystems, CVM was discontinued around 2010 following Oracle's acquisition of Sun, as focus shifted away from legacy J2ME profiles toward modern Java SE and embedded alternatives. PreonVM, created by Virtenio for ultra-constrained microcontrollers like Atmel AVR, provided a lightweight JVM for sensor networks and IoT prototypes but saw no major activity after 2015, rendering it inactive. The Intent VM from Tao Group offered a portable Java runtime for early mobile platforms including PocketPC and Symbian OS, enabling cross-device content execution, but became defunct in the mid-2000s after Tao's acquisition by Thomson Multimedia in 2003, amid the decline of proprietary embedded Java stacks. Overall, these niche JVMs are largely inactive or fully merged into broader platforms due to market consolidation, particularly Oracle's acquisitions of Sun and BEA, which streamlined commercial Java offerings toward HotSpot dominance by 2025. Their unique contributions, such as real-time determinism and embedded optimizations, persist indirectly in specialized tools but with limited standalone viability.

Specialized Implementations

For Embedded and Real-Time Systems

Java virtual machines designed for embedded and real-time systems prioritize minimal resource usage, deterministic behavior, and integration with real-time operating systems (RTOS) to meet stringent constraints in environments like automotive controls, avionics, and industrial automation. These JVMs often employ ahead-of-time (AOT) compilation, bounded garbage collection, and static configurations to ensure predictability and low latency, distinguishing them from general-purpose implementations. As of 2025, advancements focus on supporting emerging architectures such as RISC-V for IoT edge devices, enhancing portability in resource-limited settings. Among open-source options, JamVM stands out as a lightweight JVM conforming to the JVM specification version 2, optimized for embedded platforms including AVR and ARM microcontrollers, and licensed under the GPL. It pairs with compact class libraries like GNU Classpath to fit within constrained memory footprints, though development has been inactive since around 2014, making it notable primarily for historical embedded deployments. Similarly, the Mika VM, licensed under BSD, targets low-end devices with a Java ME/CDC runtime environment, enabling execution on various embedded platforms, but it remains inactive with no updates since the early 2010s. NanoVM, also GPL-licensed, provides a portable implementation for 8-bit microcontrollers like Atmel AVR, supporting standard Java bytecode on devices with as little as 8KB of code space; however, its development stalled after 2007, limiting it to legacy microcontroller applications. Proprietary solutions address real-time demands more robustly. JamaicaVM, developed by aicas, is a Java-based runtime with deterministic, preemptable garbage collection and RTOS integration, certified for safety-critical use including MISRA C++ compliance in its implementation layers, making it suitable for automotive and aerospace embedded systems. As of March 2025, JamaicaVM version 8.10.1 added support for QNX 8.0 and VxWorks 24.03. Azul's Zulu Embedded builds of OpenJDK provide low-pause garbage collection mechanisms for embedded scenarios, supporting applications in infotainment, home automation, and edge gateways with verified Java SE compliance and minimal footprint optimizations. Early Java OS integrations further illustrate embedded adaptations. JX OS, a GPL-licensed, component-based microkernel system from the University of Erlangen, incorporates a custom JVM for protection domains and runs on embedded PCs like the DIMM-PC, with its last major release in 2007. Sun's JavaOS, an embedded OS from the 1990s that bundled the KVM for applet execution, targeted network computers and smart cards but was discontinued in 2004 following joint announcement by Sun and IBM. Unique features in these JVMs enhance security and certifiability for real-time embedded use. Many disable dynamic class loading to prevent runtime vulnerabilities and enable static analysis for compliance with standards like DO-178C in aviation, ensuring verifiable predictability without unbounded operations. Ongoing efforts to add experimental RISC-V support in OpenJ9 are underway as of 2025, potentially facilitating IoT deployments on open-source hardware with low-power profiles.

For Mobile, IoT, and Robotics

Java virtual machines designed for mobile, Internet of Things (IoT), and robotics environments prioritize low power consumption, minimal memory footprints, and seamless integration with sensors, actuators, and battery-powered hardware, often building on Java Micro Edition (Java ME) standards like CLDC for constrained devices. These JVMs enable portable applications across smartphones, wearables, edge nodes, and robotic platforms such as Lego Mindstorms, adapting Java's platform independence to resource-limited settings where traditional full-scale JVMs like HotSpot would be inefficient. As of 2025, developments in this domain emphasize cross-platform compatibility and native-like performance to support the growing ecosystem of IoT devices and mobile robotics. Among open-source implementations, leJOS serves as a prominent firmware replacement and JVM for Lego Mindstorms robotics kits, licensed under the GPL. Development stalled after the 0.9.1-beta release in 2015, but it remains usable for educational and hobbyist robotics projects on EV3 and NXT bricks. It allows developers to program using Java, incorporating robotics-specific APIs for motor control, sensor feedback, and real-time navigation, optimizing bytecode execution for the ARM-based EV3 hardware and enabling complex behaviors such as autonomous navigation and multi-robot coordination while fitting within the brick's limited 64MB RAM. Codename One provides another open-source solution via its ParparVM, a lightweight JVM tailored for cross-platform mobile applications targeting iOS, Android, and desktop environments. ParparVM employs ahead-of-time (AOT) compilation to translate Java bytecode into native C code, reducing runtime overhead and enabling high-performance UIs and app logic on battery-constrained devices without requiring a full JIT compiler. This approach supports Java ME-like subsets for mobile development, allowing developers to build once and deploy natively, with features like touch event handling and network APIs suited for mobile IoT gateways. Specialized JVMs have also emerged for niche mobile and sensor applications. The Squawk VM, originally developed by Sun Microsystems for Java ME on IoT and embedded platforms, is a self-hosted JVM written entirely in Java that runs directly on bare metal without an underlying OS, making it influential for early wireless sensor deployments like the Sun SPOT platform. Released under the GPL, Squawk supports isolates for concurrent execution on low-power devices but has been inactive since the early 2010s, though its design principles continue to inform modern IoT virtualization. Similarly, TakaTuka is a GPL-licensed JVM optimized for wireless sensor networks on tiny motes, featuring bytecode-level optimizations for 8-bit microcontrollers and stalled development in the 2010s after initial releases around 2010. For legacy mobile and embedded scenarios, SuperWaba evolved into its active successor TotalCross, an open-source SDK under LGPL v2.1 that extends Java-like programming to Palm OS derivatives, Windows CE, and modern IoT devices, emphasizing low-footprint GUIs and cross-compilation for resource-starved hardware. In the IoT domain, GraalVM's native image technology compiles Java applications ahead-of-time into standalone executables optimized for edge computing, drastically reducing startup times to milliseconds and memory usage to under 10MB, ideal for battery-powered sensors and robotics controllers in 2025 deployments. This AOT approach, integrated with OpenJDK, supports Java SE subsets on constrained devices, enabling efficient execution of IoT protocols like MQTT alongside sensor data processing without a traditional JVM runtime. Complementing these, the Kilo Virtual Machine (KVM), a foundational Java ME component, operates as a minimal interpreter for devices with as little as 128KB of memory, incorporating CLDC APIs for sensor integration and power management to facilitate mobile and IoT applications on early wireless platforms.

References

  1. https://docs.oracle.com/en/java/javase/25/vm/java-virtual-machine-technology-overview.html
  2. https://eclipse.dev/openj9/
  3. https://www.graalvm.org/
  4. https://www.azul.com/products/prime/
  5. https://openjdk.org/projects/jdk/25/spec/
  6. https://docs.oracle.com/javase/tutorial/getStarted/intro/changemylife.html
  7. https://openjdk.org/groups/conformance/JckAccess/
  8. https://www.oracle.com/a/ocom/docs/dc/ww-brief-history-java-infographic.pdf
  9. https://www.tech-insider.org/java/research/1998/05-a.html
  10. https://www.cnet.com/tech/secret-weapon-for-java-speed/
  11. https://www.ibm.com/docs/en/sdk-java-technology/8?topic=introduction-java-virtual-machine
  12. https://www.openlogic.com/blog/what-openjdk
  13. https://www.oracle.com/corporate/pressrelease/oracle-buys-sun-042009.html
  14. https://adoptium.net/about
  15. https://aws.amazon.com/about-aws/whats-new/2019/01/amazon-corretto-is-now-generally-available/
  16. https://www.infoq.com/news/2018/04/oracle-graalvm-v1/
  17. https://openjdk.org/projects/valhalla/
  18. https://openjdk.org/projects/jdk/25/
  19. https://openjdk.org/projects/babylon/
  20. https://openjdk.org/
  21. https://github.com/eclipse-openj9/openj9
  22. https://www.graalvm.org/faq/
  23. https://adoptium.net/
  24. https://aws.amazon.com/corretto/
  25. https://www.azul.com/downloads/?package=jdk
  26. https://www.oracle.com/java/technologies/java-se-support-roadmap.html
  27. https://www.oracle.com/java/technologies/javase/jdk-faqs.html
  28. https://docs.azul.com/prime/c4-garbage-collection.html
  29. https://archive.qconnewyork.com/system/files/presentation-slides/java_at_speed.pdf
  30. https://www.ibm.com/products/semeru-runtimes
  31. https://bell-sw.com/blog/bellsoft-releases-liberica-jdk-21-for-risc-v-with-support/
  32. https://bell-sw.com/pages/downloads/
  33. https://www.aicas.com/products-services/jamaicavm/
  34. https://embeddedcomputing.com/technology/software-and-os/java-brewing-in-embedded-with-targeted-virtual-machine
  35. https://www.aicas.com/jamaica/8.10/doc/JamaicaVM-8.10-Release-Notes.html
  36. https://www.aicas.com/download/manuals/aicas-JamaicaVM-8.10-Manual.pdf
  37. https://www.aicas.com/use-cases/
  38. https://www.aicas.com/products-services/jamaicavm/memory-safety/
  39. https://www.aicas.com/customers/defense/
  40. https://techdocs.broadcom.com/us/en/vmware-tanzu/data-solutions/tanzu-gemfire/10-1/gf/getting_started-system_requirements-java_support.html
  41. https://docs.spring.io/spring-data-gemfire/docs/1.9.8.RELEASE/reference/html/
  42. https://www.crn.com/news/applications-os/207402952/oracle-wraps-up-bea-systems-acquisition
  43. https://indicthreads.com/7157/oracle-to-merge-hotspot-jvm-jrockit-java-virtual-machine-jvm/
  44. https://www.infoq.com/news/2010/02/jrockit_hotspot/
  45. https://blogs.oracle.com/java/post/now-available-migration-guide-from-oracle-jrockit-jvm-to-hotspot-jvm
  46. https://support.oracle.com/knowledge/Middleware/2244851_1.html
  47. https://www.aicas.com/about-us/news/
  48. https://www.azul.com/use-cases/iot-embedded/
  49. https://github.com/eclipse-openj9/openj9/labels/arch%253Ariscv
  50. https://www.oracle.com/java/technologies/javameoverview.html
  51. https://lejos.sourceforge.io/
  52. https://sourceforge.net/p/lejos/news/
  53. https://www.codenameone.com/developer-guide.html
  54. https://github.com/codenameone/CodenameOne
  55. https://www.researchgate.net/publication/303079565_The_squawk_virtual_machine_Java_on_the_bare_metal
  56. https://sourceforge.net/projects/takatuka/
  57. https://totalcross.com/
  58. https://www.graalvm.org/22.3/reference-manual/native-image/
  59. https://barrgroup.com/blog/kvm-small-java-virtual-machine-j2me
Add your contribution
Related Hubs
User Avatar
No comments yet.