New And Noteworthy

Improved Application Performance

The performance of applications optimized for AMD64 and ARM architectures has improved significantly thanks to:

  • New optimizations in the AOT compiler, including all-new profile-guided optimization
  • Complete rewrite of the JIT compiler
  • Optimizations of the runtime engine

Profile-Guided Optimization

It's no secret that HotSpot and other advanced JIT compilers benefit tremendously from having application execution profile data at their disposal. A lesser known fact is that all popular C++ compilers, free and commercial, implement profile-guided optimization (PGO) as well.

Starting from version 12, Excelsior JET, Enterprise Edition and Excelsior JET Embedded offer PGO as an option. Specifically, two extra steps are injected into the build process:

  1. Build the project normally, i.e. without PGO
  2. New Step Run the resulting binary under typical load with profiling enabled
  3. New Step Rebuild the project with PGO enabled
  4. … (proceed as before: test, package, etc.)

The good news is that the overheads are less significant than you might expect:

  • You do not need to re-build your application in a special profile-collecting mode. Profiling can be enabled for any normally built executable at launch time.
  • We've implemented smart compilation for this specific scenario — a class only gets recompiled on step 3 if PGO would change its code compared to the initial build. Typically, only a small portion of the application code is recompiled with PGO.
  • The first two steps may be omitted on subsequent builds, as long as the code changes are not expected to make a considerable impact on the execution profile.

In our tests, application performance improvements delivered by PGO can be quite significant, but it is up to you to conduct the measurements necessary to decide whether these extra steps in the build process are worth the change in application performance.

Notice The compiler option that enables PGO has no effect on the 32‑bit x86 targets yet. Profile collection works, as it may help resolve technical support issues. This enables you to use the same project file and build script for the 32‑bit and 64‑bit builds of your application for Windows and/or Linux.

Learn how to use PGO »

64-bit Global Optimizer

The Global Optimizer has long been the staple of the original Excelsior JET AOT compiler targeting 32-bit Windows and Linux. The technology is finally getting into the newer AMD64 and ARM compilers. Its first instance found in Excelsior JET 12 can help reduce the disk footprint of your applications, but more importantly, it can significantly improve application performance when combined with PGO.

Smaller 64-bit Executables

The 64-bit Excelsior JET 12 compilers produce executables that are on average 7% smaller compared to version 11.3.

Build Tool Integration

Excelsior JET Maven and Gradle plugins now support all application types beside Eclipse RCP and almost all features accessible through the graphical interfaces.

Platform-Specific Improvements

  • The 64-bit Linux version no longer depends on 32-bit libraries

Still Missing in The 64-bit Version

  • Some compiler optimizations
  • Startup Accelerator (missing in the OS X version only)

We do intend to port these features over.

Download Excelsior JET 12 Evaluation Package Now

Update 06-Mar-2017: Maintenance Pack 1 adds support for Java SE 8u121, fixes a compilation error observed on projects involving Netty, Tomcat 8, Guice, Guava frameworks.

New And Noteworthy

Linux/ARM Support

Excelsior JET Embedded now supports 32-bit Linux/ARM targets.

Support for Compact Profiles

Java SE 8 Compact Profiles are now fully supported in Excelsior JET Installation Toolkit. Now you can deploy your Java applications bundled with an appropriate Compact Profile without any dependencies. As a side-effect, the Java Runtime Slim-Down deployment mode has been deprecated and will be removed in future releases.

Reduced Application Memory Usage

The memory management subsystem substantially re-worked to reduce the application memory footprint and avoid throwing an OutOfMemoryError in many (edge) cases.

64-bit App Performance Improvements

More optimizations were implemented in the 64-bit versions of Excelsior JET. As a result, application performance has increased. Timings improved from 6% to 29% across our benchmark suite, with median at 9%.

Robustness Improvements

Memory management subsystem re-worked to cure unexpected OutOfMemoryError thrown under heavy load.

Ease-of-use Improvements

Fully scripted builds
The command line interface of the xpack utility was extended to enable building installation packages without using the JetPackII GUI.
Maven and Gradle plug-ins
The Excelsior JET Maven and Gradle plugins now support most product features for plain Java SE applications and Tomcat Web applications. Update 25-Nov-2016: Invocation libraries and Windows services are now also supported.
Streamlined usage of multiple Excelsior JET versions
Installing and using multiple versions of Excelsior JET on the same system has become easier.

Platform Support

Windows 10 added to the list of fully supported platforms (i.e. Excelsior JET 12.0 has passed the official Java Compatibility Kit test suite on it).

Excelsior JET Embedded 11.3 is the first version to support code generation for ARM CPUs.

Java Technologies Support

Excelsior JET 11.3 supports Java SE 8 Update 121 out-of-the-box. The Enterprise Edition now supports Eclipse RCP 4.5 (Mars) and Apache Tomcat 8.0.

Tomcat Web applications support and CoreBalance Garbage Collector are now enabled in Excelsior JET Embedded.

Update 06-Mar-2017: Support for Oracle's January 2017 CPU (Java SE 8 Update 121) is included in Maintenance Pack 1.

Still Missing in The 64-bit Version

  • A number of advanced compiler optimizations
  • Global Optimizer
  • Startup Accelerator (missing in the OS X version only)

We do intend to port these features over.

Update 07-Dec-2015: Maintenance Pack 1 fixes a critical issue in the runtime that may cause sporadic IOExceptions.

Update 11-Mar-2016: Maintenance Pack 2 supersedes MP1.

Update 29-Apr-2016: Maintenance Pack 3 supersedes MP2.

New And Noteworthy

  • Java SE 8 and JavaFX 8 are now fully supported
  • Startup time improvement technologies ported over to the 64‑bit versions (except for Startup Accelerator on OS X)
  • The xpack utility extended to enable the creation of installation packages from the command-line, i.e. without the use of JetPackII GUI at all

Robustness Improvements

  • Memory management subsystem re-worked to cure unexpected OutOfMemoryError thrown under heavy load
  • The root cause of some sporadic access violation crashes found and eliminated

Java version support

Excelsior JET 11 supports Java SE 8 Update 40 (1.8.0_40) out-of-the-box.

Update 07-Dec-2015: Support for Oracle's October 2015 CPU (Java SE 8 Update 65) is included in Maintenance Pack 1.

Update 11-Mar-2016: Support for Java SE 8 Update 72 is included in Maintenance Pack 2.

Update 29-Apr-2016: Support for Java SE 8 Update 91 is included in Maintenance Pack 3.

Still Missing in The 64-bit Version

  • A number of advanced compiler optimizations
  • Global Optimizer, and hence Java Runtime Slim-Down
  • Startup Accelerator (missing in the OS X version only)

We do intend to port all these features over.

New And Noteworthy

  • CoreBalance™ Garbage Collector
  • Support for Eclipse RCP 4.4 (Luna)
  • Support for OS X 10.10
  • Trial generation ported over to the 64‑bit version
  • 64‑bit executables are now faster:

    Excelsior JET 10.5 vs 10.0 SPECjvm2008 chart

Still Missing in The 64-bit Version

  • A number of advanced compiler optimizations
  • Startup Optimizer and Startup Accelerator
  • Global Optimizer, and hence Java Runtime Slim-Down

We do intend to port all these features over.

Java version support

Excelsior JET 10.5 supports Java SE 7 Update 55 (1.7.0_55) out-of-the-box.
Update 17-Mar-2015: Support for Oracle's January 2015 PSU update (1.7.0_76) is optionally included with Maintenance Pack 1.
Update 25-May-2015: Support for Oracle's April 2015 PSU update (1.7.0_80) is optionally included with Maintenance Pack 2.

New And Noteworthy

OS X Support

The 64‑bit versions of Excelsior JET, Professional and Enterprise Editions are now available for Apple OS X desktop operating system.

New And Improved in The 64-bit Version

  • OS X support
  • Application performance improvements evidenced by industry‑standard and popular benchmarks:
    • SPECjvm2008 and SPECjbb2002 composite scores improved by more than 25%
    • 20% to 60% speedups observed on the DaCapo benchmark suite
    • etc.
  • Executable sizes reduced by 15-25%

Benchmark results improved across the board:

Excelsior JET 9 vs 10 benchmarks

Still Missing in The 64-bit Version

  • More advanced compiler optimizations
  • Startup Optimizer and Startup Accelerator
  • Global Optimizer, and hence Java Runtime Slim-Down
  • Generation of trial versions

We do intend to port all these features over.

Java Version Support

Excelsior JET 10 supports Java SE 7 Update 55. More recent versions will be supported via updates, as usual.

New And Noteworthy

Support for Java SE 7

Java SE 7 Update 40 is supported out of the box, later updates will be supported through add-ons, as usual.

Update 19-May-2014: Maintenance Pack 2 adds support for Java SE 7 Update 55.

New Platform

Linux x64 is added to the list of supported platforms.

Other improvements

Stack trace printing is now enabled by default, so as to improve the de-facto compatibility with other Java implementations.

New And Improved in The 64-bit Version

  • Linux support
  • Compilation time reduced by 10% on average
  • Compiler memory footprint 3x lower
  • Application performance improvements:
    • 1.2x improvement of SPECjvm2008 composite score
    • 1.6x to 2x higher performance of selected tests from EEMBC and DaCapo benchmark suites.

Still Missing in The 64-bit Version

  • More compiler optimizations
  • Startup Optimizer and Startup Accelerator
  • Global Optimizer, and hence Java Runtime Slim-Down
  • Generation of trial versions

We do intend to port all these features over.

Also, Excelsior Installer is unavailable in the 64‑bit Linux version.

Update: Excelsior Installer is available in the 64‑bit Linux version starting from Maintenance Pack 2.

At a Glance

Excelsior JET 8.0 is the first to support generation of 64‑bit Windows executables, enabling large heaps and integration with 64-bit native libraries. On the 32‑bit front, it delivers application performance and stability improvements over 7.6 on both Windows and Linux.

New And Improved in This Release

The Professional and Enterprise Editions of Excelsior JET are now capable of generating 64-bit Windows executables and DLLs, enabling the compiled applications to allocate over 4GB heaps and integrate with 64-bit native libraries.

However, please note that this is the first ever 64-bit release, so it has some issues (that we will surely address in the future):

  • Certain features are not available in the 64‑bit version (see Deprecated/Delayed Features below)
  • Applications are noticeably faster when compiled with the 32-bit version. Some apps are 1.5x-2x faster in 32-bit native executable form.
  • There is no support for 64-bit Linux yet

The 32-bit Excelsior JET 8.0 is functionally equivalent to version 7.6, but there were important changes under the hood. In particular, the substantially re-worked memory management subsystem delivers, compared to Excelsior JET 7.6:

  • 15-20% higher performance on memory intensive applications
  • 10-50% shorter GC pauses
  • Eliminated root causes of unexpected OutOfMemoryErrors
  • Fixes of certain sporadic access violation crashes (TRAP#3, TRAP#17), except for those provoked by JNI misuses in third-party components

There is also one known regression in the 32-bit version: JIT compilation time (fast JIT mode) has increased by 25% on average.

Deprecated/Delayed Features

As of version 8.0, the following features are deprecated in 32-bit Excelsior JET and will be removed in the next release:

  • Optimizing JIT compiler
  • JIT caching (including recompilation and deployment)
  • Executable Image Optimizer
  • Splash screen extensions

In addition, the following features are unavailable in the 64‑bit version:

  • All deprecated features listed above
  • Startup Optimizer and Startup Accelerator
  • Global Optimizer, and hence Java Runtime Slim-Down and disk footprint reduction
  • Generation of trial versions

The non-deprecated features will be enabled in the 64-bit version in the future.

For more information, please refer to the respective blog post.

Java Version Support

Excelsior JET 8.0 supports Java SE 6 Update 43. (Yes, we are working on Java 7 support.)

At A Glance

Excelsior JET 7.6 is an interim release that enhances optimized applications performance and improves their stability. It also supports newer versions of Java SE 6, Eclipse RCP and Apache Tomcat. Details follow.

Performance Enhancements

In our results, performance of the optimized applications, especially those running on multi-core/multi-CPU systems, increased from 1.2x to 2.6x on certain benchmarks. Your mileage will vary, of course.

Stability and Compatibility Improvements

In the course of the JET Runtime redesign, we have fixed a few issues that caused sporadic access violations (TRAP #3) in long-running applications, unexpected OutOfMemoryError throwing, and occasional application crashes on 64-bit Windows.

We have also aligned our implementation with HotSpot in the following aspects (imprecisely defined in the Java spec):

  • The order of elements in arrays returned by the methods Class.getFields() and Class.getDeclaredFields() is now the same
  • JNI functions now continue working even if there is a pending exception in the thread (in the previous versions of the JET Runtime they could have immediately returned)
  • When getting JNI IDs, the lookup order of class members including those declared in superclasses/superinterfaces is now the same

Installation Toolkit enhancements

By popular demand, arbitrary icons may now be selected for file associations on Windows.

For Tomcat-based applications, Excelsior Installer may now prompt the user to change the HTTP port during installation.

Other improvements

Excelsior JET 7.6 supports Java SE 6 Update 27, and support for Eclipse RCP 3.7 (Indigo) and Apache Tomcat 7.0 has been added to the Enterprise Edition.

Update 13-Mar-2013: Maintenance Pack 6 adds support for Java SE 6 Update 41,

Update 14-Nov-2012: Maintenance Pack 5 adds support for Java SE 6 Update 37,

Update 31-Aug-2012: Maintenance Pack 4 adds support for Java SE 6 Update 34, Equinox OSGi 3.8, and Eclipse RCP 4.2.

(Support for Java SE 6 Update 29, 31, and 33 is also available via previously issued updates.)

At A Glance

The major new feature introduced in this release is the Startup Accelerator that enables you to reduce the startup time of large Java applications by a factor of 2.

Excelsior JET 7.2 also reduces build time, speeds up JIT compilation and features usability enhancements.

Startup Accelerator

The newly implemented Startup Accelerator can halve the cold startup time of a large Java application. Its usage is as simple as running the application after compilation on the page Finish of the JET Control Panel. This new feature is also supported in automatic builds.

You may find benchmark results, usage guidelines, and FAQ for the startup optimization on this page.

Build Time Reduction

In our last customer survey, long build times firmly occupied the top spot in the list of annoyances.

You complained, we listened. Our tests show that upgrading to version 7.2 should reduce compilation times by at least 30%. Compilation of large Java applications consisting of tens of thousands of classes can be twice as fast now.

As an extra bonus, building install packages with xpack is about 10% faster.

Usability Enhancements

We are sorry it took us so long to fix this. The JET Control Panel and JetPackII projects now reference application files using relative paths, which eases integration of Excelsior JET into automatic builds.

Excelsior JET 7.2 Enterprise Edition includes an Eclipse IDE plug-in that enables you to optimize, protect and package an Eclipse RCP application from within the IDE. For more details, refer to the file


in your Excelsior JET installation directory.

Installation Toolkit Enhancements

During installation, Excelsior Installer now detects if an existing copy of the application being installed is running and prompts the user to close the application first.

Also, if some application files cannot be overwritten, the installer stops gracefully, asking the user to check if they are used by other applications.

Other Improvements

Faster JIT compilation (as usual)
The average JIT compilation time for various scenarios has been reduced by 15%.
Java version support

Java SE 6 Update 20 (1.6.0_20) is supported.

Note: As of Excelsior JET 7.2, support for J2SE 5.0 is no longer provided. If you have not yet moved to Java 6, you have to use Excelsior JET 7.0 or one of the prior versions.

Eclipse version support

Support for Eclipse RCP 3.6 (Helios) is included.

At A Glance

Excelsior JET 7.0 enables you to protect Web applications running on Apache Tomcat against reverse engineering and IP theft, and distribute them without the original class/WAR files and without dependency on the JDK.

Another new feature introduced in this release is multi-app executables. With it, you may compile several applications into a single executable to simplify deployment and maximize code and data sharing without manually "extracting" common parts into dynamic libraries.

This release also features improved application performance and an important usability enhancement.

Last, but not least, Windows 7 is included in the list of supported platforms.

Protection of Tomcat Web applications

In the previous versions of Excelsior JET, many Tomcat applications could be only handled via the JIT compiler that comes with the JET Runtime, just like it is done by the standard JRE.

Unfortunately, that approach did not provide any IP protection as the application classes had to be distributed in the original bytecode form.

Powered By Tomcat Logo

Protected With Excelsior JET Badge

With Excelsior JET 7.0, the Tomcat Server can be compiled directly to a native code executable together with the deployed Web applications, and distributed without the original class/WAR files.

More details »

Multi-app executables

Now you may compile more than one application into a single executable and select a particular application at launch time via the command line arguments of the executable. This option enables you to:

  • maximize code and data sharing among applications
  • apply the Global Optimizer to several applications at once
  • specify Java system properties and VM options on the command line (which may justify the usage of this feature even for a single application)
  • on Windows, run the same executable as both conventional application and service

For details, please refer to the Excelsior JET User’s Guide, Chapter “Application considerations”, section “Multi-app executables”

Usability enhancement

With the previous versions of Excelsior JET, some applications did not work unless certain library jars and/or the rt.jar file were available at run time.

That was the case for the applications including such components as JasperReports, Apache AXIS, javac or Eclipse JDT compilers, etc. The root cause is that the mentioned components use the original .class files as input data and therefore require their presence for proper operation.

As a result, users had to make special settings for some jars in the JET Control Panel and JetPackII, which was not obvious, not to mention that it increased the size of the installation package and weakened protection.

Now it is no longer required.

Improved application performance

In our results, 1.3x to 2x performance improvement has been achieved for some tests from the EEMBC, DaCapo, and SPECjvm2008 benchmark suites. Your mileage may of course vary.

Installation Toolkit enhancements

  • Windows services can now be run immediately after installation
  • JetPackII now accepts script files for Trial Run. It enables trial run testing for compiled applications that need a special environment to run, e.g. setting some environment variables, starting other processes, etc.

New platforms

Excelsior JET 7.0 has passed Java SE 6 compliance tests on Windows 7, which is now included in the list of supported operating systems.

Other improvements

Better optimization

In the previous versions of Excelsior JET, machine-generated and heavily obfuscated class files used to be compiled with a lower optimization level, which might lead to performance degradation.

Now this drawback has been eliminated, thanks to many Excelsior JET community members who pointed our attention to this problem and reported the respective issues to us.

Lower memory usage
Thanks to a more effective implementation of Java finalization.
Support for latest Java SE updates

Java SE 6 Update 16 (default) and J2SE 5.0 Update 21 are supported.

Note: Excelsior JET 7.0 is the last version with support for J2SE 5.0

Excelsior JET 6.5 provides the most secure environment for running Eclipse RCP applications.

By compiling RCP applications to native code executables you can protect the sensitive code and data from reverse engineering, and prevent tampering with the OSGi bundles.

Overall toolchain scalability improvements make Excelsior JET ready to optimize, protect, and deploy Java applications comprising tens of thousands of classes.

Faster JIT compilation, usability enhancements, improved application performance, and stability improvements conclude the list.

New Features

Protected environment for running Eclipse RCP apps

In the previous versions of Excelsior JET, RCP applications could only be handled via the JIT compiler that comes with the JET Runtime, just like it is done by the standard JRE.

Unfortunately, that approach did not provide any security as the application classes had to be distributed in the original bytecode form.

With Excelsior JET 6.5, Eclipse RCP applications can be directly compiled to native code executables and distributed without the original class/jar files.

Excelsior Installer tweaks

The Install button now appears on the initial dialogs of the installation wizard. It enables the user to install the packaged application immediately using the default settings without walking through all dialogs.

Brazilian Portuguese localization added.


Overall scalability improvements

As a side effect of Eclipse RCP support, all Excelsior JET components now scale better when working with large projects/applications:

  • the JET Control Panel works faster with projects containing many classpath entries
  • the JET Optimizer takes less time and memory to compile large applications
  • the JET Runtime scales better when running Java applications consisting of tens of thousands of classes

The Welcome screen added to the JET Control Panel streamlines the creation of projects for specific types of applications.

The Zoom In/Zoom Out widget has been added to the Classpath grid of the JET Control Panel. It simplifies setting custom optimization properties for applications including lots of classpath entries or OSGi bundles.

The Welcome screen added to JetPackII enables faster creation of installation packages and updates for specific types of applications.

Improved application performance

The following enhancements in the JET Runtime:

  • faster memory allocation and garbage collection
  • accelerated*: access to jar/zip archives
  • lower overheads on calls of Java methods from native methods via JNI

make Java applications work faster.

Faster JIT compilation

The average JIT compilation time for various scenarios has been reduced by a factor of two.

Other improvements

A new diagnostic facility implemented in the JET Runtime provides detailed info about unrecoverable errors

JMX thread CPU time measurement is now supported

New sample on C#/Java integration added (see samples\Invocation\CSharpMain)

Operating System Support

Windows Server 2008 is now supported.

Support for the latest Java SE microversions

Excelsior JET 6.5 supports Java SE 6 Update 12 and J2SE 5.0 Update 17

Customer issues addressed

Multiple issues reported by customers for various Windows flavors and Linux distros have been fixed.

Thanks to all Excelsior JET community members who gave us feedback on the previous versions of our product and participated in Excelsior JET 6.5 beta test campaign.

Excelsior JET 6.4 is the first release that introduces features designed specifically for IP protection enhancement.

The previous versions delivered program code protection "for free", as a side effect of optimizing compilation of Java classes into a native executable. But the program data, such as string literals, appeared verbatim in a hex editor. Now you have an option to scramble that data, as well as any resource files packed into the resulting executable, by checking a single box.

Then, you have to do literally nothing to take advantage of the new Startup Optimizer, seamlessly integrated into the JET Control Panel. It replaces the Executable Image Optimizer, which had to be used from the command line and was only available for Windows.

Version 6.4 removes one of the major annoyances from the Installation Toolkit, that is, the lack of support for JET Runtime updates. We have also taken the first step towards the alleviation of another annoyance, long build times. Now classes are not recompiled if you change project settings not affecting the generated code, e.g. add an icon to the executable or adjust the default GC settings.

Note: Not all new features are available in the Standard Edition. See the Feature Matrix for details.

There are also numerous speed and stability improvements, both in Excelsior JET itself and in the optimized applications, and of course

Support for the latest Java SE microversions

Excelsior JET 6.4 supports Java SE 6 Update 7 and J2SE 1.5 Update 15

New Features

String encryption

Enabled on the Target page of the JET Control Panel, string encryption scrambles all Unicode, UTF-8, and ASCII strings stored in the executable so that they are not immediately visible in a hex editor. These includes:

  • Reflection information
  • String literals
  • Various runtime data, such as the main class name

Strings are decrypted on demand at application run time. In our tests, the impact on performance was minimal, but your mileage may vary.

For details, see Excelsior JET 6.4 User's Guide, Chapter "Intellectual Property Protection", section "Data Protection".

Encryption of resource files

When compiling JAR files, you may enable encryption of enclosed resource files such as images, texts, application data. As a result, the optimized executables no longer include the resources in the original form. This option is available on the Target page of the JET Control Panel.

Resource files are decrypted on demand at application run time. This is a unique feature that cannot be found in Java bytecode obfuscators because Excelsior JET supports application data protection at the JVM level.

In our tests, the impact on performance was minimal.

For details, see Excelsior JET 6.4 User's Guide, Chapter "Intellectual Property Protection", section "Data Protection".

Faster application start up

With the newly implemented Startup Optimizer, the cold start up time of your application can be reduced by a factor of two.

You have to do nothing special to enable this optimization. Just run your app once on the page Test Run of the JET Control Panel and then build the executable as usual.

Here is what happens behind the scenes when you do that:

  1. During Test Run, a start-up profile is collected and saved into a file
  2. That file is automatically added to the project
  3. The compiler reads the profile information and does the necessary optimizations

You do not need to collect the profile each time you modify your app, because in most cases the start-up profile is quite stable. You may wish to recollect it before making the final build for pre-release QA.

The underlying optimization technique relies on the reordering of code and data within the compiled executable. As compared to using the Executable Image Optimizer available in the previous versions of Excelsior JET, the new Startup Optimizer has the following advantages:

  • Extremely easy to use
  • Can be aplied to executables of any size
  • Supported on both Windows and Linux

For maximum effect, use the Startup Optimizer together with the Global Optimizer.

For details, see Excelsior JET 6.4 User's Guide, Chapter "Startup Time Optimization".

Smart compilation (level 0)

The JET Optimizer now tracks changes in the project to avoid recompilation of the entire application if only auxiliary application files and/or project settings were modified. It dramatically reduces compilation time if, for example, you modify version info, runtime settings, resource files, icon/splash screen, etc.

If necessary, you may trigger full recompilation via the Build menu of the JET Control Panel.

In future versions, we will enhance this basic implementation with support for partial recompilation of the project even if some application classes are changed.

Updates for JET Runtime

Now you may create an update package for existing installations if your application was recompiled to work with a newer version of the JET Runtime, which occurs if you:

  • applied a hot fix or Maintenance Pack that include significant modifications
  • started using a new version of Excelsior JET
  • changed the Java SE microversion, e.g. moved from Java SE 6 Update 3 to Update 7
  • changed the major Java version, e.g. started using Java SE 6 instead of J2SE 1.5

When you start creating an update or add an executable compiled for a newer version of the JET Runtime to an update package, JetPackII displays the Runtime Update dialog. With it, you can select an appropriate version of the Runtime to be included in the update package.

In the previous releases, you had to create a new installation package in such cases.

For details, see Excelsior JET 6.4 User's Guide, Chapter "Deployment Automation", section "JET Runtime Updates".


Improved application performance

Thanks to:

  • faster memory allocation and garbage collection
  • enhanced loop optimizations
  • better register allocation

the compiled applications now work faster.

Here is some third-party proof.

Faster JIT compilation
We have managed to reduce the average JIT compilation time for various scenarios by 15-20%. We will continue working on it.
Faster AOT compilation
Build time is reduced by about 15% without compromising the quality of optimizations. We will continue working on it.

This release introduces Java SE 6 support and is fully tested and certified on Windows Vista and Red Hat Enterprise Linux 5, in addition to the previously supported platforms.

The Installation Toolkit now supports adding typical post-install actions to the Excelsior Installer GUI wizard.

Among other improvements are usability enhancements of the Excelsior JET toolchain and higher performance of the optimized Java applications.

Latest Java Version Support

Excelsior JET 6.0 has passed the official Java Compatibility Kit (JCK) test suite for Java SE 6 on a number of platforms and now supports the latest Java SE platform features. The microversion supported out-of-the-box is Java SE 6 Update 3.

J2SE 5.0 is still supported; the included microversion is J2SE 5.0 Update 13.

Operating System Support

Windows Vista and Red Hat Enterprise Linux 5 are now supported.

New features

We have implemented a handful of new features on customer requests:

Post-install actions (Windows only)
You may now add typical post-install actions to the last page of the Excelsior Installer wizard. Examples are launching the application just installed, viewing the readme file, restarting the computer, etc. etc.
Version information for Windows executables

You may now specify the standard version information on page Target of the JET Control Panel. The version information resource is then automatically created and bound to the optimized executable.

Moreover, the version information, such as company name and product version, is propagated to JetPackII and used as the default settings for Excelsior Installer setups.

Difference tracker for updates

When preparing update packages for the created installations, JetPackII now enables you to easily inspect and commit changes between the original installation and the respective files and directories on the disk. As a result, you can add the new and modified files and directories to the update package in a few mouse clicks.

The difference tracker is invoked automatically when you start preparing an update, or can be invoked manually through the main menu of JetPackII.

Other improvements

IDEA Plug-in Update

The IntelliJ IDEA plug-in is updated to work with IntelliJ IDEA 7.0.

(You may find the IDEA Integration plug-in in the ideplugins/IDEA subdirectory of your Excelsior JET installation.)

Higher performance

Delivered by more efficient memory management and better register allocation.

Customer issues addressed

Thanks to all Excelsior JET community members who gave us feedback on the previous versions of our product and participated in Excelsior JET 6.0 beta test campaign.

This release introduces a brand-new deployment technique called Java Runtime Slim-Down that enables you to significantly reduce both download size and disk footprint of your Java SE applications.

Major improvements are higher performance of the optimized Java applications and usability enhancements of the Excelsior JET toolchain.

Download size reduction

With the newly introduced Java Runtime Slim-Down, the size of a complete installation package powered by Excelsior Installer can be reduced to:

  • 8MB for a medium-size Swing/AWT application
  • 5MB for applications using alternative GUI toolkits such as SWT or LWJGL

Note that these figures may vary depending on the size of application's resources such as images and media files.

The size reduction can be achieved by excluding unused components of the Java SE API from the installation and placing them on a web server for on-demand download. This also helps you significantly reduce disk footprint of the installed applications.

The necessary support for Java Runtime Slim-Down is added to the JetPackII graphical tool and the JET Runtime. For more details, refer to Chapter "Java Runtime Slim-Down" of the User's Guide.

Note: Java Runtime Slim-Down is not available in the Standard Edition of Excelsior JET.

Higher performance

This release delivers a major performance increase over previous versions thanks to the enhancements in the JET Optimizer and Runtime:

  • new loop optimizations
  • faster floating-point operations
  • faster memory allocation
  • more effective implementation of other runtime routines

As measured with two standard benchmark suites (SciMark2 and SPEC JVM98), the composite scores have improved by a factor of 1.7.

Usability enhancements

Project Data Base

The multiple files that the JET Optimizer creates and uses on the developer machine during compilation are now automatically placed into a few zip archives which form a Project Data Base (PDB).

When optimizing large Java applications, PDB reduces the workload on the local file system and decreases compilation time. For details, see "Project Data Base" section of the User's Guide.

In addition, the availability of PDB for each compiled project simplifies the creation of multi-component applications as described in section "Multi-component applications" of the User's Guide.

Plug-in for IntelliJ IDEA

The plug-in streamlines the process of optimizing Java applications and packaging them for deployment with Excelsior JET.

You can find the IDEA Integration plug-in in the ideplugins/IDEA subdirectory of your Excelsior JET installation. For more information, visit this page.

Full support for drag-and-drop in JetPackII

When adding files to the installation package, you can now drag files from other applications, such as Windows Explorer, and drop them onto the Package Files panel of JetPackII. In previous versions, drag-and-drop was supported only for the file chooser built in JetPackII.

Project history in GUI tools

Both JET Control Panel and JetPackII now allow you to quickly open one of the recently saved projects (see "Opening a project" sections in the User's Guide for details.)

Other improvements

Faster start-up and lower memory usage

Start-up time of applications compiled with the Global Optimizer is improved by approx. 30%. The optimized applications now take 2 to 4 MB less memory.

Smaller size of update packages

The size of update packages for installations including executables built with the Global Optimizer is reduced by approx. 5MB

Deleting all files from installation folders

Excelsior unInstaller can be configured to remove all files from the installation folder including those created by the application after installation.

When preparing the installation package, you can set this option using the JetPackII tool (see "Specifying Installation Settings"/"Extra facilities" in the User's Guide).

Faster JIT compilation
Support for latest Java SE 5 update

Java SE 5.0 Update 11 is included by default

Customer issues addressed

Thanks to all Excelsior JET community members who gave us feedback on the previous versions of our product.

This release enables you to considerably reduce the disk footprint of your installed Java applications.

Other major improvements are further decrease of the download size of installers created with JetPackII and higher application performance on hardware that supports parallel execution.

Finally, this release adds more installation languages to Excelsior Installer and returns support for J2SE 1.4.2, requested by many customers.

Java SE version support

Good news for customers who resisted migrating to Java 5 for any reason: support for J2SE 1.4.2 is back!

Excelsior JET 4.8 supports J2SE 5.0 Update 9 (1.5.0_09) and J2SE 1.4.2_12 out of the box.

New features

Disk footprint reduction

Now the size of the client installation can be substantially reduced: a medium-size GUI application using SWT over Java SE 5.0 now takes only 20MB of disk space and can be run off a USB flash drive without installation.

Note that the required disk space may vary depending on the size of application's resources such as images and media files.

The disk footprint reduction has been achieved by combining:

  • compilation of used application and platform classes into a single executable
  • effective compression of rarely used components of the JET Runtime
  • on-demand decompression during execution

Other Improvements

Download size reduction

The size of a complete installation bundle for a medium-size Swing application using Java SE 5.0 can now be less than 10 MB. That is, this version saves extra 2 MB on average as compared with Excelsior JET 4.5.

This has been achieved through implementing a more effective compression technique in Excelsior Installer.

Moreover, you can now exclude all optional components of the JET Runtime from redistributions. This functionality is available on the page "Runtime" of the JetPackII tool.

Higher performance

The Desktop Runtime flavor delivers higher performance on HyperThread-enabled processors, dual-CPU systems and multi-core chips, whereas the Server Runtime delivers higher throughput on multi-CPU systems.

More installation languages

Spanish and Polish localization added to Excelsior Installer.

Customer issues addressed

Thanks to all Excelsior JET community members who gave us feedback on the previous versions of our product.

This release enables you to substantially reduce the download size of your Java applications. This newly implemented capability was requested by a number of customers.

New features of Excelsior JET Installation Toolkit include Excelsior Installer for Linux and ability to rebrand the Windows version of Excelsior Installer.

Ease-of-use enhancements, reduced application memory usage, and JIT compiler speedup are among the major improvements.

Finally, the Enterprise Edition has been introduced.

Java SE version support

Excelsior JET 4.5 supports Java SE 5.0 Update 6 (1.5.0_06).

Note: Excelsior JET 4.1 is the last version with support for Java SE 1.4.2. We shall continue to ship it in parallel with 4.5 and future versions.

New Edition

Excelsior JET, Enterprise Edition has all features of the Professional Edition plus an unlimited redistribution license for the Server Runtime.

New features

Application download size reduction
(Professional and Enterprise Editions only)

Now the size of a complete installation package for a medium-size Swing app using Java SE 5.0 is about 12 MB, which is less than the download size of the Sun JRE 5.0 alone (16 MB).

Installation packages of Swing-less GUI applications, e.g. using the SWT API or Java games using the Java2D API can now be less than 10MB in size (see this report for details.)

Note: These figures may vary depending on the size of application's resources, such as images and media files.

The size reduction has been achieved by combining:

  • scalable whole-program analysis implemented in the Optimizer
  • selective compilation of application and platform classes into one executable
  • effective compression using multiple methods such as LZMA and pack200
Excelsior Installer rebranding
(Professional and Enterprise Editions only)

Now you can replace images, texts and titles on the dialogs of the installation wizard to create a uniform appearance for your software product setups.

Excelsior Installer for Linux

The JetPackII wizard is now able to directly generate self-extracting installation executables for Linux. They are powered by Excelsior Installer which provides very effective compression to reduce the size of the installation package.

Note: Excelsior Installer for Linux only has command line interface. The graphical installation wizard found in the Windows version is not yet ported.

Improvements over previous versions

Better performance and lower memory usage

The new global optimizer integrated with the core AOT compiler performs whole program optimizations and creates an executable that includes your application's classes and the required Java platform classes.

This technique provides higher application performance and lower memory footprint.

Note: reduction in memory footprint under Linux is significant (up to 60%), whereas under Windows it is less prominent (up to 10%)

Ease-of-use improvements

Now you can use Excelsior JET Launcher for quick setup of Excelsior JET projects. The Launcher has the same interface as the standard java launcher but instead of immediately running the program, it collects the app settings, such as the classpath, main class, working directory and so on, and invokes the JET Control Panel.

This simplifies project creation to a great extent because most of required settings are extracted from the java launcher's command line automatically.

The new Excelsior JET Launcher is the easiest way to set up a project if your Java application is run through a complex script file.

To start the Excelsior JET Launcher, use its full path name, e.g.


and specify the same arguments as for the standard java launcher.

JIT compilation speeded up

JIT compilation is now 3-5x faster thanks to a newly implemented technique of linking the JIT-ed code.

It is crucial if your Java app must load classes dynamically, e.g. if it uses third-party plug-ins or proxies generated at run time.

Customer issues addressed

Thanks to all Excelsior JET community members who gave us feedback on the previous versions of our product.

Compliance testing

SUSE Linux Enterprise Server 9 is added to the list of platforms on which Excelsior JET has passed the Java Compatibility Kit test suite (JCK) for Java SE 5.0.

Changes in pricing and licensing

Starting from version 4.5, all Excelsior JET purchases include one year of support and upgrades. The price list has been adjusted accordingly.

This release improves ease-of-use of the entire Excelsior JET toolchain and makes a number of customer-requested enhancements to the Excelsior Installation Toolkit. The core engine has been left intact, except for bug fixes.

Java SE version support

Excelsior JET 4.1 supports Java SE 5.0 Update 5 (1.5.0_05) and 1.4.2_10.

Ease of use improvements

Working with separate resources simplified

In the previous versions of Excelsior JET, the procedure of compiling and deploying applications with separate resources, such as directories containing images or media files, was error-prone. Specifically, such applications required a run script to launch on the developer system, and adding separate resources to the installation package was complicated.

Now JET Control Panel always produces clickable executables, and JetPackII enables you to add separate resources to the installation in two mouse clicks.

Automatic conversion of previously created JetPackII projects

JetPackII can now read projects (.jpn files) created for another version of J2SE. Formerly, one had to remove the compiled executables from the project and add them again to retain project settings.

Automatic opening of an appropriate JetPackII project

When starting JetPackII from within the JET Control Panel, the project last used for packaging the application is now automatically opened.

Improvements of Excelsior Installation Toolkit

Updating client installations simplified

"Third-party installer, single root" and "Self-contained directory" are merged into a single control of JetPackII. Deployment of updates for this type of installations can be now reduced to simply copying to the target system the files prepared by JetPackII. In previous versions of the Installation Toolkit, it also required performing certain post-install actions by the third-party installation tool in use.

New shortcuts in update packages

When updating client installations, Excelsior Installer can now add shortcuts to new files included in the updates prepared with JetPackII.

Installation of Windows services simplified

Using the JetPackII wizard, you can now specify default arguments for Windows services included in the installation. In addition, the "Windows services" dialog of Excelsior Installer is simplified to enhance the enduser's experience.

Unattended unistallation

Uninstallation procedure can be now run in the batch mode for the packages installed by Excelsior Installer.

Chapter "Deployment Automation" reworked
The Chapter "Deployment Automation" in the Excelsior JET User's Guide has been thoroughly reviewed and edited to ensure readability, completeness and accuracy.

New features (Professional Edition only)

Generating trials

Now you can create a trial version of your Java application that will expire in a specified number of days after build. As soon as the trial period is over, the application shows the expiration message of your choice upon startup and then exits. The functionality is available through the JET Control Panel or the command line compiler.

Shortcuts to any file with any icon

When preparing an Excelsior Installer setup, you can now add shortcuts to any file from the installation and assign it any icon. For example, you can now customize the icon for the uninstall shortcut in Program Folder. The functionality is available through the JetPackII wizard.

File associations

When preparing an Excelsior Installer setup, you can specify a program from the installation to be associated with a particular file type depending on the file name extension. The functionality is available through the JetPackII wizard. If a file association was specified, Excelsior Installer will display a dialog that shows the file name extensions, description of the associated programs and checkboxes to enable/disable a particular association.

Other improvements

Linux system requirements unified

The inconvenience that the versions of the Linux system libraries on the developer system must be not higher than the versions of those libraries present on enduser systems, is now removed.

Customer issues addressed

Thanks to all Excelsior JET community members who gave us feedback on the previous versions of our product.

Excelsior JET 4.0 has passed the Java Compatibility Kit test suites for J2SE versions 5.0 and 1.4.2 and is certified Java Compatible by Sun Microsystems.

This has enabled us to become a Java Authorized Licensee and include the Sun Java API implementation in Excelsior JET.

New Features and Improvements

Simplified deployment for all Java applications

Optimized applications no longer need the Sun JRE bundled into the installation package or preinstalled on the target system.

As a result, the download size has reduced for applications that used to require the Sun JRE if optimized by a previous version of Excelsior JET. See below for details.

Substantial compatibility improvement

The compliance of Excelsior JET to the J2SE specifications has been verified through passing the Java Compatibility Kit (JCK) test suite.

More flexible garbage collection policy

The amount of available physical memory is considered when scheduling garbage collection. That effectively makes the default memory settings suitable for most target systems.


A native splash screen image of your choice displayed at the very startup of the main executable (Professional Edition only.)

French language support in Excelsior Installer

You may now create installers supporting English, German, French, Russian and Japanese interface languages.

Download size reduction

New compression algorithm in JetPackII/Excelsior Installer (Professional Edition only.) See below for details.

Precompiled profile

You may now begin using Excelsior JET right after installation, without running JET Setup to create a profile.

Reliability and robustness improvements

Customer issues have been addressed.

Restrictions and Removed Features

No support for legacy J2SE versions

Our Java Technology License only covers J2SE 5.0 and 1.4.2, so Excelsior JET 4.0 no longer supports J2SE 1.3.x, 1.4.0, and 1.4.1.

Moreover, future versions of Excelsior JET released after December 31, 2005 shall not support J2SE 1.4.2 either. We can however continue selling version 4.0. Our recent survey has revealed that a number of customers have not moved to J2SE 5.0 yet. We therefore plan to continue shipping and supporting Excelsior JET 4.0 in 2006, in parallel with the newer versions.

Finally, if there will be enough customer demand, we can pay Sun an additional fee and provide support for J2SE 1.4.2 in the future versions of Excelsior JET through a separately priced add-on.

No Java API subsetting

The Java Technology License prohibits subsetting the Java API. This means you will no longer be able to omit any of Excelsior JET runtime components when packaging your application for deployment.

No JetPerfect Global Optimizer

For the same reason, the JetPerfect Global Optimizer add-on will not be commercially available starting from Excelsior JET 4.0. This implies that you will not be able to create a single, all-inclusive binary executable for your application or component, even if you do not care about its size.

However, you will be able to create an all-inclusive directory that contains your executable and necessary runtime support files and can be deployed to other systems by a simple copy operation.

Embedded use restrictions

The Commercial Use License prohibits embedding the J2SE Technology into devices of certain types, such as cell phones, PDAs, TV, set-top boxes, etc. Other embedded uses are subject to royalty payments based on the number of units or concurrent users.

Note: We must stop selling Excelsior JET 3.7 as soon as we release Excelsior JET 4.0. We will continue supporting the existing customers of version 3.7 and previous versions.

Download Size Change Figures

Using "Hello, World" as a baseline and JEdit ( as a Swing fat client sample, we have created complete Excelsior Installer packages that may be deployed on a "clean" target machine (that is, without Sun JRE installed).

Application Installer Size Difference
JET 3.7 Pro JET 4.0 Pro
J2SE 1.4.2
HelloWorld 3.2 MB 12.0 MB +275%
JEdit 31.4 MB 12.8 MB -59%
J2SE 5.0
HelloWorld 33.7 MB 15.2 MB -55%
JEdit 45.6 MB 16.0 MB -65%

Support for the latest Java 2 versions

Excelsior JET 3.7 supports all J2SE 5.0 (Tiger) features on both Windows and Linux. JRE-independent deployment for J2SE 5.0 is not possible, though.

Support for the latest J2SE 1.3.x and 1.4.y microversions is also implemented.

New runtime optimized for parallel execution

Excelsior JET 3.7, Professional Edition introduces a new runtime library optimized for parallel execution. The new runtime is available in three flavors tuned for different application types and hardware configurations:

  • The Desktop Runtime is optimized for use in applications typically running on conventional desktop and notebook computers, such as rich clients.
  • The Workstation Runtime is best suited for technical client applications such as visualization and engineering design, which often run on high-end graphic workstations.
  • The Server Runtime enables your highly concurrent server applications to take full advantage of the computing power available in today's multiprocessor servers.

The runtime library found in the previous versions of Excelsior JET is also available under the name of Classic Runtime.

Excelsior JET 3.7, Standard Edition only includes the Classic Runtime.

Application performance improvements

64-bit integer type support has been rewritten to make better use of CPU registers. As a result, the execution speed of programs that heavily use long variables has improved dramatically.

More objects are now allocated on the stack rather than on the heap, and the newly-introduced object explosion (conversion of stack-allocated objects' fields to local variables) amplifies the effect.

Various improvements have been made in:

  • priority-based code placement
  • register allocation
  • loop optimizations

Faster synchronization primitives have been implemented.

Below are the results of benchmarking Excelsior JET 3.7 against the previous version.

System Configuration

CPU: Intel Pentium IV running at 2.40 GHz
RAM: 512 MB
OS: Windows 2000 Professional
Video: RADEON 9200 SE 64MB at 1024x768x65536c


Longer bar means better performance.

JET 3.7JET 3.6
SPEC JVM98111%100%

System Configuration

CPU: AMD Athlon XP running at 1.0 GHz
RAM: 512 MB
OS: Windows 2000 Advanced Server
Video: S3 Virge DX/GX at 1024x768x16777216c


Longer bar means better performance.

JET 3.7JET 3.6
SPEC JVM98109%100%

Feature shift

In Excelsior JET 3.7, one core feature from the Professional Edition has been added to the Standard Edition: the fast (non-optimizing) JIT compiler without the caching engine. As a result, the Standard Edition now fully supports all features of the Java Platform, including dynamic class loading.

At the same time, the following auxiliary features have been removed from the Standard Edition:

  • NT Services toolkit
  • Memory manager fine tuning options
  • Support for multiroot projects in JetPackII

These features are present in the Professional Edition and will remain so.

Finally, the JetPerfect Global Optimizer has become a free optional add-on to the Professional Edition.

Other improvements

Faster AOT and JIT compilation
Refactoring the internal representation has resulted in reduced memory consumption and improved compilation speed
Executable size reduction
This is a nice side effect of improvements in code optimization.
Movable JetPackII projects
JetPackII now can assist you in moving your project to an environment where locations of package files are different, such as a build server.

New platform:

Linux on the Intel x86 (IA-32) architecture is now supported as the host and target platform.

New features:

  • All-new fast JIT compiler introduced
  • Preliminary support for J2SE 1.5 (Tiger) Beta implemented
    Update: Full support for Tiger will only be available in Excelsior JET 3.7
  • Support for the latest J2SE 1.3.x and 1.4.y microversions implemented

Improvements over previous versions:

  • Breakthrough stability improvements: obfuscated bytecode is no longer an obstacle for using JET
  • Faster compilation of large methods
  • Optimizations crucial for code/data size carefully re-designed, which resulted in 10-20% reduction in size of generated executables.
  • Floating point expressions are now evaluated in accordance with the Java spec. Option GENEXTENDEDFP controls whether FP values may be stored with higher precision.
  • Improved performance for certain application types
  • New sample (Rhino scripting engine) using the fast JIT compiler added
  • Important compatibility improvements and bug-fixes

Version 3.5 is a major release aimed at improving application performance and the product's ease-of-use.

New features:

  • Support for the latest J2SE 1.3.x and 1.4.y microversions implemented
  • Endorsed Standards Override Mechanism is supported. Now you can replace XML and CORBA APIs with newer versions.
  • xjava launcher (similar to the JRE "java" tool) with JIT cache optimization interface introduced (Professional Edition only)
  • Ease-of-use of the JetPerfect Global Optimizer (available in the Professional Edition only) has improved:
    • "feedback mode" for troubleshooting optimized executables
    • human-editable forced usage list
    • support for locale groups
  • Management of product updates/hotfixes installed over the original version is now possible through JET Setup
  • Exception stack trace may now optionally include source file names and line numbers (at the expense of executable size growth)
  • JetPackII and Excelsior Installation Toolkit improvements:
    • support for Unicode License Agreement in JetPackII and Excelsior Installer
    • support for deployment of JIT Cache in JetPackII (Professional Edition only)
    • JRE Lookup API provided for use with third-party installers

Improvements over previous versions:

  • Improved performance (as compared with previous versions, speedup ranges from 1 to 20% on a variety of benchmarks and real world applications)
  • Important stability improvements and bug-fixes
The information about the really old releases is preserved below for the sake of completeness and for its historical importance (to us, anyway.)

Excelsior JET 3.15 13-Aug-2003

Excelsior JET 3.15 is a maintenance update adding support for J2SE 1.4.2 and addressing customer issues. Upgrades are free for registered users of version 3.11.

New in this version:

  • Support for J2SE 1.4.2 and the latest 1.3.1 and 1.4.1 microversions
  • Command-line interface to JetPackII enables unattended creation of installation packages, e.g. from build scripts
  • JetPackII and Excelsior Installer now support the creation of shortcuts in the Startup folder
  • Important stability improvements and bug fixes

Excelsior JET 3.11 Japanese

Excelsior JET 3.11 Japanese version is available exclusively from XLsoft KK - our localization partner and reseller in Japan.

Excelsior JET 3.11 28-Apr-2003

Excelsior JET 3.11 is an important update focused on application deployment facilities and compatibility.

New features:

  • Support for the latest J2SE 1.3.x and 1.4.y microversions
  • JIT cache optimization - applications that extensively use custom classloaders may now be pre-compiled entirely with the JET ahead-of-time compiler
  • JetPackII Screenshots New customizable Excelsior Installer utility for JET-compiled applications and NT services
  • New full-featured JetPackII deployment wizard supporting Excelsior Installer and facilitating the use of third-party installation tools

Improvements over previous versions:

  • Improved performance
  • Smaller executables
  • Important stability improvements and bug-fixes

Excelsior JET 3.0 01-Dec-2002

New features:

  • Full support for the latest J2SE 1.3.x and 1.4.x microversions
  • JIT compilation may be enabled even for explicitly imported classes via reflective shield (Professional Edition only)
  • Executable image optimization for faster application startup and reduced memory consumption (Professional Edition only)
  • Support for large heaps (up to 1.5GB)
  • Scalable parallel garbage collector for n-way systems (Professional Edition only)
  • Toolkit for creating Windows NT Services
  • Support for CD-based applications and NT Services in JetPack
  • Ability to use JET with multiple JDK/JRE versions on a single system and easily switch between them
  • Java-VB6, Java-VBA integration (see samples\invocation\COM)
  • Dynamic class loading across precompiled executable components is fully supported via class to DLL mapping (see samples\DLL\dynamic)
  • Proper support for custom classloaders

Improvements over previous versions:

  • Improved performance, especially for Swing applications
  • Smaller executables
  • Application memory consumption significantly reduced thanks to more sophisticated garbage collection policy
  • Faster garbage collection
  • Compiler's memory requirements lowered
  • Key customer issues addressed

Excelsior JET 2.51 05-Jul-2002

Excelsior JET 2.51 is a minor update featuring:

  1. Support for J2SE 1.4.0_01
  2. Cumulative JetPack Update

Note that v2.51 does not incorporate compiler fixes found in the Maintenance Pack 1.

IBM SWT Support 27-May-2002

Excelsior JET, Professional Edition now allows you to create JRE-independent GUI applications in Java using the IBM SWT library!


Excelsior JET 2.5 05-Apr-2002

Excelsior JET 2.5 is a major upgrade featuring full support for the latest Java platform APIs introduced in JDK 1.4.0 and contributing significantly to the product's ease-of-use through provision of a graphical front-end.

New features:

  1. Full support for the latest JDK 1.4.0 and all 1.3.x_yy flavors
  2. Graphical front-end
  3. Resource binding
  4. Clickable executables

Improvements over previous versions:

  1. Faster memory allocation and garbage collection
  2. Code performance improvements
  3. Smaller executables
  4. Reduced memory usage
  5. JetPacked applications may now create desktop icons and add Start Menu items during install
  6. Stack backtracing implemented
  7. Delphi-Java integration sample added (samples\Invocation\DelphiMain)
  8. Key customer issues addressed

Excelsior JET 2.1 22-Oct-2001

Version 2.1 is an upgrade that further improves performance, scalability and reliability of your Java applications natively compiled with Excelsior JET. Also introduced at this version level is the Personal Edition.

Improvements not specific to a particular Edition:

  1. Overall application performance improved
  2. Application memory consumption reduced
  3. Faster memory allocation and garbage collection
  4. Smaller application executables
  5. Adaptive heap limit introduced
  6. Compilation speeded up and needs less memory
  7. Option IGNORECLASSDUPLICATION introduced for better compatibility with JVM
  8. Import libraries are no longer needed when using dynamic linking
  9. Latest JDK 1.3.1_01 is supported

Professional edition only:

  1. Truly standalone executables for non-GUI apps (vs. JRE-independent in JET 2.0)
  2. JetPerfect Global Optimizer now works faster and produces smaller executables

Excelsior JET 2.0, Professional Edition 01-Jun-2001

New version of Excelsior JET delivers powerful features that enable developers to dramatically improve performance, scalability and code protection of any Java 2 application on the Microsoft Windows platform.

Excelsior JET 2.0, Professional Edition is a breakthrough release that includes:

Mixed Compilation Model

Excelsior JET 2.0, Professional Edition is the first Java to native code compiler for the Windows platform to introduce Mixed Compilation Model. With it, you distribute along with your statically compiled application a caching Just-In-Time compiler, that shall handle dynamically loaded classes unknown at compile-time.

Mixed Compilation Model provides complete support for dynamic class loading, effectively making JET fully conforming to the Java specification. It enables you to statically compile applications that employ RMI Distributed Object Model, Dynamic Proxy API, third-party plugins, or any other mechanisms essentially relying on dynamic loading of classes.

JRE-Independent Executables

Excelsior JET 2.0, Professional Edition allows you to compile your non-GUI (batch or server-side) Java applications into executables that do require neither prior installation of the JRE on the target system nor bundling it with your application using JetPack. This would reduce the typical size of a ready-for-deployment package downto 2-3 MB.

JET 1.03 07-Mar-2001

This is a maintenance release, tested with the latest Sun JDK refresh (version 1.3.0_02). It also fixes a few bugs.

Note: JET no longer supports JDK 1.3.0_01.

JET 1.02 26-Feb-2001

  1. All known localization problems fixed (Japanese, Chinese, Korean, European, etc.)
  2. JetPack-created SFX executables now contain a GUI installer
  3. Memory consumption reduced
  4. Bug fixes

JET 1.01 19-Jan-2001

  1. New benchmark, JET-compiled javac, added (JET/Samples/Bench/PerfectJAVAC). See below the results of benchmarking against the most current Sun and IBM JVMs and IBM Jikes compiler (written in C++)
  2. Oracle JDBC drivers tested (JET/Samples/JDBC)
  3. Samples for XML parsers and XSLTransform added (JET/Samples/XML)
  4. Samples for compiling Java Standard Extensions added: COMM API, JavaMail, JavaHelp, Java3D
    For details, see JET/Samples/JavaExtensions
  5. Updated version of JetPack
  6. Bug fixes

Benchmarking Java compilers

We measured the time required to compile the sources of Sun's javac Java to bytecode compiler with javac itself, on latest Sun and IBM JVMs, with javac compiled by JET, and with IBM Jikes compiler (written in C++). All tests were run on the same system equipped with an Intel Celeron processor running at 375MHz and 320 MB RAM, under control of Windows 2000 Professional.

Compiler Execution Environment Heap size Time, sec
Sun javac from JDK 1.3 Native EXE (JET-compiled) 20 MB 5.2
Sun HotSpot JRE 1.3 20 MB 11.2
IBM JRE 1.3 with JIT enabled 20 MB 20.1
IBM Jikes 1.12 Native EXE - 7.2

As you may see, JET-compiled javac outperformed by far not only itself executed on the state-of-the-art JVMs, but also, to our big surprise, the Jikes compiler, which is written in C++.

JET 1.0 Final 08-Dec-2000

  1. Project for IBM Xeena compilation added to samples
  2. Serialization speeded up
  3. Compilation of fuzzy jars now supported
  4. Project system usage samples added (see samples\PrjSys)
  5. Bug fixes

JET 1.0 Release Candidate 20-Nov-2000

Major improvements

  1. Memory consumption considerably reduced (applications work with lower values of HEAPLIMIT without throwing OutOfMemoryError)
  2. Improved performance
  3. Recursive method optimizations implemented
  4. Plenty of bug-fixes

Minor improvements

  1. JetPack GUI (jetpacker.exe)
  2. Ability to bind an icon to EXE
  3. The option COMPILERTHRES removed as superfluous

JET 0.9 beta 28-Oct-2000

Major improvements

  1. Full Java 2 platform support (CORBA was added thus all JDK 1.3 standard classes are now supported; see Samples\CORBA)
  2. Start-up time significantly reduced
  3. Improved performance
  4. java.lang.ref support implemented in GC (weak references)
  5. JetPerfect memory consumption and compilation time considerably reduced
  6. Plenty of bug-fixes
  7. User's Guide updated

JET 0.7 beta 19-Sep-2000

Major improvements

  1. JDK 1.3 support
  2. Invocation API implemented: you may now call JET-built DLLs from C programs (see JET\Samples\Invocation)
  3. Ultra-fast synchronization (overheads reduced by a factor of 2)
  4. java.rmi packages support (see JET\Samples\RMI)
  5. Performance of JetPerfected apps improved dramatically
  6. Memory manager redesigned: the option GCTHRESHOLD is no longer needed
  7. Considerable performance improvements
  8. Plenty of bug-fixes

Minor improvements

  1. Smart recompilation (the "all" submode is not always required now)
  2. Properties for GC control added: jet.gc.heaplimit (sets HEAPLIMIT at startup), jet.gc.defragment (decreases memory consumption in exchange for GC slowdown)

JET 0.68 beta 14-Aug-2000

Major improvements

  1. HotSym(tm) compilation technology greatly reduces time/memory consumption.

    Resources required to compile Sun's javac with JET:

    Version RAM Time
    0.62 100M 9.36 min
    0.68 30M 2.02 min
  2. Fast thread synchronization causes overhead per synchronized method reduced by a factor of 5.

    As a result, single-thread run-time DLL (XJDK153S.DLL) is no longer needed.

  3. Run-time DLLs shrinked again:

    DLL v0.62 v0.68
    XJDK153.DLL 5.19M 4.25M (-18%)
    XAWT153.DLL 3.97M 3.30M (-17%)
    XSWING153.DLL 5.38M 3.88M (-28%)
  4. Application startup time improved
  5. Fully tested on Windows 2000
  6. A lot of bug fixes

New features

  1. JetPerfect facility supporting global optimizations and smart single component linking (alpha version, recommended for console apps)

    With JetPerfect enabled, JET compiles "Hello world!" to a 567KB EXE file (against 7KB EXE plus 5.1M DLL in version 0.62)

  2. JetPack utility for easy deployment

Minor improvements

  1. Properties setting in environment variable:
        SET JETVMPROP=-Dp1name -Dp2name=p2value
  2. GC anchor tracing (the jet.gc.anchor.trace property enabled) allows you to determine "heap weight" of static fields

JET 0.62 beta 28-Jun-2000

Performance improvements (intrinsic functions implemented)

Several bugfixes

JET 0.61 beta 06-Jun-2000

JET is now capable of compiling class files produced by either

  • javac from Sun JDK 1.2.x
  • javac from Sun JDK 1.3 or
  • IBM's Jikes

A lot of minor compiler bugs had been fixed

Some JDK symbol files accidentally omitted in v0.6 are now included

JET 0.6 beta 19-May-2000

More JDK packages are supported:


Plenty of bugs has been fixed

Minor performance improvements

JET 0.51 beta 16-Apr-2000

Major fixes

  1. AWT applications did not work under Windows 95/98
  2. AWT applications compiled with +GUI failed (+GUI forces running without a console window)
  3. The properties user.home and were not set
  4. Objects serialized to a file by JVM could not be deserialized by a JET-compiled application.


  1. Dynamic registration of native methods is implemented
  2. Size of run-time DLLs is reduced:

    DLL v0.5 v0.51
    XJDK.DLL 5.22M 4.78M (-8%)
    XAWT.DLL 9.30M 4.71M (-49%)
  3. Null pointer checking with zero overhead is implemented

JET 0.5 beta 09-Mar-2000

First public beta.

Java specific object-oriented optimizations are implemented

Type inference and polivariant intermodule analysis allow JET compiler to remove redundant type checks and replace polymorphic calls with static, strongly improving overall program performance and applicability of classical optimizations.

Perfomance has grown up dramatically

Usage of automatic memory instead of dynamic memory is implemented:

Short living objects, fixed and variable size arrays may be allocated on the stack rather than on the heap, considerably reducing memory consumption and garbage collection overhead.

Dynamic memory allocation and garbage collection speeded up

More JDK packages supported:


Object serialization is implemented

Beta-version of java source code front-end is included