Blog

GraalVM Team Blog

Top 10 Things To Do With GraalVM

GraalVM enables a very diverse set of new functionality — it is a platform on which you can build more powerful languages and tools and put them into more environments. This article discloses some of the diverse features of GraalVM accompanied by code examples and setup configurations.

06-DEC-2019

Announcing GraalVM 19.0

Succeeding previous monthly "release candidates", GraalVM 19.0 is confirmed as stable, mature and ready for production use. In addition to the release of GraalVM 19.0 Community Edition, there is also the GraalVM 19.0 Enterprise Edition made available by Oracle.

10-MAY-2019

24-FEB-2020

Announcing the GraalVM Project Advisory Board!

GraalVM is an open source project and we highly value the interactions with the community and the ecosystem built around it. The blog post is announcing the GraalVM Project Advisory Board - an advisory committee, composed of key project contributors and partners in the ecosystem with a shared goal of driving the GraalVM project forward.

06-FEB-2020

Improve React.js Server-Side Rendering by 150% with GraalVM

This blog post demonstrates how to port a fairly large application that executes both Scala and TypeScript/JavaScript on the server-side, within a JVM. The web application written for Nashorn to run React.js on the server-side can be executed using the GraalVM JavaScript implementation. In the end, you will have a port that has migrated from Nashorn, passes all the tests and exceeds in performance.

30-DEC-2019

GraalVM in 2019: Year in Review

Read about some of the highlights that occurred to GraalVM in 2019. The first production release, the level of community engagement, industry use cases, new features are summarized in this blog.

13-DEC-2019

Mixed Interactive Debugging of Dynamic Languages and Native Code

This artcile describes a unique ability of GraalVM to debug mixed applications written in R, Ruby, or Python together with C/C++ code in a single development environment. The mixed debugging of dynamic languages and native code is made possible by GraalVM’s capacity to load and execute the LLVM bitcode attached to shared libraries when being built using the GraalVM LLVM Toolchain.

05-DEC-2019

Compiling Native Projects via the GraalVM LLVM Toolchain

Learn about a pre-built GraalVM support of the LLVM toolchain that makes it easy to compile a native project to LLVM bitcode. The LLVM toolchain provides a set of build tools, such as a C compiler and a linker, that enables compiling a native program to an executable with embedded LLVM bitcode.

02-DEC-2019

Announcing GraalWasm — a WebAssembly engine in GraalVM

This is an announcement post about a WebAssembly engine implemented in GraalVM. Supporting WebAssembly expands the set of languages GraalVM can execute with a whole other set of languages to the ones supported by GraalVM and is further step towards making it a universal platform for programming language execution.

20-NOV-2019

Announcing GraalVM 19.3 with JDK 11 Support

GraalVM 19.3 is the first of the planned longer-term support (LTS) releases built from the main line of the project. This release includes the much anticipated support for JDK 11 along with a number of other exciting improvements.

11-OCT-2019

HPI Polyglot Programming Seminar

The blog post explores the domain of polyglot programming using GraalVM. Read about a GraalVM-based Jupyter kernel, a tool for polyglot programming to find code on the web, UI framework experiments, and MLE benchmarks.

09-OCT-2019

JDK Flight Recorder Support in VisualVM

A preview version of the JDK Flight Recorder support was released as a plugin for the VisualVM tool bundled with GraalVM. Observe how plugin reads JFR snapshots and presents the data in typical VisualVM views familiar to the users.

12-SEP-2019

Updates on Class Initialization in GraalVM Native Image Generation

Get acquainted with new options introduced in GraalVM 19.2 to debug and understand class initialization problems. For example, the option -H:+TraceClassInitialization collects the stack trace that triggered class initialization during image generation and prints the stack traces in error messages.

09-SEP-2019

GraalVM Powers Oracle Cloud Infrastructure

The Oracle Cloud Infrastructure Monitoring service recently completed the move and now runs on GraalVM in production. Read this article to learn more about the performance gains and transition process.

29-AUG-2019

Improving performance of GraalVM native images with profile-guided optimizations

Read about plentiful benefits and possible trade-offs of GraalVM Native Image. Learn how easily generate profile-guided optimizations (PGO) profiles to significantly improve throughput of generated native images for known workloads.

20-AUG-2019

GraalVM 19.2: New Tools

The 19.2 GraalVM announcement post. This release brought improved profile-guided optimizations, included LLVM toolchain support, enhanced VisualVM with Java Flight Recorder support, added a preview of a new Visual Studio Code plugin, came with better native image peak performance, and much more.

15-JUL-2019

libgraal: GraalVM compiler as a precompiled GraalVM native image

Learn why libgraal became a default operational mode of the GraalVM compiler when used as a HotSpot JIT compiler. Discover the difference between running the GraalVM compiler in a Native Image vs on the JVM.

2-JUL-2019

GraalVM 19.1: Compiling Faster

This is an announcement post of GraalVM 19.1. It dives into main improvements in this release and then discloses the future versioning scheme.

11-JUN-2019

Getting started with GraalVM for Scala

The post shows how you can start using GraalVM for your Scala projects. GraalVM shows great performance results for Scala and speeds up the compilation. Give it a try, see what performance impact GraalVM shows on your code.

5-JUN-2019

Introducing the Tracing Agent: Simplifying GraalVM Native Image Configuration

The tracing agent records behavior of a Java application running, for example, on GraalVM or any other compatible JVM, to provide the GraalVM Native Image Generator with configuration files for reflection, JNI, resource, and proxy usage.

3-MAY-2019

Lightweight cloud-native Java applications

This short blog post visualizes the benefits GraalVM Native Image offers for Java microservice frameworks like Helidon, Quarkus, and Micronaut.

26-MAR-2019

Using Java libraries from a Node.js application. Testcontainers example

This post discovers how GraalVM polyglot capabilities allow you to use Java libraries, on the example of Testcontainers, from a Node application. Not only can GraalVM run both Java and Node apps, it also supports other languages like Ruby, Python and R and allows you to mix the libraries from all their ecosystems in a very efficient way.

19-MAR-2018

Simplifying native-image generation with Maven plugin and embeddable configuration

The blog post shows two features recently added to GraalVM to simplify the generation of native images. One is a Maven plugin so you can include the native image generation in your build without calling the command line utilities manually. Then we look at native-image.properties as a way to include the configuration for your library in the jar file to avoid manual configuration.

22-FEB-2019

GraalVM’s JavaScript engine on JDK11 with high performance

Learn how one can consume GraalVM’s JavaScript engine artifacts from Maven Central and run it on a stock JDK. Without access to the GraalVM compiler performance of the JavaScript code in this setup might not be optimal — luckily you can enable the GraalVM compiler with a bunch of command line options to make JavaScript perform significantly faster than Nashorn.

11-FEB-2019

Multi-threaded Java ←→JavaScript language interoperability in GraalVM

GraalVM’s JavaScript language runtime is designed to be embeddable and highly-flexible, allowing for it to be embedded in a wide variety of scenarios, from databases to Node.js and Java applications. Multi-threading support comes in the form of a simple share-nothing semantics for JavaScript, that can be extended with Java concurrency.

25-JAN-2019

Isolates and Compressed References: More Flexible and Efficient Memory Management via GraalVM

GraalVM native images now support isolates (multiple independent VM instances in the same process) and compressed references (use 32-bit references to Java objects on 64-bit architectures). This reduces memory footprint and makes it possible to strictly separate memory for, e.g. web requests from different users.

13-DEC-2018

Bringing Modern Programming Languages to the Oracle Database with GraalVM

The Multilingual Engine (MLE) allows you with the help of GraalVM to use JavaScript and Python in the Oracle Database, bringing their enormous ecosystems to your data-intensive computations. With GraalVM, not only can we rapidly bring new languages to the Oracle Database, but we also have a high-performance speculative JIT compiler at our fingertips. It can be used to generate efficient code for critical parts of queries such as data conversions at runtime.

11-OCT-2018

Safe and sandboxed execution of native code

Enterprise Edition of GraalVM introduced a managed execution mode for LLVM intermediate representation code, which can be enabled with --llvm.managed command line option. In this mode, all access to native libraries and native memory is forbidden. All memory operations occur on managed objects on the managed heap of the VM, where the standard Java memory protection guarantees apply.

6-NOV-2018

Faster R with FastR

FastR is a GraalVM based implementation of the R language that provides significant improvements in the performance of R code, the embedding of the R execution engine into Java applications, and the ability to interface with other GraalVM and JVM languages including Python, Java, and Scala. FastR is also able to utilize the tooling support provided by the GraalVM ecosystem.

2-OCT-2018

Under the hood of GraalVM JIT optimizations

In this article we look at some of the high-level optimizations performed by the GraalVM compiler: inlining, polymorphic inlining, and partial escape analysis, but there are many more — loop unrolling, loop peeling, path duplication, to name just a few. The most relevant optimizations are supported by short examples.

6-SEP-2018

Understanding Class Initialization in GraalVM Native Image Generation

Classes reachable for a GraalVM native image are initialized at image build time. Objects allocated by class initializers are in the image heap that is part of the executable. The new option --delay-class-initialization-to-runtime= delays initialization of listed classes to image run time.

16-AUG-2018

Analyzing the Heap of GraalVM Polyglot Applications

In this article we describe how to create and analyze heap content of a polyglot application with Graal VisualVM. Using simple HelloWorld snippets written in Java, JavaScript, Python, R and Ruby we show how to save a heap dump from HotSpot JVM, and to open and analyze it in Graal VisualVM heap viewer.

7-AUG-2018

Stream API performance with GraalVM

This article will show, using concrete examples, that GraalVM achieves a performance improvement of between 2x and 5x on Stream programs compared to Java HotSpot VM. We will go over several Stream-based programs, and measure their performance using the GraalVM and the standard Java HotSpot VM, and conclude the article with an example of larger Stream-based program.

30-JUL-2018

Bringing Fibers to TruffleRuby

TruffleRuby now supports C extensions with a novel approach to executing native code and automatically synchronising shared objects. But there are a couple of things that still need to be done here — callcc, continuations and fibers.

19-JUL-2018

Oracle GraalVM announces support for Nashorn migration

Recently, the Java team published a proposal (JEP-335) to deprecate the Nashorn JavaScript engine with the intention of removing it from future releases of the JDK. GraalVM’s support for JavaScript and Node.js is a great path forward for applications that have been using Rhino or Nashorn in older versions of the JDK with more features, compatibility and performance. It is a totally different implementation than Nashorn.

20-JUN-2018

Compiling Scala Faster with GraalVM

The Scala compiler is notorious for its long compilation times. One of the main reasons for long compilation is that the Java HotSpot VM is not tuned for Scala programs and the Scala compiler is entirely written in Scala. GraalVM performs significantly better than the standard Java HotSpot VM for Scala programs. In this blog post, we show how GraalVM can speed up compilation of Scala programs and thus improve productivity.

22-MAY-2018

Instant Netty Startup using GraalVM Native Image Generation

In this article we demonstrate how you can achieve instant startup for Netty, a non-blocking I/O Java networking framework. We do this by compiling the Netty application into a native executable with GraalVM.

10-MAY-2018

Enhance your Java Spring application with R data science

In this post we look at GraalVM running a sample Spring application written in Java, that is using ggplot2, an R library, to plot the data. GraalVM is a polyglot virtual machine capable of running various languages efficiently such as Java, Scala, JavaScript, Ruby, R and native languages compiled to LLVM bitcode.

3-MAY-2018

Debugging polyglot Node.js, Ruby, R apps with GraalVM

In this post, we explore how to debug a polyglot Node.js, Ruby, and R application using GraalVM and the Chrome Dev tools debugger. We use a small web application that plots math functions you provide as input.