layout: ohc

permalink: /overview/architecture/

Oracle GraalVM Enterprise Edition (GraalVM Enterprise) is a highly productive JDK distribution.

It is designed to accelerate the execution of applications written in Java and other JVM languages while also providing a high-performance runtime for JavaScript, Ruby, Python, and a number of other popular languages.

GraalVM Enterprise's polyglot capabilities make it possible to mix multiple programming languages in a single application while eliminating any foreign language call costs.

This page provides developers, solution architects, and infrastructure architects with an architectural overview of GraalVM Enterprise, as well as information about runtime modes, supported platforms, available distributions, core and additional functionalities, and support levels for various features.

The conceptual overview and advantages of GraalVM Enterprise are described on the [Solutions Overview](/en/graalvm/enterprise/{{ site.version }}/docs/overview/) page.

* [GraalVM Enterprise Architecture](#graalvm-enterprise-architecture)

* [Runtime Modes](#runtime-modes)

* [Available Distributions](#available-distributions)

* [Supported Platforms](#supported-platforms)

* [Distribution Components List](#distribution-components-list)

* [Licensing and Support](#licensing-and-support)

* [Experimental and Early Adopter Features](#experimental-and-early-adopter-features)

* [What to Read Next](#what-to-read-next)

*Figure 1. GraalVM Enterprise Runtime*

The preceding diagram illustrates a complete high-level architecture of GraalVM Enterprise.

GraalVM adds an [advanced just-in-time (JIT) optimizing compiler](/en/graalvm/enterprise/{{ site.version }}/docs/reference-manual/compiler/), which is written in Java, to the HotSpot Java Virtual Machine.

In addition to running Java and JVM-based languages, GraalVM's [Truffle language implementation framework](/en/graalvm/enterprise/{{ site.version }}/docs/graalvm-as-a-platform/language-implementation-framework/) makes it possible to run JavaScript, Ruby, Python, and a number of other popular languages on the JVM.

With GraalVM Truffle, Java and other supported languages can directly interoperate with each other and pass data back and forth in the same memory space.

GraalVM Enterprise is unique as a runtime environment offering several modes of operation: JVM runtime mode, Native Image, Java on Truffle (the same Java applications can be run on either).

When running programs on the HotSpot JVM, GraalVM defaults to the [GraalVM compiler](/en/graalvm/enterprise/{{ site.version }}/docs/reference-manual/compiler/) as the top-tier JIT compiler.

At runtime, an application is loaded and executed normally on the JVM.

The JVM passes bytecodes for Java or any other JVM-native language to the compiler, which compiles that to the machine code and returns it to the JVM.

Interpreters for supported languages, written on top of the [Truffle framework](/en/graalvm/enterprise/{{ site.version }}/docs/graalvm-as-a-platform/language-implementation-framework/), are themselves Java programs that run on the JVM.

[Native Image](/en/graalvm/enterprise/{{ site.version }}/docs/reference-manual/enterprise-native-image/) is an innovative technology that compiles Java code into a standalone binary executable or a native shared library.

The Java bytecode that is processed during the native image build includes all application classes, dependencies, third party dependent libraries, and any JDK classes that are required.

A generated self-contained native executable is specific to each individual operating systems and machine architecture that does not require a JVM.

[Java on Truffle](/en/graalvm/enterprise/{{ site.version }}/docs/reference-manual/java-on-truffle/) is an implementation of the Java Virtual Machine Specification, built with the [Truffle language implementation framework](/en/graalvm/enterprise/{{ site.version }}/docs/graalvm-as-a-platform/language-implementation-framework/).

It is a complete Java VM that includes all core components, implements the same API as the Java Runtime Environment library, and reuses all JARs and native libraries from GraalVM.

Java on Trufle is an experimental technology in GraalVM, available as of version 21.0.0.

GraalVM Enterprise distributions are based on Oracle JDK 8, 11, and 16.

GraalVM Enterprise releases include all Oracle Java critical patch updates (CPUs), which are released on a regular schedule to remedy defects and known vulnerabilities.

GraalVM Enterprise is available for Linux, macOS, and Windows platforms on x86 64-bit systems, and for Linux on ARM 64-bit system.

The base GraalVM binary including all components is experimental on Linux/ARM and Windows.

The GraalVM Enterprise distribution based on Oracle JDK 16 is experimental with [several known limitations](/en/graalvm/enterprise/{{ site.version }}/docs/release-notes/known-issues/).

Depending on the platform, the distributions are shipped as *.tar.gz* or *.zip* archives.

The following are the supported platforms for GraalVM Enterprise 21:

| Operating System | Version | Architecture | Installation Guide |

|------------------------------------ |-------------- |-------------- |------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

| Oracle Linux on OCI | 6, 7, 8 | x86 64-bit | [GraalVM Enterprise Installation Guide on OCI](/en/graalvm/enterprise/{{ site.version }}/docs/getting-started/oci/compute-instances/) |

| Oracle Linux | 6, 7, 8 | x86 64-bit, ARM 64-bit (experimental) | [GraalVM Enterprise Installation Guide for Linux](/en/graalvm/enterprise/{{ site.version }}/docs/getting-started/installation-linux/) |

| Red Hat Enterprise Linux(RHEL) | 6, 7, 8 | x86 64-bit | [GraalVM Enterprise Installation Guide for Linux](/en/graalvm/enterprise/{{ site.version }}/docs/getting-started/installation-linux/) |

| macOS | 10.13 (High Sierra), 10.14 (Mojave), 10.15 (Catalina), 11.2 (Big Sur) | x86 64-bit | [GraalVM Enterprise Installation Guide for macOS](/en/graalvm/enterprise/{{ site.version }}/docs/getting-started/installation-macos/) |

| Windows | 10 | x86 64-bit | [GraalVM Enterprise Installation Guide for Windows](/en/graalvm/enterprise/{{ site.version }}/docs/getting-started/installation-windows/) |

GraalVM Enterprise consists of core and additional functionalities.

**Runtimes**

* Java HotSpot VM

* JavaScript runtime

* LLVM runtime

**Libraries (JAR files)**

* GraalVM compiler - the top-tier JIT compiler

* Polyglot API – the APIs for combining programming languages in a shared runtime

**Utilities**

* JavaScript REPL with the JavaScript interpreter

* `lli` tool to directly execute programs from LLVM bitcode

* [GraalVM Updater](/en/graalvm/enterprise/{{ site.version }}/docs/reference-manual/graalvm-updater/) to install additional functionalities

GraalVM Enterprise core installation can be extended with more languages runtimes and utilities.

Tools/Utilities:

* [Native Image](/en/graalvm/enterprise/{{ site.version }}/docs/reference-manual/enterprise-native-image/) -- a technology to compile an application ahead-of-time into a native platform executable.

* [LLVM toolchain](/en/graalvm/enterprise/{{ site.version }}/docs/reference-manual/llvm/) -- a set of tools and APIs for compiling native programs to bitcode that can be executed on GraalVM.

* [Java on Truffle](/en/graalvm/enterprise/{{ site.version }}/docs/reference-manual/java-on-truffle/) -- a JVM implementation built upon the [Truffle framework](/en/graalvm/enterprise/{{ site.version }}/docs/graalvm-as-a-platform/language-implementation-framework/) to run Java via a Java bytecode interpreter.

Runtimes:

* [Node.js](/en/graalvm/enterprise/{{ site.version }}/docs/reference-manual/js/) -- the Node.js 14.16.1 runtime for JavaScript

* [Python](/en/graalvm/enterprise/{{ site.version }}/docs/reference-manual/python/) -- Python 3.8.5 compatible

* [Ruby](/en/graalvm/enterprise/{{ site.version }}/docs/reference-manual/ruby/) -- Ruby 2.7.2 compatible

* [R](/en/graalvm/enterprise/{{ site.version }}/docs/reference-manual/r/) -- GNU R 4.0.3 compatible

* [GraalWasm](/en/graalvm/enterprise/{{ site.version }}/docs/reference-manual/wasm/) -- WebAssembly (Wasm)

Oracle GraalVM Enterprise Edition is licensed under the [Oracle Technology Network License Agreement for GraalVM Enterprise Edition](https://www.oracle.com/downloads/licenses/graalvm-otn-license.html) for developing, testing, prototyping, and demonstrating Your application.

For production use, GraalVM Enterprise is available as part of the [Oracle Java SE Subscription](https://www.oracle.com/uk/java/java-se-subscription/) which includes 24x7x365 [Oracle premier support](https://www.oracle.com/support/premier/) and the access to [My Oracle Support (MOS)](https://www.oracle.com/support/).

Oracle GraalVM Enterprise Edition features are distributed as fully supported, early adopter, and experimental.

Experimental features are being considered for future versions of GraalVM Enterprise.

They are not meant to be used in production and are not supported by Oracle.

The development team welcomes feedback on experimental features, but users should be aware that experimental features might never be included in a final version, or might change significantly before being considered production-ready.

For more information, check the [Oracle Technology Network License Agreement for GraalVM Enterprise Edition](https://www.oracle.com/downloads/licenses/graalvm-otn-license.html).

The following table lists supported and experimental features in GraalVM Enterprise Edition 21 by platform.

| Feature | Linux AMD64 | Linux ARM64 | macOS | Windows |

|--------------------|---------------|---------------|---------------|

| Native Image | early adopter | experimental | early adopter | experimental |

| LLVM runtime | supported | experimental | supported | not available |

| LLVM toolchain | supported | experimental | supported | not available |

| JavaScript | supported | experimental | supported | experimental |

| Node.js | supported | experimental | supported | experimental |

| Java on Truffle | experimental | not available | experimental | experimental |

| Python | experimental | not available | experimental | not available |

| Ruby | experimental | not available | experimental | not available |

| R | experimental | not available | experimental | not available |

| WebAssembly | experimental | experimental | experimental | experimental |

Users who are new to GraalVM Enterprise or have little experience using it, continue to [Getting Started with GraalVM Enterprise](/en/graalvm/enterprise/{{ site.version }}/docs/getting-started/).

Download and install GraalVM Enterprise on your local machine, try running the examples provided in the guide, or test GraalVM Enterprise with your workload.

We suggest you then look at more complex [Examples Applications](/en/graalvm/enterprise/{{ site.version }}/docs/examples/).

Developers, who have GraalVM Enterprise already installed or have experience using it in the past, can skip the getting started guide and proceed to the [Reference Manuals](/en/graalvm/enterprise/{{ site.version }}/docs/reference-manual/) for

in-depth coverage of GraalVM Enterprise technologies.

layout: ohc

permalink: /overview/

Today’s online global enterprises and microservices alike face the same needs:

achieving better performance, and reducing ever-increasing infrastructure costs.

The evolution from older, layered architectures to microservices requires new,

innovative approaches to running a business either on premises or on the cloud.

Speed, dexterity, and leanness are key, then, to commanding the modern

online marketplace.

GraalVM Enterprise is a foundation for innovation and improvement for both large

enterprise applications and microservices alike.

Built on trusted and secure Oracle Java SE, GraalVM Enterprise accelerates

application performance while consuming fewer resources — improving application

efficiency and reducing IT costs.

In data centers with ever-growing workloads, being able to service more

requests with the same computing infrastructure reduces the need to purchase

additional hardware. Thus GraalVM Enterprise’s reduction of required compute

resources can lower capital cost expenditures on premise and lower operation

costs on cloud.

GraalVM's key advantages:

* Innovative compiler

* Native Image technology

* Language interoperability

* Built on Oracle Java SE

* Trusted Oracle support and updates

GraalVM’s just-in-time (JIT) compiler accelerates the performance of any Java

or JVM-based application - out of the box and without any code changes.

Across the board, applications running on GraalVM Enterprise exhibit lower

latency. Request response times are reduced. Applications run faster, freeing up

CPU and memory sooner, allowing them to handle other requests or other

applications running on the same server.

GraalVM Enterprise also incorporates its optimizing compiler into an

advanced ahead-of-time (AOT) compilation technology: Native Image. The industry-leading native

image builder translates Java and JVM-based applications into native platform

executables that enjoy incredibly fast startup times since the program initialization

is done at build time so, when tasked, the application is already compiled.

Utilizing Native Image, Java applications consume a fraction of the resources

they would if running on a JVM, making GraalVM Enterprise ideal for cloud

deployments large and small.

GraalVM Enterprise breaks the barriers between programming languages.

Java is the most popular language for building enterprise applications but

JavaScript, Python, Ruby, R, and other programming languages have carved out niches

in specific areas, e.g., machine learning. Many have accompanying libraries that provide

unique and valuable features. Hence, developers often use different languages

for specialized applications.

GraalVM Enterprise provides high-performance runtime support for a number of

languages beyond Java, allowing different languages and

libraries to interoperate with no performance penalty. This improves developer

productivity by letting them use the right language or library for a given task.

*Figure 1. GraalVM Enterprise Polyglot Runtime*

Key to GraalVM Enterprise’s polyglot support is language compliance. For each of

the supported languages, GraalVM Enterprise strictly adheres to the

specification for each language and runs their compliance test suites to ensure

compatibility.

GraalVM Enterprise also tracks changes through Oracle’s participation in a

number of standards bodies like Ecma International. GraalVM innovations are in

turn influencing specifications, like the recent announcement of the OpenJDK’s

Project Leyden, which seeks to provide a standard specification for Java binary

executables pioneered by the Native Image technology.

GraalVM Enterprise customers take advantage of 24/7 access to the experienced GraalVM

Enterprise support team who work closely with the Oracle Java support team.

GraalVM Enterprise releases include all Oracle Java critical patch updates

(CPUs) which are released on a regular schedule to remedy defects and known

vulnerabilities.

[Get started with GraalVM Enterprise](/en/graalvm/enterprise/{{ site.version }}/docs/getting-started/) and:

* reduce IT and storage costs

* provide customers with quicker response time

* employ fewer resources, freeing up CPU

* enjoy seamless language interoperability

* take advantage of full support

* receive regularly scheduled updates

* rest assured with the security and stability of Java

Test GraalVM Enterprise with your workload and see for yourself the advantages it brings.

layout: docs

toc_group: examples

link_title: Examples

permalink: /examples/

Here you will find example applications written in Java, JavaScript, R, Ruby, and other JVM languages to illustrate the diverse capabilities of GraalVM.

The GraalVM compiler, enabled by default in GraalVM, assures performance advantages for highly abstracted programs due to its versatile optimization techniques.

Code using more abstraction and modern Java features like Streams or Lambdas will see even greater speedups.

[Java Performance Examples](java-performance-examples.md) and [Java stream API Benchmark](java-simple-stream-benchmark.md) demonstrate this.

The [Polyglot JavaScript, Java, R Example Application](polyglot-javascript-java-r.md) displays GraalVM's abilities as a polyglot runtime, processing programs written in two or more languages.

The [Native Image Examples](native-image-examples.md) illustrate GraalVM's unique capabilities to create self-contained executable images that run remarkably fast.

Here you can also find an even more sophisticated example of polyglot native executables.

The [Java/Kotlin Native Image Example](java-kotlin-aot.md) demonstrates how to compile a Java and Kotlin application ahead-of-time, and illustrates the performance gain.