GraalVM Demos

This repository contains a collection of example applications that highlight key features and best practices for working with GraalVM technologies.

Get Started

To get started, clone this repository and navigate to the relevant demo directory:

git clone https://github.com/graalvm/graalvm-demos.git
cd graalvm-demos

You will find instructions for running a particular demo in the corresponding README.md file. Some demos redirect you to a specific guide on the GraalVM website.

Native Image Demos

Example applications showcasing the capabilities of GraalVM Native Image, including performance optimization and configuration tips.

Build

Demos for building native images, including configurations and setup steps for various use cases.

• hello-world - A HelloWorld example showing how to create a native executable from a class file
• hello-world-layered - A HelloWorld example showing how to create a layered native executable from a class file
• build-from-jar - Shows how to create a JAR file without using Maven or Gradle, and build a native executable from that JAR
• build-java-modules - Shows how to compile a modularized Java application into a native executable without using Maven or Gradle
• build-shared-library - Shows how build a native shared library and then load it from a C application
• build-static-images - Shows how to create a fully static and a mostly-static native executable, unlike the default dynamic one
• build-with-js-embedded - Shows how to embedded JavaScript into a Java application, and then compile it ahead of time
• list-files - Shows how to create a native executable from the command line, and then apply Profile-Guided Optimization (PGO)
• native-build-tools - Contains two Java projects, and shows how to create native executables from those applications using Maven and Gradle plugins for GraalVM Native Image
• preserve-package - Demonstrates how to use the -H:Preserve option to include all classes from a package in a native image, eliminating the need for JSON metadata configuration.
• dynamic-class-loading - Shows how to load classes dynamically in a native executable without rebuilding it, using the experimental Runtime Class Loading feature.

Configure

Demos illustrating how to compile applications with Native Image that use some dynamic Java features including reflection, resource access, and so on.

• access-environment-variables - Showing how to access environment variables in a native executable at run time
• configure-with-tracing-agent - Demonstrate how to use the tracing agent to create a native executable that relies on reflection and requires configuration
• include-metadata - Contains Maven and Gradle Java projects and demonstrates how to include reachability metadata using Native Build Tools
• include-resources - Demonstrates how to register resources to be included in a native executable by providing a resource configuration file
• specify-class-init - Demonstrates how to influence the default class initialization policy, and initialize a specific class at build time
• use-system-properties - Demonstrates how to use system properties in a native executable at build time versus at run time

Containerize

Demos focusing on containerizing native Java applications and following best practices.

• spring-boot-microservice-jibber - Demonstrates how to create a native executable for a Spring Boot web server, containerize it, and run
• tiny-java-containers - Shows how a simple Java application and the jdk.httpserver module can be compiled to produce small container images

Monitor

Demos showcasing how to monitor native applications using observability and diagnostics tools.

• add-jfr - Shows how to build a native executable with JDK Flight Recorder (JFR) events support
• add-jmx - Shows how to build, run, and interact with a native executable using Java Management Extensions (JMX)
• add-logging - Demonstrates how add logging to a native executable by providing necessary logging configuration
• create-heap-dump - Shows how to enable heap dump support and describes all possible ways how to create a heap dump from a native executable
• embed-sbom - Demonstrates how to embed an SBOM in a native executable to identify its dependencies

Optimize

Demos optimizing native applications for different criteria (runtime and performance tuning, file size, build time, and more).

• emit-build-report - Shows how to optimize Size of a native executable using Build Reports
• optimize-memory - Shows how to optimize memory footprint of a native executable
• optimize-with-pgo - Shows how to optimize a native executable with Profile-Guided Optimization (PGO) for performance and throughput

Benchmark

Performance measurement demos for Native Image.

• jmh/binary-tree - Shows how to run a Java Microbenchmark Harness (JMH) benchmark as a native executable

Clouds

Demos showcasing the building and deployment of native applications to Oracle Cloud Infrastructure (OCI), AWS, and Google Cloud.

• native-aws-fargate - Shows how to containerize a native Java application and then deploy it using the Amazon Elastic Container Registry and AWS Fargate
• native-aws-lambda - Demonstrates how to deploy both Java 17 and Native Image applications onto the AWS Lambda platform
• native-google-cloud-run - Demonstrates how to deploy a native Java application onto the Google Cloud Run platform
• native-oci-cloud-shell - Shows how to get started quickly with Oracle GraalVM and use Native Image in Oracle Cloud Infrastructure (OCI) Cloud Shell
• native-oci-container-instances - Shows how to containerize a native Java application and then deploy it on OCI using the Container Instance service
• native-oci-generative-ai - Demonstrates how to use the OCI Generative AI service provided in a Java application, and then compile it ahead of time with Maven

Microservices

Demos for building microservices ahead of time using frameworks such as Micronaut and Spring Boot.

• micronaut-hello-rest-gradle - Demonstrates how to build a native executable from a Micronaut application using Grade plugin for Native Image
• micronaut-hello-rest-maven - Demonstrates how to build a native executable from a Micronaut application using Maven plugin for Native Image
• micronaut-hello-rest-maven-layered - Demonstrates how to build a simple Micronaut REST application using the GraalVM Native Image Layers feature
• spring-hello-rest-maven-layered - Demonstrates how to build a simple Spring REST application using the GraalVM Native Image Layers feature

Web Image

Demos illustrating how to use Web Image, GraalVM's new experimental feature to produce a WebAssembly module together with a JavaScript wrapper that can run in browsers or on Node.js.

• hello-wasm - Demonstrates the experimental GraalVM Web Image feature by compiling a simple JVM application into a WebAssembly module with a JavaScript wrapper.
• export-java-function - Shows how you can call Java methods directly from JavaScript via WebAssembly using the @JS annotation.
• js-java-object-exchange - Demonstrates how you can work with objects: JavaScript sends a request object, Java processes it, and returns a structured response object, via WebAssembly.
• javac - Illustrates how to use GraalVM Web Image to compile javac into a Wasm module, which can then run either on the command line or in the browser. Check out the live demo here.
• spring-shell - Demonstrates how to use GraalVM Web Image to compile a Spring Shell application into a Wasm module that can then run on the command-line or in the browser. Check out the live demo here.

Compiler Demos

Demos designed to test and showcase the capabilities of the Graal Just-In-Time (JIT) compiler. These examples focus on evaluating the compiler's performance, including its optimizations for modern Java workloads.

• java-stream-benchmark - A simple Java Stream benchmark to test the Graal JIT compiler performance against C2

Graal Languages Demos

You can find demos and guides for GraalJS, GraalPy, GraalWasm, and other Graal Languages at github.com/graalvm/graal-languages-demos/.

Archived Demos

Legacy or blog-related demos, as well as examples involving polyglot capabilities.

License

Unless specified otherwise, all code in this repository is licensed under the Universal Permissive License (UPL).