TheRock/RELEASES.md

Releases

This page describes how to install and use our release artifacts for ROCm and external builds like PyTorch and JAX. We produce build artifacts as part of our Continuous Integration (CI) build/test workflows as well as release artifacts as part of Continuous Delivery (CD) nightly releases.

For the development status of GPU architecture support in TheRock, please see SUPPORTED_GPUS.md which tracks release readiness for each AMD GPU architecture.

Important

These instructions assume familiarity with how to use ROCm. Please see https://rocm.docs.amd.com/ for general information about the ROCm software platform.

Prerequisites:

• We recommend installing the latest AMDGPU driver on Linux and Adrenalin driver on Windows
• Linux users, please be aware of Configuring permissions for GPU access needed for ROCm

Table of contents:

• About multi-arch releases
• Installing multi-arch releases
  • Installing multi-arch Python packages
    • Installing multi-arch ROCm Python packages
      • Using multi-arch ROCm Python packages
      • Supported Python [device-*] install extras
    • Installing multi-arch PyTorch Python packages
    • Installing multi-arch JAX Python packages
  • Installing multi-arch native packages
    • Installing multi-arch native Linux packages
  • Installing multi-arch tarballs
• Verifying your installation

About multi-arch releases

Important

We introduced multi-arch releases with #3323. Rather than build ROCm for GPU family subsets like the legacy per-family releases, these multi-arch releases build all GPU architectures together and split GPU-specific code (kernel packs) from architecture-neutral host code as a packaging step.

This new setup streamlines package installation, so please note the differences in the install instructions.

Key differences from legacy per-family releases:

• One index URL for all GPUs: select your target with a pip extra like [device-gfx942] instead of finding a per-family index URL
• Broader GPU support: adding support for a new GPU target is just one more device package, so more GPUs can be supported without impacting build times or download sizes for other targets
• Smaller downloads: kernels downloaded can be scoped to a single GPU instead of always being scoped to a family or "all"

Multi-arch release status

Warning

Nightly packages are built from the latest ROCm code and may be unstable.

If you encounter issues, check

• https://therock-hud.amd.com/ for current test status
• https://github.com/ROCm/TheRock/issues for known issues

Job description	Status
Build ROCm artifacts/tarballs/packages
Test ROCm artifacts
Test ROCm native Linux packages
PyTorch packages - Linux build/test
PyTorch packages - Windows build/test
PyTorch packages - full tests
JAX packages - Linux build/test

Package availability:

Package type	Linux	Windows
ROCm Python packages	✅ Available	✅ Available
PyTorch Python packages	✅ Available	✅ Available
JAX Python packages	✅ Available	-
ROCm tarballs	✅ Available	✅ Available
Native packages	✅ Available	🟠 Planned (#1987)

Installing multi-arch releases

Installing multi-arch Python packages

Nightly releases of ROCm and framework Python packages are published to a unified index at https://rocm.nightlies.amd.com/whl-multi-arch/.

Tip

We highly recommend working within a Python virtual environment:

python -m venv .venv
source .venv/bin/activate

Multiple virtual environments can be present on a system at a time, allowing you to switch between them at will.

Warning

If you really want a system-wide install, you can pass --break-system-packages to pip outside a virtual environment. In this case, command-line interface shims for executables are installed to /usr/local/bin, which normally has precedence over /usr/bin and might therefore conflict with a previous installation of ROCm.

Installing multi-arch ROCm Python packages

We provide several Python packages which together form the complete ROCm SDK. In multi-arch releases, GPU-specific device code is split into separate rocm-sdk-device-{target} packages.

• See ROCm Python Packaging via TheRock for information about each package.
• The packages are defined in the build_tools/packaging/python/templates/ directory.

Install extra (if any)	Package name	Description
rocm	rocm	Primary sdist meta package that dynamically determines other deps
rocm	rocm-sdk-core	OS-specific core of the ROCm SDK (e.g. compiler and utility tools)
rocm[libraries]	rocm-sdk-libraries	OS-specific libraries (architecture-neutral host code)
rocm[device-gfx{target}]	rocm-sdk-device-{target}	GPU-specific device code (e.g. rocm-sdk-device-gfx942)
rocm[devel]	rocm-sdk-devel	OS-specific development tools

Install ROCm with device support for your GPU by looking up the appropriate [device-*] extras from the Supported Python [device-*] install extras table below and then running an install command such as:

# Single device (replace device-gfx942 with your GPU):
pip install --index-url https://rocm.nightlies.amd.com/whl-multi-arch/ \
    "rocm[libraries,device-gfx942]"

# Also install the 'devel' package:
pip install --index-url https://rocm.nightlies.amd.com/whl-multi-arch/ \
    "rocm[libraries,devel,device-gfx942]"

# Multiple devices (e.g. for a Dockerfile used by both MI300X and MI355X):
pip install --index-url https://rocm.nightlies.amd.com/whl-multi-arch/ \
    "rocm[libraries,device-gfx942,device-gfx950]"

# All supported devices:
pip install --index-url https://rocm.nightlies.amd.com/whl-multi-arch/ \
    "rocm[libraries,device-all]"

Warning

A device-* extra (or a single-family per-architecture index) being installable does not mean the runtime is functional on that target. Targets without ✅ in Sanity Tested in SUPPORTED_GPUS.md are unverified. pip install will succeed, but device enumeration, kernel launch, or library loads may fail at runtime. Please file an issue if you hit one.

Using multi-arch ROCm Python packages

After installing the ROCm Python packages, you should see them in your environment:

pip freeze | grep rocm
# rocm==7.15.0a20260630
# rocm-sdk-core==7.15.0a20260630
# rocm-sdk-device-gfx1100==7.15.0a20260630
# rocm-sdk-libraries==7.15.0a20260630

You should also see various tools on your PATH and in the bin directory:

which rocm-sdk
# .../.venv/bin/rocm-sdk

ls .venv/bin
# activate       amdclang++    hipcc      python                 rocm-sdk
# activate.csh   amdclang-cl   hipconfig  python3                rocm-smi
# activate.fish  amdclang-cpp  pip        python3.12             roc-obj
# Activate.ps1   amdflang      pip3       rocm_agent_enumerator  roc-obj-extract
# amdclang       amdlld        pip3.12    rocminfo               roc-obj-ls

The rocm-sdk tool can be used to inspect and test the installation:

$ rocm-sdk --help
usage: rocm-sdk {command} ...

ROCm SDK Python CLI

positional arguments:
  {path,test,version,targets,init}
    path                Print various paths to ROCm installation
    test                Run installation tests to verify integrity
    version             Print version information
    targets             Print information about the GPU targets that are supported
    init                Expand devel contents to initialize rocm[devel]

$ rocm-sdk test
...
Ran 22 tests in 8.284s
OK

$ rocm-sdk targets
gfx1100;gfx1101;gfx1102;gfx1103;gfx1151;gfx1200;gfx1201;...

If you also installed the rocm-sdk-devel development package using the rocm[devel] extra and want to use it outside of Python, you can eagerly expand its contents using rocm-sdk init:

$ rocm-sdk init
Devel contents expanded to '.venv/lib/python3.12/site-packages/_rocm_sdk_devel'

The paths in the devel package can be used like so:

$ rocm-sdk path --root
.venv/Lib/site-packages/_rocm_sdk_devel
$ rocm-sdk path --bin
.venv/Lib/site-packages/_rocm_sdk_devel/bin
$ rocm-sdk path --cmake
.venv/Lib/site-packages/_rocm_sdk_devel/lib/cmake

-DCMAKE_PREFIX_PATH=$(rocm-sdk path --cmake)
-DROCM_HOME=$(rocm-sdk path --root)
export PATH="$(rocm-sdk path --bin):$PATH"

For more details on using the rocm-sdk-devel package to build projects, see Using Packages from Frameworks in docs/packaging/python_packaging.md.

Tip

The devel tree is expanded - and its device files linked from the installed rocm-sdk-device-* wheels - only once: on the first rocm-sdk init / rocm-sdk test, or the first use of a devel tool such as hipcc. If you install or remove a rocm-sdk-device-* wheel (for example, adding a second GPU target) after that first expansion, re-run rocm-sdk init or rocm-sdk test to link the new device files. The compiler tools do not re-scan on their own, so a device wheel added later is not picked up until you run one of those again. Uninstalling a rocm-sdk-device-* wheel removes its devel files automatically via pip. If the devel tree ever ends up in a bad state, recreate the virtual environment.

Supported Python [device-*] install extras

For packages which include device-specific code (such as rocm, torch, and torchvision), select your GPU using a [device-*] install extra from the table below. See also the GPU architecture specs for a full list of supported AMD GPUs.

Product Name	GFX Target	Device Extra
All supported GPUs	(all)	device-all
AMD Instinct MI355X / MI350X	gfx950	device-gfx950
AMD Instinct MI325X / MI300X / MI300A	gfx942	device-gfx942
AMD Instinct MI250X / MI250 / MI210	gfx90a	device-gfx90a
AMD Instinct MI100	gfx908	device-gfx908
AMD Instinct MI60 / MI50, Radeon Pro VII, Radeon VII	gfx906	device-gfx906
AMD Instinct MI25	gfx900	device-gfx900
AMD Radeon RX 9070 / XT, AI PRO R9700 / R9600D	gfx1201	device-gfx1201
AMD Radeon RX 9060 / XT	gfx1200	device-gfx1200
AMD Radeon 820M iGPU	gfx1153	device-gfx1153
AMD Ryzen AI 7 350	gfx1152	device-gfx1152
AMD Ryzen AI Max+ PRO 395	gfx1151	device-gfx1151
AMD Ryzen AI 9 HX 375	gfx1150	device-gfx1150
AMD Ryzen 7 7840U / Ryzen 9 270	gfx1103	device-gfx1103
AMD Radeon RX 7600	gfx1102	device-gfx1102
AMD Radeon RX 7800 XT / 7700 XT, PRO V710 / W7700	gfx1101	device-gfx1101
AMD Radeon RX 7900 XTX / 7900 XT, PRO W7900 / W7800	gfx1100	device-gfx1100
AMD Radeon RX 6900 XT / 6800 XT, PRO W6800 / V620	gfx1030	device-gfx1030
AMD Radeon RX 6750 XT / 6700 XT	gfx1031	device-gfx1031
AMD Radeon RX 6600 XT / 6600, PRO W6600	gfx1032	device-gfx1032
AMD Van Gogh iGPU	gfx1033	device-gfx1033
AMD Radeon RX 6500 XT	gfx1034	device-gfx1034
AMD Radeon 680M iGPU	gfx1035	device-gfx1035
AMD Raphael iGPU	gfx1036	device-gfx1036
AMD Radeon RX 5700 / XT	gfx1010	device-gfx1010
AMD Radeon Pro V520	gfx1011	device-gfx1011
AMD Radeon Pro W5500	gfx1012	device-gfx1012

Installing multi-arch PyTorch Python packages

Install PyTorch with ROCm support using the unified multi-arch index. Select your GPU target using the [device-*] extras from the table above:

Note

By default, pip will install the latest stable versions of each package.

• If you want to allow installing prerelease versions, use the --pre

• If you want to install other versions, take note of the compatibility matrix:

  torch version	torchaudio version	torchvision version	apex version
  2.14	2.11	0.29	1.14
  2.13	2.11	0.28	1.13
  2.12	2.11	0.27	1.12
  2.11	2.11	0.26	1.11

  For example, torch 2.11 and compatible wheels can be installed by specifying

  torch==2.11 torchaudio==2.11 torchvision==0.26 apex==1.11.0
  

  See also

  • Supported PyTorch versions in TheRock
  • Installing previous versions of PyTorch
  • torchvision installation - compatibility matrix
  • torchaudio installation - compatibility matrix
  • apex installation - compatibility matrix

Warning

The torch packages depend on rocm[libraries], so the compatible ROCm packages should be installed automatically for you and you do not need to explicitly install ROCm first. If ROCm is already installed this may result in a downgrade if the torch wheel to be installed requires a different version.

# Single device (replace device-gfx942 with your GPU):
pip install --index-url https://rocm.nightlies.amd.com/whl-multi-arch/ \
    "torch[device-gfx942]" "torchvision[device-gfx942]" torchaudio

# Multiple devices (e.g. for a Dockerfile used by both MI300X and MI355X):
pip install --index-url https://rocm.nightlies.amd.com/whl-multi-arch/ \
    "torch[device-gfx942,device-gfx950]" \
    "torchvision[device-gfx942,device-gfx950]" \
    torchaudio

# All supported devices:
pip install --index-url https://rocm.nightlies.amd.com/whl-multi-arch/ \
    "torch[device-all]" "torchvision[device-all]" torchaudio

# Optional additional packages on Linux:
#   apex

Tip

The device extras install GPU-specific packages like amd-torch-device-gfx1100 which contain GPU-specific kernels and depend on rocm-sdk-device-gfx1100. The compatible ROCm packages are installed automatically, you do not need to install ROCm separately:

pip install --index-url https://rocm.nightlies.amd.com/whl-multi-arch/ \
    "torch[device-gfx1100]"

pip freeze  # with approximate download sizes:
# rocm-sdk-core==7.13.0a...              ~700 MB
# rocm-sdk-libraries==7.13.0a...         ~100 MB  (host code, shared across GPUs)
# rocm-sdk-device-gfx1100==7.13.0a...     ~50 MB  (only gfx1100 device code)
# torch==2.11.0+rocm...                  ~100 MB  (host code, shared across GPUs)
# amd-torch-device-gfx1100==2.11.0+...    ~50 MB  (only gfx1100 device code)
# Total:                                 ~1.1 GB
#
# For comparison, a similar per-family (non-multi-arch) torch wheel for
# gfx110X-all [gfx1100, gfx1101, gfx1102, gfx1103] is ~600 MB.

Using multi-arch PyTorch Python packages

After installing, verify PyTorch can see your GPU:

import torch

print(torch.cuda.is_available())
# True
print(torch.cuda.get_device_name(0))
# e.g. AMD Radeon Pro W7900 Dual Slot

See external-builds/pytorch/README.md for more details on supported PyTorch versions and building from source.

See also the Testing the PyTorch installation instructions in the AMD ROCm documentation.

Installing multi-arch JAX Python packages

Install JAX with ROCm support using the unified multi-arch index.

Important

Unlike PyTorch, the JAX wheels do not automatically install ROCm packages as a dependency. You must install ROCm first by following Installing multi-arch ROCm Python packages.

Always pin jax, jax_rocm<major>_plugin, and jax_rocm<major>_pjrt to the same version.

The plugin and PJRT package names embed the ROCm major version they were built against, so the name to install depends on the ROCm release: jax_rocm7_* for ROCm 7.x and jax_rocm10_* for ROCm 10.x.

# Set the version (currently supported: 0.10.0, 0.10.1, 0.10.2, and 0.11.0)
JAX_VERSION=0.11.0

# 1. Install ROCm (replace device-gfx942 with your GPU)
pip install --index-url https://rocm.nightlies.amd.com/whl-multi-arch/ \
    "rocm[libraries,device-gfx942]"

# 2. Install JAX ROCm wheels
# Use the ROCm major version the wheels were built against: 7 for ROCm 7.x, 10
# for ROCm 10.x.
ROCM_MAJOR=7
pip install --index-url https://rocm.nightlies.amd.com/whl-multi-arch/ \
    "jax_rocm${ROCM_MAJOR}_plugin==${JAX_VERSION}" \
    "jax_rocm${ROCM_MAJOR}_pjrt==${JAX_VERSION}"

# 3. Install matching jax from PyPI
pip install "jax==${JAX_VERSION}"

After installing, verify JAX can see your GPU:

import jax

print(jax.devices())
# [RocmDevice(id=0), RocmDevice(id=1), ...]

Installing multi-arch native packages

Native packages are installable via operating system package managers.

Installing multi-arch native Linux packages

ROCm native Linux packages are published for Debian-based and RPM-based distributions.

Warning

Nightly builds are primarily intended for development and testing and are currently unsigned.

Multi-arch native packages use a simplified package model compared to the legacy per-family releases:

Package name	Description
amdrocm	Installs all base ROCm libraries and runtime support for all supported GPU architectures
amdrocm-core-sdk	Installs the full ROCm SDK including runtime, development tools, and headers for all supported GPU architectures

Tip

To find the latest available release, browse the index pages:

• Debian packages: https://rocm.nightlies.amd.com/packages-multi-arch/deb/
• RPM packages: https://rocm.nightlies.amd.com/packages-multi-arch/rpm/

Look for directories in the format YYYYMMDD-<action-run-id> (e.g., 20260701-28484694006) and use the latest in the commands below.

Installing on Debian-based systems (Ubuntu, Debian, etc.)

# Step 1: Find the latest release from
#         https://rocm.nightlies.amd.com/packages-multi-arch/deb/
#         Look for directories like "20260701-28484694006"
# Step 2: Set the variable below
export RELEASE_ID=20260701-28484694006  # Replace with the latest date-runid

# Step 3: Add repository and install
sudo apt update
sudo apt install -y ca-certificates
echo "deb [trusted=yes] https://rocm.nightlies.amd.com/packages-multi-arch/deb/${RELEASE_ID} stable main" \
  | sudo tee /etc/apt/sources.list.d/rocm-multiarch-nightly.list
sudo apt update

# Install base runtime for all supported GPU architectures:
sudo apt install amdrocm
# Or install full SDK (runtime + dev tools + headers) for all supported GPU architectures:
sudo apt install amdrocm-core-sdk

Installing on RPM-based systems (RHEL, SLES, AlmaLinux, etc.)

# Step 1: Find the latest release from
#         https://rocm.nightlies.amd.com/packages-multi-arch/rpm/
#         Look for directories like "20260701-28484694006"
# Step 2: Set the variable below
export RELEASE_ID=20260701-28484694006  # Replace with the latest date-runid

# Step 3: Add repository and install
sudo dnf install -y ca-certificates
sudo tee /etc/yum.repos.d/rocm-multiarch-nightly.repo <<EOF
[rocm-multiarch-nightly]
name=ROCm Multi-Arch Nightly Repository
baseurl=https://rocm.nightlies.amd.com/packages-multi-arch/rpm/${RELEASE_ID}/x86_64
enabled=1
gpgcheck=0
priority=50
EOF

# Install base runtime for all supported GPU architectures:
sudo dnf clean all
sudo dnf install amdrocm
# Or install full SDK (runtime + dev tools + headers) for all supported GPU architectures:
sudo dnf install amdrocm-core-sdk

Note

To install support for a specific GPU architecture only, you can use the per-arch package variant (e.g., apt install amdrocm-gfx942 or dnf install amdrocm-gfx942). For a full list of supported GPU targets and their identifiers, see Supported Python [device-*] install extras.

Installing multi-arch tarballs

Standalone "ROCm SDK tarballs" are a flattened view of ROCm artifacts matching the familiar folder structure seen with system installs on Linux to /opt/rocm/ or on Windows via the HIP SDK:

install/
  .kpack/     # GPU-specific kernel packs
  bin/
  clients/
  include/
  lib/
  libexec/
  share/

Tarballs are just these raw files. They do not come with "install" steps such as setting environment variables.

Multi-arch tarballs separate GPU-specific kernel code into a .kpack/ directory. Two variants are available:

• Per-family multi-arch tarballs (e.g. therock-dist-linux-gfx110X-all-7.13.0a20260430.tar.gz) that include .kpack files only for one family.
• Full multi-arch tarball (e.g. therock-dist-linux-multiarch-7.13.0a20260430.tar.gz) that include .kpack files for all supported targets.

Browse and download tarballs from https://rocm.nightlies.amd.com/tarball-multi-arch/.

To download and extract:

mkdir therock-tarball && cd therock-tarball

# Per-family (smaller, one GPU family):
wget https://rocm.nightlies.amd.com/tarball-multi-arch/therock-dist-linux-gfx110X-all-7.13.0a20260430.tar.gz

# Or multiarch (all GPUs):
wget https://rocm.nightlies.amd.com/tarball-multi-arch/therock-dist-linux-multiarch-7.13.0a20260430.tar.gz

mkdir install && tar -xf *.tar.gz -C install

After extraction, test the install:

./install/bin/rocminfo
ls install/.kpack/
# blas_lib_gfx1100.kpack  fft_lib_gfx1100.kpack  rand_lib_gfx1100.kpack  ...

Tip

You may also want to add parts of the install directory to your PATH or set other environment variables like ROCM_HOME.

See also this issue discussing relevant environment variables.

Verifying your installation

After installing ROCm via any of the methods above, you can verify that your GPU is properly recognized.

Verifying installation on Linux

GPU status on Linux can be checked via either:

rocminfo
# or
amd-smi

Verifying installation on Windows

GPU status on Windows can be checked via

hipInfo.exe

Additional installation troubleshooting

If your GPU is not recognized or you encounter issues:

• Linux users: Check system logs using dmesg | grep amdgpu for specific error messages
• Review memory allocation settings (see the FAQ for GTT configuration on unified memory systems)
• Ensure you have the latest AMDGPU driver on Linux or Adrenalin driver on Windows