GraalVM Team Blog
GraalVM 20.3
Is Available
We’re happy to announce GraalVM 20.3.0! This is the final feature release of 2020 and the first Long-Term Support (LTS) release for GraalVM Enterprise. With every release we introduce new features to make the development process more efficient and fun!
17-NOV-2020
Read moreCLI applications with GraalVM Native Image
GraalVM native image technology is great for command line applications. See how to build a sample command line application with Micronaut and PicoCLI which is a terrific combination and a good fit for native images.
13-NOV-2020
Read more5-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.
Read more23-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.
Read more18-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.
Read more3-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.
Read more24-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.
Read more18-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.
Read more28-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.
Read more19-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.
Read more12-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.
Read more12-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.
Read more11-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.
Read more5-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.
Read more3-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.
Read more3-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.
Read more6-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.
Read more30-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.
Read more13-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.
Read more5-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.
Read more2-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.
Read more20-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.
Read more11-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.
Read more9-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.
Read more12-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.
Read more29-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.
Read more20-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.
Read more15-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.
Read more2-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.
Read more11-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.
Read more5-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.
Read more10-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.
Read more3-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.
Read more26-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.
Read more19-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.
Read more22-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.
Read more11-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.
Read more25-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.
Read more13-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.
Read more11-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.
Read more6-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.
Read more2-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.
Read more6-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.
Read more16-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.
Read more7-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.
Read more30-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.
Read more19-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.
Read more20-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.
Read more22-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.
Read more10-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.
Read more3-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.
Read more