TornadoVM on foojay.io - Friends of OpenJDK

TornadoInsight - Compatibility with TornadoVM SDK 2.0+ & Configuration Guide

Tue, 30 Dec 2025 09:00:00 +0000

This blog updates the previously published TornadoInsight configuration ++guidelines++ and explains how to configure the required environment variable to ensure that TornadoInsight correctly detects the TornadoVM SDK when IntelliJ IDEA is launched from a graphical environment.

Overview

TornadoInsight requires access to a compatible Java Development Kit (JDK) and the TornadoVM SDK.{#o7o5c20810}

Important update:{#mvwo920904}

Since version ++v1.4.0++ , TornadoInsight can also use the JDK configured directly in IntelliJ IDEA via Project Structure. This means that, in many cases, users no longer need to configure the Java SDK in the plugins settings.{#welj420814}

Getting Started with TornadoVM 2.0 for Accelerating Java Applications

Mon, 22 Dec 2025 10:00:00 +0000

Starting with TornadoVM 2.0 , installing and using TornadoVM is easier than ever. The project now provides prebuilt SDKs for multiple operating systems, architectures, and accelerator backends, and is also available via Maven Central for seamless integration with existing Java codebases.{#viewer-bsvyh182}

This guide walks you through:{#viewer-aq221189}

Installing the TornadoVM SDK
Verifying your setup
Integrating TornadoVM into Java projects using Maven

Prerequisites

Before installing TornadoVM, ensure that your system has the following:{#viewer-k00hu10420}

Foojay Podcast #82: OpenJDK Projects (Leyden, Babylon, Panama) and TornadoVM

Mon, 17 Nov 2025 07:35:00 +0000

In this Foojay Podcast, we’re diving deep into some of the most exciting developments happening within the OpenJDK and TornadoVM projects.

At the Devoxx and JFall conferences, we spoke with several speakers and visitors about some of the major themes shaping the future of Java development. The first guest is Moritz Halbritter from the Spring Engineering team. He provides us with more insights into Project Leyden and how it’s improving Java startup times through ahead-of-time compilation and profiling. We’ll learn how Spring Boot developers can already take advantage of these improvements today.

Build and Run TornadoVM with IntelliJ IDEA

Wed, 20 Nov 2024 19:08:13 +0000

TornadoVM is an open-source Java technology that is developed to aid Java programmers in adapting their code bases for hardware acceleration.

This blog aims to explain how Java programmers can build TornadoVM with IntelliJ IDEA, and how they can run TornadoVM unit-tests or other Java programs.

Prerequisites

This blog uses IntelliJ IDEA 2024.2.4 version and the list of required plugins are as follows:{#r55ph1440}

Python ++plugin++ to be installed in IntelliJ. This plugin allows python scripting from the IDE.

{#x95ro33520}

TornadoVM for RISC-V Accelerators

Thu, 19 Sep 2024 07:50:28 +0000

Takeaways

RISC-V is an open standard instruction set architecture that anyone can use to build new processors and accelerators, for example, for AI.
oneAPI Construction Kit (OCK) is a new framework that allows software developers and system designers to bridge the gap between hardware accelerators and open standards, by enabling a programming system to implement domain specific instructions for modern hardware such as RISC-V accelerators and custom processors.
TornadoVM, a parallel programming framework for Java, can take advantage of OCK to offload and accelerate Java workloads on RISC-V chips. This post shows how to run on RISC-V CPUs with vector extensions.

Introduction

RISC-V is an open standard instruction set architecture (ISA) based on the principles of reduced instruction sets (RISC). RISC-V is freely available under open licences, allowing anyone to design, modify and implement RISC-V processors.

Defining patterns of data transfers for Java applications with TornadoVM

Thu, 15 Aug 2024 15:43:56 +0000

The TornadoVM API is designed to aid Java programmers in adapting their code bases for hardware acceleration. As explained in a previous ++article++ , the TornadoVM API exposes two key Java objects for programmers, the ++TaskGraph++ and the ++TornadoExecutionPlan++ . The former is used to define which methods should be offloaded on an accelerator as well as how often the data will flow. The latter is used to configure how the execution will take place (e.g., with a warmup, with a specific grid, with a profiler, etc.) and contains a method that actually invokes the execution. More information about how to use those objects are provided ++here++ .{#viewer-foo}

The TornadoVM Programming Model Explained

Tue, 28 May 2024 11:01:14 +0000

Key Takeaways

TornadoVM offers an API for parallel programming on modern hardware that tackles data parallel, task parallel and pipeline parallel applications.
TornadoVM offers different abstractions to developers to be able to express parallel applications in Java, identify the methods to offload, and dispatch the application on the corresponding accelerators.
Task-Graphs and Execution Plans are the main building blocks of TornadoVM applications, allowing developers to compose complex graphs of computations and interact with the TornadoVM runtime to enable/disable profiling, enable debugging, or enable dynamic reconfiguration to select the best possible accelerators for the compute graphs.

In this blog post, I will explain how developers can start programming with TornadoVM and interact with the TornadoVM runtime.

Foojay Podcast #47: Artificial Intelligence and Machine Learning with Java

Mon, 15 Apr 2024 09:59:42 +0000

About one and a half years ago, ChatGPT was launched.

The way we search for information and develop software has changed a lot since then as the use of Artificial Intelligence suddenly became a lot easier.

What can we expect in the near future, and how can we program AI ourselves with Java? Let’s find out…

Video

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

TornadoVM: Code Interoperability Mode

Thu, 11 May 2023 07:54:04 +0000

TornadoVM is a programming framework for accelerating Java applications on heterogeneous devices, like multi-core CPUs, GPUs and FPGAs.

Java developers can use the TornadoVM API to prototype Java methods within their code bases for hardware acceleration.

TornadoVM is hardware-agnostic, but the generated code (i.e., kernels) for acceleration can be executed only through the TornadoVM runtime.

This blog outlines the key changes in TornadoVM to enable code interoperability of kernels with other programming languages beyond Java.

Foojay Podcast #17: Execute Java Code with TornadoVM

Mon, 27 Mar 2023 08:45:20 +0000

TornadoVM is a programming and execution framework for offloading and running JVM applications on multi-core CPUs, GPUs, and FPGAs.

With the same code, some of your existing program code can be executed hundreds of times faster!

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

Migrating Applications to TornadoVM v0.15 (Part 2)

Sat, 04 Mar 2023 18:38:41 +0000

In the previous blog , we discussed the TornadoVM programming model and showed how programmers can define the parts of their Java applications to be offloaded for hardware acceleration via the TornadoVM API (v0.15).

In this article, we will spotlight all the TornadoVM configurations/operations that regard the execution on the hardware device.

In particular, this blog has the following objectives:

Provide guidelines regarding how programmers can trigger TornadoVM-specific configurations that regard the execution on hardware accelerators.
Provide examples on how to exploit the new operations that are exposed by the new TornadoVM API.

Prerequisites {#h2-0-1-prerequisites}

This blog begins with a prerequisite that a snapshot of a user-defined TaskGraph is captured to an immutable state. This was the final point of the previous blog .

Migrating Applications to TornadoVM v0.15 (Part 1)

Thu, 16 Feb 2023 07:58:43 +0000

TornadoVM 0.15 introduced changes at the API level with the aim of making the exposed operations more comprehensive to the programmers.

It is imperative after all to get an understanding of how to use the TornadoVM API, as it includes very powerful operations, such as expressing parallelism, chaining Java methods (tasks) for deployment on heterogeneous hardware, configuration of the data transfers, etc.

This article has the following objectives:

Give an overview of the TornadoVM programming model.
Provide guidelines on how to define what to run on a device.
Provide guidelines on how existing TornadoVM programs can migrate to use the TornadoVM v0.15 API.

TornadoVM Programming Model {#h2-0-1-tornadovm-programming-model}

TornadoVM uses a programming model that derives from the state-of-the-art programming models of heterogeneous hardware accelerators, such as OpenCL, Level Zero, and CUDA. A key aspect for software applications that require to offload computations for hardware acceleration is that they are composed of two parts:

A Flavour of TornadoVM on Apple M1 Pro

Tue, 02 Aug 2022 08:21:12 +0000

This article aims to describe the main steps required to install and run TornadoVM on Apple M1 Pro.

Steps

Install Prerequisites
Run TornadoVM Installer
Execute Unit Tests
Performance Evaluation: Running Matrix-Multiplication on Apple M1 GPU

1. Install Prerequisites

To install TornadoVM, it is necessary to have some packages installed. For instance, you will have to install Maven and wget in order to enable the TornadoVM installer to be functional.

Assuming that Homebrew is installed in your system, you can open a terminal and execute the following commands:

Hardware Acceleration For Java? TornadoVM Can Do It!

Fri, 01 Apr 2022 07:37:03 +0000

Java programs can primarily run on x86 and Arm platforms and recent efforts focus on ports to PowerPC and RISC-V.

Despite the diverse range of ISAs, contemporary computers are equipped with heterogeneous devices, such as Graphics Processing Units (GPUs), Field Programmable Gate Arrays (FPGAs), and Tensor Processing Units (TPUs), which operate as co-processors that offload data processing from the main processor.

A question that rises is whether such compute power can be utilized by Java programs. The answer is that several frameworks have been created to address this challenge. For instance, IBM J9 , Aparapi , and TornadoVM , are frameworks that aid Java programmers to accelerate their programs on heterogeneous hardware devices.