GraalVM Blog

5-NOV-2020

The many ways of polyglot programming with GraalVM

Using the Neo4j Java Driver, which is now compatible with GraalVM Native Image, including SSL support, the article shows three ways of polyglot programming on GraalVM. This is a guest blog post by Michael Simons.

23-OCT-2020

Integrating Cobol with JavaScript

By using a compiler like GnuCOBOL that compiles COBOL code to C code, you can run COBOL programs on GraaLVM's LLVM runtime. The interoperability feature of GraalVM allows you to call COBOL code from other programming languages and vice versa. This is a guest blog post by Christoph Schobesberger.

18-AUG-2020

Announcing GraalVM 20.2.0

The most advanced and fastest polyglot runtime that shows absolutely superb results on Java and other JVM languages — and can run programs written in popular languages like JavaScript, Ruby, R, and Python — just got even better.

3-AUG-2020

Java Frameworks for the Cloud

This article explores some popular frameworks in the Java ecosystem, how to establish the bounds for rapid startups and make the case for using the GraalVM platform for serverless applications.

24-JUN-2020

Asynchronous Polyglot programming in GraalVM JavaScript

GraalVM’s polyglot capabilities enable asynchronous programming across multiple languages and paradigms. In this blog post the author focuses on the combination of Java and JavaScript in the context of asynchronous applications.

18-JUN-2020

Moving from Jython to GraalVM

Moving from Jython to GraalVM might require some attention to details. GraalVM offers a migration path from Jython using the compatibility mode enabled with the —-python.EmulateJython command line option, which should make adapting existing Jython applications for Python on GraalVM as easy as possible.

3-JUN-2020

Accelerating OCI applications with GraalVM Enterprise

High performance, fast startup, and lower CPU and memory consumption make GraalVM Enterprise the perfect platform for cloud deployed Java applications. Learn how to use GraalVM Enterprise in an Oracle Cloud VM compute instance, build and deploy the applications and make them available on the public internet.

28-MAY-2020

Static Compilation of Java Applications at Alibaba at Scale

The Alibaba JVM team is sharing their experience using the native image technology of GraalVM to statically compile a microservice application into an ELF executable file which results in native code startup times for Java applications.

19-MAY-2020

GraalVM 20.1

This is an announcement blog post of GraalVM 20.1.0 — a feature release, offering better performance, native image and tooling updates, improvements to all languages, and more.

12-MAY-2020

Optimizing Machine Learning Performance at Netsuite with GraalVM and NVIDIA GPUs

Netsuite used GraalVM and NVIDIA's grCUDA to build fast and highly accurate machine learning models with Java and Python. Look how they accomplished it.

12-MAY-2020

Improvements to the GraalVM Community Edition Release Schedule

We are announcing a change to the roadmap for GraalVM Community Edition (CE) critical patch update (CPU) releases.

11-MAR-2020

Nashorn removal: GraalVM to the rescue!

Nashorn, the JavaScript engine in the OpenJDK, has been deprecated in JDK 11 by JEP 335 and has recently been scheduled to be removed in a future JDK version by JEP 372. So, if you are running on Nashorn today, the clock is ticking faster now until the day when you will be unsupported. However, there is a solution — GraalVM’s modern JavaScript engine.

5-MAY-2020

Apache Spark — Lightning fast on GraalVM Enterprise

As Apache Spark excels at processing large amounts of data, performance is absolutely critical. There are many sophisticated performance tuning options and techniques available in Apache Spark, but one of the easiest ways to improve overall performance is to run it on GraalVM Enterprise.

3-MAR-2020

A look at GraalVM 20.0: better Windows support, better Native Images, better tooling

GraalVM 20.0 is the release from the master branch while the 19.3.x branch continues to be maintained with the next release planned in April. We recommend updating to take advantage of new functionality and improvements. In this article we’d like to look at the most notable new features.

3-MAR-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. We highly appreciate these relationships and we want to facilitate them further.

6-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.

5-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.

2-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.

9-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.

9-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.

10-MAY-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.

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.

GraalVM Team Blog