Unlock GraalVM: Faster Java, Native Images, and Polyglot Programming

Preface

GraalVM helps developers get more out of Java in three ways: a cutting‑edge JIT compiler for speed, native‑image compilation for instant startup and low memory, and support for multiple languages and polyglot programming.

The quick reference sheet summarizes what GraalVM can do and highlights the most important options and commands.

1. Running Java Applications

The GraalVM distribution includes a JDK, so you can compile Java source with

javac MyApp.java

and run applications using the standard

java -jar MyApp.jar

command. The underlying JVM is HotSpot, so most JVM options still apply, e.g., setting the classpath with

java -cp target/myapp.jar com.example.Main

.

GraalVM’s JIT compiler runs in native‑library mode by default, but you can adjust the compiler configuration with options such as

-Dgraal.CompilerConfiguration=enterprise|community|economy

. To enable compilation logging, use

-Dgraal.PrintCompilation=true

, and for deeper diagnostics,

-Dgraal.Dump=:2

. Java agents can also be attached with

-javaagent:path/to/jar.jar

or

-agentlib:path/to/native/agent

.

2. Compiling to Native Executables

The Native Image feature lets you ahead‑of‑time compile applications into binaries. First install the component with

gu install -L native-image.jar

, then generate a binary using

native-image [options] MyClass

or

native-image -jar MyApp.jar

. Run the resulting executable with

./myApp

.

To build a shared library instead of an executable, use the

--shared

flag and annotate exported methods with

@CEntryPoint

. For static linking, add

--static --libc=muslc

(default is glibc).

3. Polyglot Programming

GraalVM can run Truffle‑based languages such as JavaScript, Ruby, Python, R, and LLVM. Language support is enabled with flags like

--language:js

,

--language:python

, etc. Native Image also supports profile‑guided optimization (PGO) via

native-image --pgo-instrument MyApp

and subsequent profiling steps.

Class‑initialization tracing can be turned on with

-H:+TraceClassInitialization=package.class.Name

. Debugging native‑image builds is possible via

--debug-attach=[port]

. Additional options are listed with

--expert-options-all

.

Running language-specific launchers (e.g.,

node myApp.js

,

graalpython myApp.py

) defaults to native mode; to force JVM mode use

--jvm

, or enable polyglot support with

--polyglot

.

Resource limits can be set, for example

--sandbox.MaxCPUTime=Nms

, to restrict execution time per language context.

4. General Development Tools

GraalVM ships with built‑in development tools such as Chrome DevTools debugging, CPU samplers, CPU tracers, and memory samplers, enabled with flags:

<code>--inspect
--cpusampler
--cputracer
--memsampler</code>

Conclusion

GraalVM is a versatile platform that supports Java, other JVM languages, JavaScript, Ruby, Python, R, and more. It offers a high‑performance JIT compiler, native‑image generation, and polyglot runtime capabilities, making it valuable for modern cloud‑native and microservice development.

Download the GraalVM quick‑reference PDF, print it, and keep it handy to explore these features.