Excelsior JET Feature Matrix

Side by side comparison of available Excelsior JET editions.

new - New in the current version x64 - Not ported to the 32‑bit (x86) version yet
- This feature/capability is either O/S-specific, or has not been ported to all platforms yet.

Notice Excelsior JET Embedded is nearly equivalent to the Enterprise Edition in terms of feature sets, plus is also available for Linux/ARM targets.

↓ Click to expand
Click to filter rows →
Ent Pro Std
Excelsior JET Optimizer
JET Launcher
Helps you quickly setup Excelsior JET for compiling a Java application into native code.
JET Control Panel
Graphical front-end to the AOT compiler. Facilitates step-by-step creation and easy modification of JET project files
AOT (ahead-of-time) Java to native 32-bit x86 code compiler Win Lin

Highly optimizing compiler that runs on a developer system. It translates Java bytecode instructions into optimized x86 (IA-32) code and converts your Java application's classes and jars into conventional Windows EXE and DLL files or Linux executables and shared objects.

Notice Not available for OS X.

AOT compiler for 64-bit x86 (x64)
Optimizing compiler that runs on a developer system. It translates Java bytecode instructions into optimized AMD64 (Intel 64) code and converts your Java application's classes and jars into conventional binary executables for the target platform.
Incremental ("smart") AOT compilation new
The AOT compiler skips over the jar files that have not changed since the previous build. Incremental compilation is enabled by default in all editions that support it.
Support for AOT-only compilation of Eclipse RCP applications
AOT compiler with built-in support for Equinox OSGi. It translates Eclipse RCP applications into native code executables thus providing protection from decompilers.
Support for AOT-only compilation of Tomcat Web applications
AOT compiler with built-in support for Apache Tomcat. It translates Tomcat Web applications into native code executables thus providing protection from decompilers.
Profile-Guided Optimization (PGO) x64 arm

PGO enables the AOT compiler to base its optimization decisions on an actual application execution profile. The Global Optimizer amplifies the effect.

As of version 12, PGO is implemented in the 64‑bit compiler only.

Global Optimizer

Improves application performance and reduces its memory usage and disk footprint by compiling its classes together with required Java SE API classes into a single executable.

Beginning with version 12, the Global Optimizer is included in both 32‑ and 64‑bit versions.

Startup Optimization Toolkit

Startup Optimizer reduces cold startup time by reordering code and data sections of the resulting executable according to the application startup profile. Startup Accelerator prefetches portions of the executable file upon launch, in the optimal order. Their combined effect is up to 3x faster application startup.

Notice Startup Accelerator has not been ported to OS X yet.

Excelsior JET Runtime
High performance JVM
Complete Java Virtual Machine that works with both Java classes and executables produced by the AOT compiler. Implements support for dynamic compilation, memory management, threading, synchronization, exceptions, and other low-level stuff.
Complete Java SE 8 API
Excelsior JET Runtime includes, in native compiled form, the complete Java SE 8 API implementation licensed from Oracle, enabling your compiled applications to work without the Oracle JRE.
JavaFX 8 API
Also included in the Runtime is the JavaFX 8 API implementation licensed from Oracle.
JIT compiler

The Just-In-Time (JIT) compiler processes dynamically loaded classes that were not precompiled with the AOT compiler for any reason.

Notice The JIT compiler produces non-optimized code, so it is recommended to precompile all known performance-critical classes.

Classic Runtime

Designed to use on low-end hardware which does not support parallel execution such as uniprocessor systems equipped with old CPU models of the x86 architecture.

Not recommended for HyperThread/multi-core CPUs and multi-processor systems.

Desktop Runtime

Designed for use in applications typically running on conventional desktop and notebook computers.

Optimized for single-processor multi-core systems, including HyperThread-enabled.

Server Runtime
Enables your highly concurrent server applications to take full advantage of the computing power available in today's multi-processor servers.
CoreBalance™ Garbage Collector
Effectively utilizes available CPUs and cores to reduce both the average and maximum GC pauses.
Protected environment for Eclipse RCP apps
Supports the core functionality of the Eclipse Runtime at the JVM level. Enables Eclipse RCP executables produced by the Optimizer to run without the original jar files, thus providing protection from decompilers.
Protected environment for Tomcat Web apps
Supports the Apache Tomcat core at the JVM level. Enables running Tomcat Web apps, natively compiled by the Optimizer, without the original jar/WAR files, thus providing protection from decompilers.
Excelsior JET Deployment Toolkit

This tool helps you create application setups powered by the bundled Excelsior Installer or a third-party installation tool of your choice.

It also enables you to prepare a self-contained directory that includes your application alongside the required JET Runtime files.

Java SE 8 Compact Profiles
Compact profiles, introduced in Java SE 8, define subsets of the Java SE Platform API that can reduce the static size of the Java runtime.
Excelsior Installer Win Lin

Provides basic application installation functionality: show splash screen/end-user license agreement, install optimized apps and Windows services, create shortcuts, set file type associations, etc. Supports updates and automatic uninstallation.

Notice This feature is not available on OS X yet.

Pack200+LZMA Compression Win Lin
Excelsior Installer uses a combination of these compression methods to deliver minimal size of installation packages. They also help reduce the disk footprint of pre-installed Java apps that run off removable media such as USB flash drives
Multi-app executables
Compile several applications into one executable, then specify the main class on the command line, alongside with Java system properties.
Windows Services toolkit Win
Includes the WinService API for programming Windows Services in Java, a service installation/removal utility, support for Services in the JET Runtime, Excelsior Installer and in graphical tools.
Generator of trial versions

Enables you to create a trial version of your Java application that will expire in a specified number of days.

Printable documentation
Click to filter rows → Ent Pro Std
Optimize applications that use any Java SE 8 platform API, including JavaFX 8
Excelsior JET includes the reference implementation of the Java SE 8 standard library, licensed from Oracle. It has passed the official Java Compatibility Kit test suite, which in particular covers the entire platform API.
Optimize applications essentially relying on dynamic class loading
Technically, applications based on a dynamic framework, such as Spring, will run if compiled by the Standard Edition, but their startup time and response would be unacceptable.
Optimize applications that use Java Optional Packages such as Java3D, JavaMail, JavaHelp, COMM API, etc.
Compile Java applications into conventional native code executables
Compile Java components into dynamic libraries callable from native code via JNI and Invocation API
Turn your Java applications into Windows services using the supplied API and tools Win
Add standard version information resources to Windows executables Win
Improve performance of your Java applications by compiling them into optimized native code executables prior to deployment.
Maximize performance of Java applications running on HyperThread/multi-core uniprocessor systems
Maximize throughput of Java applications running on multi-processor servers
Reduce average and maximum GC pause times on multi-CPU and multi-core systems
Reduce the cold startup time of your application by 1.5-3x
Reduce application memory usage
Protect plain Java SE applications from decompilation
Protect Eclipse RCP applications from decompilation
Protect Tomcat Web applications from decompilation
Scramble program data (string literals, reflection info, etc.)
Scramble resources (audio clips, icons, data and configuration files) packed into the executable
Create complete application setups that do not require Java (JRE) installed on target systems
Create pre-installed Java apps that run off a USB flash drive
Substantially reduce the download size and disk footprint of Java applications
Create application setups powered by Excelsior Installer Win Lin
Create compact Excelsior Installer-based setups Win Lin
Specify post-install actions such as "launch application", "restart the system", etc. Win
Brand your Excelsior Installer-based setups Win
Replace images, texts and titles on installation dialogs
Create file associations and arbitrary shortcuts with custom icons in Excelsior Installer-based setups Win
Create updates for the previously shipped installation packages
Create trial versions of your Java applications