ROCm is a software stack developed by Advanced Micro Devices (AMD) for graphics processing unit (GPU) programming. It spans several domains, including general-purpose computing on graphics processing units (GPGPU), high-performance computing (HPC), and heterogeneous computing. ROCm offers multiple programming models, including HIP (GPU-kernel-based programming), OpenMP (directive-based programming), and OpenCL. The stack is free, libre, and open-source software, except for GPU firmware blobs, and is distributed under various licenses. The name initially stood for Radeon Open Compute platform, but due to Open Compute being a registered trademark, it no longer functions as an acronym.
ROCm is designed to provide a unified platform for developers to leverage AMD GPUs for compute-intensive tasks, from scientific simulations to Machine learning workloads. It includes a range of components, from low-level kernel drivers to high-level libraries and tools, enabling efficient execution across diverse hardware. The stack is actively developed by AMD and the open-source community, with support for both professional and consumer GPUs.
Background
The first GPGPU software stack from ATI/AMD was Close to Metal, which later became Stream. ROCm was launched around 2016 with the Boltzmann Initiative, building upon previous AMD GPU stacks. Some tools trace back to GPUOpen, while others originate from the Heterogeneous System Architecture (HSA). In July 2026, AMD announced that ROCm would adopt a six-week release cycle, aiming for more frequent updates and improvements.
Heterogeneous System Architecture Intermediate Language
HSAIL was designed to produce a middle-level, hardware-agnostic intermediate representation that could be JIT-compiled to the eventual hardware (GPU, FPGA, etc.) using the appropriate finalizer. This approach was dropped for ROCm, which now builds only GPU code using LLVM and its AMDGPU backend that was upstreamed. However, research continues on enhanced modularity with LLVM MLIR.
Programming Abilities
ROCm as a stack ranges from the kernel driver to end-user applications. AMD provides introductory videos about AMD GCN hardware and ROCm programming via its learning portal. One of the best technical introductions to the stack and ROCm/HIP programming remains, to date, to be found on Reddit.
Hardware Support
ROCm is primarily targeted at discrete professional GPUs, but consumer GPUs and APUs of the same architecture as a supported professional GPU are known to work with ROCm. For example, all professional GPUs of the RDNA 2 architecture are officially supported by ROCm 5.x; users report that consumer RDNA2 units such as the Radeon 6800M APU and the Radeon 6700XT GPU also work.
Professional-Grade GPUs
ROCm officially supports a range of professional GPUs, including those based on the CDNA and RDNA architectures. These are typically used in data centers and workstations for HPC and Artificial intelligence workloads. The support is continuously expanded with each release.
Consumer-Grade GPUs
While not officially guaranteed, many consumer GPUs from the same architecture families as supported professional models function with ROCm. The community has documented successful use of consumer Radeon GPUs for compute tasks, though performance and stability may vary.
Software Ecosystem
Machine Learning
Various Deep learning frameworks have a ROCm backend, enabling GPU acceleration on AMD hardware. Notable frameworks include PyTorch, TensorFlow, ONNX, MXNet, CuPy, MIOpen, Caffe, Iree (which uses LLVM MLIR), and llama.cpp. These integrations allow developers to run Neural network training and inference on AMD GPUs, supporting models like Large language models and Transformer (architecture) architectures.
Supercomputing
ROCm is gaining significant traction in the top 500 supercomputers. It is used with the exascale supercomputers El Capitan and Frontier. Related software is available at AMD Infinity Hub, which provides containerized applications for scientific research.
Other Acceleration and Graphics Interoperation
As of version 3.0, Blender can use HIP compute kernels for its Cycles renderer, enabling GPU-accelerated rendering on AMD hardware.
Other Languages
#### Julia
Julia has the AMDGPU.jl package, which integrates with LLVM and selects components of the ROCm stack. Instead of compiling code through HIP, AMDGPU.jl uses Julia's compiler to generate LLVM IR directly, which is later consumed by LLVM to generate native device code. AMDGPU.jl uses ROCr's HSA implementation to upload native code onto the device and execute it, similar to how HIP loads its own generated device code. AMDGPU.jl also supports integration with ROCm's rocBLAS (for BLAS), rocRAND (for random number generation), and rocFFT (for FFTs). Future integration with rocALUTION, rocSOLVER, MIOpen, and other ROCm libraries is planned.
Software Distribution
Official
Installation instructions are provided for Linux and Windows in the official AMD ROCm documentation. ROCm software is currently spread across several public GitHub repositories. Within the main public meta-repository, there is an XML manifest for each official release; using git-repo, a version control tool built on top of Git, is the recommended way to synchronize with the stack locally. AMD also distributes containerized applications for ROCm, notably scientific research applications gathered under AMD Infinity Hub, and packages tailored to various Linux distributions.
Third-Party
There is a growing third-party ecosystem packaging ROCm. Linux distributions are officially packaging ROCm natively, with various degrees of advancement, including Arch Linux, Gentoo, Debian, Fedora, GNU Guix, and NixOS. There are also Spack packages for HPC environments.
Components
There is one kernel-space component, ROCk, and the rest - roughly a hundred components in the stack - are user-space modules. The unofficial typographic policy is to use uppercase ROC, lowercase following for low-level libraries (e.g., ROCt), and the contrary for user-facing libraries (e.g., rocBLAS). AMD is actively developing with the LLVM community, but upstreaming is not instantaneous, and as of January 2022, it is still lagging. AMD still officially packages various LLVM forks for parts that are not yet upstreamed, including compiler optimizations destined to remain proprietary, debug support, OpenMP offloading, and more.
Low-Level
#### ROCk - Kernel Driver
The ROCk kernel driver is the core kernel-space component that manages GPU hardware and provides the interface for user-space libraries.
#### ROCm - Device Libraries
Support libraries implemented as LLVM bitcode. These provide various utilities and functions for math operations, atomics, queries for launch parameters, on-device kernel launch, and more.
#### ROCt - Thunk
The thunk is responsible for all the thinking and queuing that goes into the stack, handling low-level interactions with the kernel driver.
#### ROCr - Runtime
The ROC runtime is a set of APIs and libraries that allows the launch of compute kernels by host applications. It is AMD's implementation of the HSA runtime API. It is different from the ROC Common Language Runtime.
#### ROCm - CompilerSupport
The ROCm code object manager is in charge of interacting with LLVM intermediate representation, managing code objects and their loading.
Mid-Level
#### ROCclr Common Language Runtime
The common language runtime is an indirection layer adapting calls to ROCr on Linux and PAL on Windows. It used to be able to route between different compilers, like the HSAIL-compiler. It is now being absorbed by the upper indirection layers (HIP and OpenCL).
#### OpenCL
ROCm ships its installable client driver (ICD) loader and an OpenCL implementation bundled together. As of January 2022, ROCm 4.5.2 ships OpenCL 2.2, and is lagging behind competition.
#### HIP - Heterogeneous Interface for Portability
The AMD implementation for its GPUs is called HIPAMD. There is also a CPU implementation, mostly for demonstration purposes.
#### HIPCC
HIP builds a HIPCC compiler that either wraps Clang and compiles with LLVM open AMDGPU backend, or redirects to the NVIDIA compiler.
#### HIPIFY
HIPIFY is a source-to-source compiling tool. It translates CUDA to HIP and reverse, either using a Clang-based tool, or a sed-like Perl script.
#### GPUFORT
Like HIPIFY, GPUFORT is a tool compiling source code into other targets, facilitating porting of Fortran code to GPU execution.