Open Source Alternatives
  • Alternatives
  • Categories
    Categories by size1,302 projects
    • Developer Tools673
    • AI & Machine Learning549
    • Business & Productivity311
    • Web Development219
    • Security & Monitoring198
    • Communication & Collaboration168
    • IT Management165
    • Design & Creative145
    • LLMOps & AI Tooling142
    • DevOps & CI/CD141
    Browse all 21 categoriesCloud & Hosting, Product & Project Management and 9 more
  • Blog
  • Advertise
SearchNotion, Slack, password manager.../
Submit
Open Source Alternatives
  • Alternatives
    • Developer Tools673
    • AI & Machine Learning549
    • Business & Productivity311
    • Web Development219
    • Security & Monitoring198
    • Communication & Collaboration168
    • Browse all 21 categories
  • Blog
  • Advertise
Submit your project

New open source projects by email

The projects we add and every new guide. Free, unsubscribe any time.

Open Source Alternatives LogoOpen Source Alternatives

Handpicked Open Source Alternatives to Paid Softwares

Add Open Source Alternatives as a preferred source on Google

Product

  • Categories
  • Tag
  • Advertise

Resources

  • Blog
  • Collection
  • Submit

Company

  • Privacy Policy
  • Terms of Service
  • Refund Policy
  • Sitemap

Alternatives

  • Claude Code
  • Jira
  • Notion
  • Slack
  • Linear
  • Wispr Flow
  • All alternatives
© 2026 Open Source Alternatives. All rights reserved.
Open SourceAlternatives
Home/Categories/Developer Tools/TornadoVM
icon of TornadoVM

TornadoVM

  • 1.6K stars
  • Apache-2.0
  • Active this week
  • Last commit today

Last verified Nov 18, 2026

Run GPU-accelerated Java code on NVIDIA, AMD, Apple Silicon, and Intel GPUs via JIT-compiled CUDA, OpenCL, and Metal, with no C++ toolchain.

Visit websiteGitHub1.6K stars
Image for TornadoVM
TL;DR

TornadoVM is an Apache 2.0 GPU programming framework for Java (JDK 21-27) that JIT-compiles Java bytecode to CUDA, OpenCL, and Apple Metal at runtime. Write kernels using @Parallel (auto-inferred launch configuration), KernelContext (CUDA-style explicit thread indexing), or TileContext (tile programming with Tensor Core support, CUDA backend only). The Hybrid API calls cuBLAS, cuFFT, cuDNN, and cuDF directly from the TaskGraph, sharing device buffers with JIT-compiled kernels on one CUDA stream. Latest release: 8.1.0. Install via SDKMAN! in one command or add from Maven Central; Docker and AWS deployment guides are available from the GitHub repository.

Read the full breakdownHide the full breakdownWho it is for, how it works, trade-offs, the quick start and the FAQ
who it's for

Who TornadoVM is for#

LLM inference inside a Java application

Teams using LangChain4j or Quarkus that want GPU-accelerated LLM inference without a separate Python service can use jitLLM to run Llama 3, Mistral, Qwen 3, and other GGUF-format models directly inside the JVM, using the CUDA backend for NVIDIA GPUs at up to 117 tokens per second on an RTX 5090.

Skip if:

You are already running a dedicated Python inference server and are not constrained to stay inside the JVM.

Accelerating Spark UDFs and Iceberg pipelines

Data engineers using Apache Spark or Apache Iceberg who need GPU acceleration for custom UDFs or compaction operations can use TornadoVM's cuDF library tasks to bring RAPIDS relational primitives, including multi-key ordering, grouped aggregations, and stream compaction, into the TaskGraph without leaving Java.

Skip if:

Your Spark cluster already uses RAPIDS Accelerator for Spark at the framework level and you have no custom Java UDFs that require GPU acceleration.

GPU-accelerated kernels for ML and signal processing

Research teams writing Java-based physics simulations, signal processing pipelines, or ML training routines can annotate existing loop-heavy code with @Parallel and run it on NVIDIA, AMD, Intel, or Apple Silicon GPUs without rewriting in CUDA C++. The Kernel API delivers 52x speedup over sequential Java on SGEMV, measured on an RTX 4090.

Skip if:

Your compute workload is small enough to run on CPU in acceptable time, or the team can migrate the compute-critical path to Python without breaking the stack.

Apple Silicon GPU compute from Java

macOS developers or researchers using Apple M1-M4 machines can target the GPU through TornadoVM's Metal backend (new in 8.1.0), using the same @Parallel or KernelContext Java code that also runs on NVIDIA and AMD hardware. No Objective-C or Metal Shading Language is required.

Skip if:

Your GPU compute target is exclusively NVIDIA or AMD hardware running on Linux.

the problem

The problem it solves#

Java developers working on compute-intensive problems, whether training models, processing signals, running LLM inference, or doing matrix-heavy data work, have traditionally hit a wall: Java's JVM runs on the CPU and has no native GPU API. The two workarounds both carry real costs. Writing a CUDA or OpenCL kernel in C++ requires learning a second language and build toolchain, then maintaining JNI bindings that break across JDK upgrades. Offloading to a dedicated GPU service adds network latency, data-transfer overhead, and per-call pricing that makes tight inference loops impractical. The underlying challenge is that GPU parallelism is a different programming model: thread indexing, memory hierarchies, and dispatch configurations are foreign to Java's object model, and bridging the gap has historically meant leaving Java. TornadoVM addresses this by moving the compilation into the JVM: at runtime it lowers Java bytecode through its own compiler to CUDA C, OpenCL, or Metal Shading Language, so the developer writes ordinary Java methods and the framework handles the hardware targeting.

how TornadoVM solves it

How it solves it#

@Parallel, KernelContext, and TileContext APIs

Three levels of control, all building the same TaskGraph. @Parallel annotates parallel loops and lets TornadoVM infer the launch configuration. KernelContext exposes CUDA-style thread indexing (global/local thread IDs, local memory, barriers) across all backends. TileContext, new in 8.1.0 and CUDA-only, writes computation over tiles and lets the tile compiler pick tensor-core instructions; it has no thread index, no warp, and no fragment in the API.

Hybrid API: cuBLAS, cuFFT, cuDNN, and cuDF

Library tasks slot NVIDIA library calls into the TaskGraph alongside JIT-compiled Java kernels. Shared TornadoVM-managed device buffers on one CUDA stream mean a Java kernel can feed cuBLAS SGEMV and consume the output with no extra copies or host synchronization. On an RTX 4090, mixing a custom Java kernel with cuBLAS FP16 reaches 160 TFLOP/s on 4096x4096 SGEMM, 27.4x over the best hand-written Java kernel.

Single codebase, four GPU backends

The same Java method runs on NVIDIA GPUs via CUDA, AMD and Intel GPUs via OpenCL, and Apple Silicon via Metal Shading Language. TornadoVM selects the backend at runtime; switching is a JVM flag, not a code change. CUDA generates PTX compiled through NVRTC to a native cubin; Metal generates MSL; OpenCL targets NVIDIA, AMD, Intel, and FPGA devices.

CUDA Graphs for single-call replay

Calling withCUDAGraph() on a TornadoExecutionPlan records all kernels, library calls, and data transfers into a captured CUDA Graph and replays them with a single cuGraphLaunch. TaskGraphs that mix @Parallel kernels, KernelContext kernels, TileContext kernels, and native cuBLAS calls can all be captured into one graph, reducing per-iteration overhead.

Maven Central packaging, no native compiler required

TornadoVM binds its GPU drivers through java.lang.foreign; the Maven Central jars are a complete runtime on the plain classpath. tornado-drivers-opencl, tornado-drivers-metal, and tornado-drivers-cuda are on Maven Central from 8.1.0 onward. SDKMAN! delivers a backend-specific or full distribution in one command. GraalVM native image and Project Leyden AOT cache support cut CUDA backend startup from 0.6s to 0.3s.

strengths · trade-offs

Strengths and trade-offs#

Strengths

  • Zero JNI maintenance overheadAll GPU library bindings use java.lang.foreign; there are no JNI modules to maintain and no native compiler in the application's dependency chain, except for library modules that require compiled native code. The runtime discovers library bindings via Java's ServiceLoader, so adding a new library module requires no changes to the core runtime.
  • Active development shipping for each JDK lineThe repository's last push was 2026-11-17 and the team ships named builds for every JDK from 21 to 27. TornadoVM is a member of the NVIDIA Inception Program, has presented at NVIDIA GTC, and is the official GPU inference engine for LangChain4j and Quarkus LLM inference. The project has 1,564 GitHub stars and 152 forks.
  • jitLLM: LLM inference inside the JVMBuilt on TornadoVM's CUDA backend, jitLLM runs Llama 3, Mistral, Qwen 3, Phi-3, Granite, and DeepSeek models from GGUF files inside the JVM. It is the official GPU inference engine for LangChain4j and Quarkus, achieving 117 tokens per second on an RTX 5090, with FP16 and Q8 support and fused dequantize-compute kernels.
  • Identical code runs on CPU for debuggingEvery GPU kernel written with @Parallel, KernelContext, or TileContext has a plain JVM execution path. The same method runs and debugs on the CPU in a standard IDE, then runs on the GPU with no code changes. This makes TornadoVM-accelerated code testable with normal Java tooling before deploying to GPU infrastructure.

Trade-offs

  • -Requires JDK 21 or laterTornadoVM supports JDK 21 through 27 only. Projects still on JDK 11 or 17 must upgrade before using it. Per-JDK Maven Central artifacts (e.g., tornado-api:8.1.0-jdk21, tornado-api:8.1.0-jdk22plus) mean the dependency coordinates change when the team upgrades the JDK.
  • -GPU driver setup required for each backendEach backend requires its own GPU driver and toolkit: the CUDA Toolkit for NVIDIA, ROCm for HIP, an OpenCL runtime for AMD/Intel, or macOS for Metal. NVIDIA library tasks (cuBLAS, cuFFT, cuDNN) need the corresponding CUDA Toolkit libraries installed separately. This is straightforward for teams already managing GPU servers but adds first-time cost for teams new to GPU computing.
  • -35 open GitHub issuesThe GitHub issue tracker shows 35 open issues (from the GitHub API, pull requests excluded). Most are feature requests and backend-specific edge cases. Teams running less common GPU configurations should check the tracker before adopting.
versus alternatives

TornadoVM vs alternatives#

TornadoVM vs CUDA C++

GPU computing in Java has traditionally meant one of two paths: accept CPU-only performance, or switch to CUDA C++ and maintain JNI bindings between the two codebases. The NVIDIA CUDA toolkit is free to download, but the real cost is the second language, the separate build toolchain, and the maintenance burden when JDK versions change and JNI signatures break.

TornadoVM keeps the entire codebase in Java. The same @Parallel or KernelContext method that runs on the CPU in development compiles to CUDA PTX at runtime and executes on the GPU in production. Teams that have written CUDA-style kernels before can adopt the KernelContext API directly; teams new to GPU programming can start with @Parallel and let TornadoVM infer the launch configuration.

On NVIDIA hardware, TornadoVM also calls into cuBLAS, cuFFT, and cuDNN directly from the TaskGraph, so there is no longer a performance reason to drop to CUDA C++ for library-heavy workloads. The SGEMM benchmark on an RTX 4090 shows 160 TFLOP/s with cuBLAS FP16 through the Hybrid API, against 5.8 TFLOP/s for TornadoVM's own JIT kernel.

TornadoVM vs TensorRT

TensorRT is NVIDIA's proprietary ML inference optimizer. It delivers high throughput on NVIDIA GPUs by applying layer fusion, precision calibration, and engine serialization, but it requires C++ or Python bindings, an NVIDIA GPU, and a model export step (ONNX or TensorRT engine). It has no Java API and no support for AMD, Intel, or Apple Silicon.

TornadoVM's jitLLM runs Llama 3, Mistral, Qwen 3, Phi-3, and DeepSeek GGUF models inside the JVM via the CUDA backend, reaching 117 tokens per second on an RTX 5090. For teams that need GPU-accelerated inference inside a Java application, with no Python layer and no ONNX export step, jitLLM is an open source path that runs on NVIDIA hardware today.

TensorRT remains stronger for maximum throughput on NVIDIA GPUs for models that benefit from TensorRT-specific graph optimization. TornadoVM is the better fit when the application is Java-first, the GPU mix includes non-NVIDIA hardware, or the team wants to write and debug the same kernel on CPU before running it on GPU.

install · quick start

Quick start#

bash
Download TornadoVM 8.1.0 binary distributions (OpenCL, CUDA, Metal, or full build) for Linux, macOS, and Windows from GitHub Releases, or install in one command via SDKMAN! (sdk install tornadovm): https://github.com/beehive-lab/TornadoVM/releases/latest
tech stack · detected from GitHub

What it's built on#

Languages
C++JavaPython
frequently asked

FAQ#

Does TornadoVM require learning CUDA or OpenCL?

No. The @Parallel annotation handles the most common case: you annotate parallel Java loops and TornadoVM infers the full GPU launch configuration. For tighter control, KernelContext uses Java with CUDA-style thread indexing (global/local thread IDs, local memory, barriers), but you write Java, not CUDA C. TornadoVM generates the CUDA PTX (compiled through NVRTC), OpenCL, or Metal code at runtime from your Java bytecode.

What GPU hardware does TornadoVM 8.1.0 support?

NVIDIA GPUs via CUDA (PTX generation, Tensor Cores, cuBLAS/cuFFT/cuDNN/cuDF library tasks and CUDA Graphs), AMD GPUs via OpenCL and ROCm/HIP, Intel GPUs via OpenCL, Apple Silicon (M1-M4) via Metal (new in 8.1.0), and multi-core CPUs via OpenCL. The CUDA backend also supports the new CUDA Tile path. Backends are selected at runtime; a single binary switches hardware with a JVM flag.

Can TornadoVM run in Docker or on cloud GPU instances?

Yes. The documentation includes Docker and AWS deployment guides, both linked from the GitHub README. The community maintains docker-tornado images. For cloud deployments, the SDKMAN! install or Maven Central jars work on any Linux GPU instance with the appropriate driver installed (CUDA Toolkit for NVIDIA, ROCm for AMD). No application code changes are needed to run on a different target.

What does the Apache 2.0 license allow?

Apache 2.0 is an OSI-approved open source license. It permits using, modifying, and distributing TornadoVM in commercial products and hosted services with no royalty. The main requirement is preserving copyright notices in distributed copies. You can run TornadoVM in a commercial SaaS application, a managed GPU service, or an internal product without restriction.

What is Beestream.ai and how does it relate to TornadoVM?

Beestream.ai is the commercial company founded by the TornadoVM team. It builds enterprise GPU accelerators and in-process AI products on top of TornadoVM and offers commercial support contracts. TornadoVM itself remains open source under Apache 2.0. Beestream.ai builds GPU-accelerated data products (Iceberg compaction, Spark UDFs, JVector indexing) and AI products (jitLLM, jitNN, jitCast) on top of the open source core.

also worth a look

Similar open-source tools#

Dbos Transact Java

Alternative toTemporal Cloud

Postgres-native durable workflows for Java, no orchestrator required.

  • 248 GitHub stars
  • MITLicence MIT

Vllm

Alternative toTogether AI

High-throughput LLM inference server with OpenAI-compatible API

  • 97,105 GitHub stars
  • Apache-2.0Licence Apache-2.0

Firebase Ios Sdk

Alternative toAWS Amplify

Open source Apple SDK for Firebase auth, data, push and crashes

  • 6,993 GitHub stars
  • Apache-2.0Licence Apache-2.0

PiG

Alternative toClaude Code

Pi's coding agent, in Go. One binary, no Node.js required.

  • 872 GitHub stars
  • MITLicence MIT

dify

Alternative toRelevance AI

Visual AI workflow builder with RAG, agents, and self-hosting

  • 161,347 GitHub stars
  • CustomLicence Apache-2.0 with additional terms

FckSignups

InCustomer Support

Open-source tools that work instantly, no signup required

  • 4,588 GitHub stars
  • GPL-3.0Licence GPL-3.0
by category

Open source tools in these categories#

673

Developer Tools

REA (Reverse Engineer Anything), Skills for Real Engineers, superpowers
549

AI & Machine Learning

freeCodeCamp, REA (Reverse Engineer Anything), OpenClaw
93

Backend Development

dify, graphify, Rust

Sponsors

Inbox Zero

Alternative toSuperhuman

AI email assistant that drafts replies and clears your inbox

  • 13,058 GitHub stars
  • AGPL-3.0Licence AGPL-3.0
  • #Email

rakazo

Alternative toGrok Bot

AI teammates you own: your keys, your model, your machine.

  • 8,913 GitHub stars
  • Apache-2.0Licence Apache-2.0
  • #AI Agents

SnitchFeed

Live monitoring on LinkedIn, X, Reddit & more. Agentic social listening for startups.

Marketing & Growth

Advertise your product

New open source projects by email

The projects we add and every new guide. Free, unsubscribe any time.

Find open source alternatives to paid software

/
  • Claude Code to OpenCode
  • Jira to Windshift
  • Notion to AppFlowy
  • Slack to Mattermost
  • Linear to GitLab
  • Wispr Flow to Handy
  • Arc to Zen Browser
  • CapCut to Concat
  • Grok Bot to rakazo
  • Superhuman to Inbox Zero
  • Discord to Stoat
  • Airtable to AITable
  • Datadog to SigNoz
  • Muse to OpenClaw
  • Railway to Coolify
  • GitHub Copilot to Cline
  • Confluence to Wiki.js
  • Microsoft Teams to Rocket.Chat
  • 1Password to KeePassXC
  • Firebase to Supabase
  • Pinecone to Qdrant
  • Zapier to n8n
  • Devin AI to OpenHands
  • Asana to Leantime
  • Claude Code to OpenCode
  • Jira to Windshift
  • Notion to AppFlowy
  • Slack to Mattermost
  • Linear to GitLab
  • Wispr Flow to Handy
  • Arc to Zen Browser
  • CapCut to Concat
  • Grok Bot to rakazo
  • Superhuman to Inbox Zero
  • Discord to Stoat
  • Airtable to AITable
  • Datadog to SigNoz
  • Muse to OpenClaw
  • Railway to Coolify
  • GitHub Copilot to Cline
  • Confluence to Wiki.js
  • Microsoft Teams to Rocket.Chat
  • 1Password to KeePassXC
  • Firebase to Supabase
  • Pinecone to Qdrant
  • Zapier to n8n
  • Devin AI to OpenHands
  • Asana to Leantime