Skip to content
<open-source>
Oeiuwq Faith Blog OpenSource Porfolio

beehive-lab/TornadoVM

TornadoVM: A practical and efficient heterogeneous programming framework for managed languages
Source code at GitHub https://www.tornadovm.org
beehive-lab/TornadoVM.json
{
  "createdAt": "2018-09-07T09:37:44Z",
  "defaultBranch": "master",
  "description": "TornadoVM: A practical and efficient heterogeneous programming framework for managed languages",
  "fullName": "beehive-lab/TornadoVM",
  "homepage": "https://www.tornadovm.org",
  "language": "Java",
  "name": "TornadoVM",
  "pushedAt": "2025-11-24T14:25:19Z",
  "stargazersCount": 1348,
  "topics": [
    "ai",
    "cuda",
    "gpu-acceleration",
    "gpu-computing",
    "gpus",
    "graalvm",
    "java",
    "levelzero",
    "multi-core",
    "opencl",
    "parallel-computing",
    "parallel-programming",
    "spirv"
  ],
  "updatedAt": "2025-11-25T22:37:14Z",
  "url": "https://github.com/beehive-lab/TornadoVM"
}

TornadoVM

Section titled “TornadoVM”

TornadoVM version [Contributor Covenant]!(CODE_OF_CONDUCT.md) License: Apache 2 License: GPL v2

TornadoVM is a plug-in to OpenJDK and GraalVM that allows programmers to automatically run Java programs on heterogeneous hardware. TornadoVM targets OpenCL, PTX and SPIR-V compatible devices which include multi-core CPUs, dedicated GPUs (Intel, NVIDIA, AMD), integrated GPUs (Intel HD Graphics and ARM Mali), and FPGAs (Intel and Xilinx).

TornadoVM has three backends that generate OpenCL C, NVIDIA CUDA PTX assembly, and SPIR-V binary. Developers can choose which backends to install and run.

Website: tornadovm.org

Documentation: https://tornadovm.readthedocs.io/en/latest/

For a quick introduction please read the following FAQ.

Latest Release: TornadoVM 1.1.1 - 07/07/2025 : See CHANGELOG.

1. Installation

Section titled “1. Installation”

In Linux and macOS, TornadoVM can be installed automatically with the installation script. For example:

Terminal window
$ ./bin/tornadovm-installer --help
usage: tornadovm-installer [-h] [--jdk JDK] [--backend BACKEND] [--version] [--listJDKs] [--polyglot] [--mvn_single_threaded] [--auto-deps]


TornadoVM Installer Tool. It will install all software dependencies except the GPU/FPGA drivers


options:
  -h, --help            show this help message and exit
  --jdk JDK             Specify a JDK to install by its keyword (e.g., 'jdk21', 'graal-jdk-21'). Run with --listJDKs to view all available JDK keywords.
  --backend BACKEND     Select the backend to install: { opencl, ptx, spirv }
  --version             Print version
  --listJDKs            List supported JDKs
  --polyglot            Enable Truffle Interoperability with GraalVM
  --mvn_single_threaded
                        Run Maven in single-threaded mode
  --auto-deps           Automatic download and use any missing dependencies

NOTE Select the desired backend:

  • opencl: Enables the OpenCL backend (requires OpenCL drivers)
  • ptx: Enables the PTX backend (requires NVIDIA CUDA drivers)
  • spirv: Enables the SPIRV backend (requires Intel Level Zero drivers)

Example of installation:

Terminal window
# Install the OpenCL backend with OpenJDK 21
$ ./bin/tornadovm-installer --jdk jdk21 --backend opencl


# It is also possible to combine different backends:
$ ./bin/tornadovm-installer --jdk jdk21 --backend opencl,spirv,ptx

Alternatively, TornadoVM can be installed either manually from source or by using Docker.

If you are planning to use Docker with TornadoVM on GPUs, you can also follow these guidelines.

You can also run TornadoVM on Amazon AWS CPUs, GPUs, and FPGAs following the instructions here.

2. Usage Instructions

Section titled “2. Usage Instructions”

TornadoVM is currently being used to accelerate machine learning and deep learning applications, computer vision, physics simulations, financial applications, computational photography, and signal processing.

Featured use-cases:

  • kfusion-tornadovm: Java application for accelerating a computer-vision application using the Tornado-APIs to run on discrete and integrated GPUs.
  • Java Ray-Tracer: Java application accelerated with TornadoVM for real-time ray-tracing.

Run your first TornadoVM program (replace <path-to-your-tornado-examples-jar> with the path to the JAR file generated by your build, e.g., tornado-examples/target/tornado-examples-<version>.jar):

Terminal window
java @tornado-argfile -cp tornado-examples/target/tornado-examples-1.1.2-dev-6070d0e.jar uk.ac.manchester.tornado.examples.compute.MatrixVectorRowMajor

We also have a set of examples that includes NBody, DFT, KMeans computation and matrix computations.

Additional Information

3. Programming Model

Section titled “3. Programming Model”

TornadoVM exposes to the programmer task-level, data-level and pipeline-level parallelism via a light Application Programming Interface (API). In addition, TornadoVM uses single-source property, in which the code to be accelerated and the host code live in the same Java program.

Compute-kernels in TornadoVM can be programmed using two different approaches (APIs):

a) Loop Parallel API

Section titled “a) Loop Parallel API”

Compute kernels are written in a sequential form (tasks programmed for a single thread execution). To express parallelism, TornadoVM exposes two annotations that can be used in loops and parameters: a) @Parallel for annotating parallel loops; and b) @Reduce for annotating parameters used in reductions.

The following code snippet shows a full example to accelerate Matrix-Multiplication using TornadoVM and the loop-parallel API:

public class Compute {
    private static void mxmLoop(Matrix2DFloat A, Matrix2DFloat B, Matrix2DFloat C, final int size) {
        for (@Parallel int i = 0; i < size; i++) {
            for (@Parallel int j = 0; j < size; j++) {
                float sum = 0.0f;
                for (int k = 0; k < size; k++) {
                    sum += A.get(i, k) * B.get(k, j);
                }
                C.set(i, j, sum);
            }
        }
    }


    public void run(Matrix2DFloat A, Matrix2DFloat B, Matrix2DFloat C, final int size) {


        // Create a task-graph with multiple tasks. Each task points to an exising Java method
        // that can be accelerated on a GPU/FPGA
        TaskGraph taskGraph = new TaskGraph("myCompute")
                .transferToDevice(DataTransferMode.FIRST_EXECUTION, A, B) // Transfer data from host to device only in the first execution
                .task("mxm", Compute::mxmLoop, A, B, C, size)             // Each task points to an existing Java method
                .transferToHost(DataTransferMode.EVERY_EXECUTION, C);     // Transfer data from device to host


        // Create an immutable task-graph
        ImmutableTaskGraph immutableTaskGraph = taskGraph.snaphot();


        // Create an execution plan from an immutable task-graph
        try (TornadoExecutionPlan executionPlan = new TornadoExecutionPlan(immutableTaskGraph)) {


            // Run the execution plan on the default device
            TorandoExecutionResult executionResult = executionPlan.execute();


        } catch (TornadoExecutionPlanException e) {
            // handle exception
            // ...
        }
    }
}

b) Kernel API

Section titled “b) Kernel API”

Another way to express compute-kernels in TornadoVM is via the Kernel API. To do so, TornadoVM exposes the KernelContext data structure, in which the application can directly access the thread-id, allocate memory in local memory (shared memory on NVIDIA devices), and insert barriers. This model is similar to programming compute-kernels in SYCL, oneAPI, OpenCL and CUDA. Therefore, this API is more suitable for GPU/FPGA expert programmers that want more control or want to port existing CUDA/OpenCL compute kernels into TornadoVM.

The following code-snippet shows the Matrix Multiplication example using the kernel-parallel API:

public class Compute {
    private static void mxmKernel(KernelContext context, Matrix2DFloat A, Matrix2DFloat B, Matrix2DFloat C, final int size) {
        int idx = context.globalIdx
        int jdx = context.globalIdy;
        float sum = 0;
        for (int k = 0; k < size; k++) {
            sum += A.get(idx, k) * B.get(k, jdx);
        }
        C.set(idx, jdx, sum);
    }


    public void run(Matrix2DFloat A, Matrix2DFloat B, Matrix2DFloat C, final int size) {
        // When using the kernel-parallel API, we need to create a Grid and a Worker
        WorkerGrid workerGrid = new WorkerGrid2D(size, size);    // Create a 2D Worker
        GridScheduler gridScheduler = new GridScheduler("myCompute.mxm", workerGrid);  // Attach the worker to the Grid
        KernelContext context = new KernelContext();             // Create a context
        workerGrid.setLocalWork(16, 16, 1);                      // Set the local-group size


        TaskGraph taskGraph = new TaskGraph("myCompute")
                .transferToDevice(DataTransferMode.FIRST_EXECUTION, A, B) // Transfer data from host to device only in the first execution
                .task("mxm", Compute::mxmKernel, context, A, B, C, size)   // Each task points to an existing Java method
                .transferToHost(DataTransferMode.EVERY_EXECUTION, C);     // Transfer data from device to host


        // Create an immutable task-graph
        ImmutableTaskGraph immutableTaskGraph = taskGraph.snapshot();


        // Create an execution plan from an immutable task-graph
        try (TornadoExecutionPlan executionPlan = new TornadoExecutionPlan(immutableTaskGraph)) {
            // Run the execution plan on the default device
            // Execute the execution plan
            TorandoExecutionResult executionResult = executionPlan
                        .withGridScheduler(gridScheduler)
                        .execute();
        } catch (TornadoExecutionPlanException e) {
            // handle exception
            // ...
        }
    }
}

Additionally, the two modes of expressing parallelism (kernel and loop parallelization) can be combined in the same task graph object.

4. How to Use TornadoVM in your Projects?

Section titled “4. How to Use TornadoVM in your Projects?”

To use TornadoVM, you need two components:

a) The TornadoVM jar file with the API. The API is licensed as GPLV2 with Classpath Exception. b) The core libraries of TornadoVM along with the dynamic library for the driver code (.so files for OpenCL, PTX and/or SPIRV/Level Zero).

You can import the TornadoVM API by setting this the following dependency in the Maven pom.xml file:

<repositories>
    <repository>
        <id>universityOfManchester-graal</id>
        <url>https://raw.githubusercontent.com/beehive-lab/tornado/maven-tornadovm</url>
    </repository>
</repositories>


<dependencies>
<dependency>
    <groupId>tornado</groupId>
    <artifactId>tornado-api</artifactId>
    <version>1.1.1</version>
</dependency>
<dependency>
    <groupId>tornado</groupId>
    <artifactId>tornado-matrices</artifactId>
    <version>1.1.1</version>
</dependency>
</dependencies>

To run TornadoVM, you need to either install the TornadoVM extension for GraalVM/OpenJDK, or run with our Docker images.

5. Additional Resources

Section titled “5. Additional Resources”

Here you can find videos, presentations, tech-articles and artefacts describing TornadoVM, and how to use it.

6. Academic Publications

Section titled “6. Academic Publications”

If you are using TornadoVM >= 0.2 (which includes the Dynamic Reconfiguration, the initial FPGA support and CPU/GPU reductions), please use the following citation:

@inproceedings{Fumero:DARHH:VEE:2019,
 author = {Fumero, Juan and Papadimitriou, Michail and Zakkak, Foivos S. and Xekalaki, Maria and Clarkson, James and Kotselidis, Christos},
 title = {{Dynamic Application Reconfiguration on Heterogeneous Hardware.}},
 booktitle = {Proceedings of the 15th ACM SIGPLAN/SIGOPS International Conference on Virtual Execution Environments},
 series = {VEE '19},
 year = {2019},
 doi = {10.1145/3313808.3313819},
 publisher = {Association for Computing Machinery}
}

If you are using Tornado 0.1 (Initial release), please use the following citation in your work.

@inproceedings{Clarkson:2018:EHH:3237009.3237016,
 author = {Clarkson, James and Fumero, Juan and Papadimitriou, Michail and Zakkak, Foivos S. and Xekalaki, Maria and Kotselidis, Christos and Luj\'{a}n, Mikel},
 title = {{Exploiting High-performance Heterogeneous Hardware for Java Programs Using Graal}},
 booktitle = {Proceedings of the 15th International Conference on Managed Languages \& Runtimes},
 series = {ManLang '18},
 year = {2018},
 isbn = {978-1-4503-6424-9},
 location = {Linz, Austria},
 pages = {4:1--4:13},
 articleno = {4},
 numpages = {13},
 url = {http://doi.acm.org/10.1145/3237009.3237016},
 doi = {10.1145/3237009.3237016},
 acmid = {3237016},
 publisher = {ACM},
 address = {New York, NY, USA},
 keywords = {Java, graal, heterogeneous hardware, openCL, virtual machine},
}

Selected publications can be found here.

7. Acknowledgments

Section titled “7. Acknowledgments”

This work is partially funded by Intel corporation. In addition, it has been supported by the following EU & UKRI grants (most recent first):

Furthermore, TornadoVM has been supported by the following EPSRC grants:

8. Contributions and Collaborations

Section titled “8. Contributions and Collaborations”

We welcome collaborations! Please see how to contribute to the project in the [CONTRIBUTING]!(CONTRIBUTING.md) page.

Write your questions and proposals:

Section titled “Write your questions and proposals:”

Additionally, you can open new proposals on the GitHub discussions page.

Alternatively, you can share a Google document with us.

Collaborations:

Section titled “Collaborations:”

For Academic & Industry collaborations, please contact here.

9. TornadoVM Team

Section titled “9. TornadoVM Team”

Visit our website to meet the team.

10. Licenses Per Module

Section titled “10. Licenses Per Module”

To use TornadoVM, you can link the TornadoVM API to your application which is under Apache 2.

Each Java TornadoVM module is licensed as follows:

ModuleLicense
Tornado-APILicense: Apache 2
Tornado-RuntimeLicense: GPL v2
Tornado-AssemblyLicense: Apache 2
Tornado-DriversLicense: GPL v2
Tornado-Drivers-OpenCL-HeadersLicense
Tornado-scriptsLicense: Apache 2
Tornado-AnnotationLicense: Apache 2
Tornado-UnittestsLicense: Apache 2
Tornado-BenchmarksLicense: Apache 2
Tornado-ExamplesLicense: Apache 2
Tornado-MatricesLicense: Apache 2