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.

Table of contents:

• Multi-arch releases
  • Multi-arch release status
  • Installing multi-arch ROCm Python packages
  • Installing multi-arch PyTorch Python packages
  • Supported Python [device-*] install extras
  • Installing multi-arch tarballs
  • Installing multi-arch native Linux packages
• Per-family releases
  • Installing per-family releases using pip
    • Python packages release status
    • Installing ROCm Python packages
    • Using ROCm Python packages
    • Installing PyTorch Python packages
    • Using PyTorch Python packages
    • Installing JAX Python packages
    • Using JAX Python packages
  • Installing from tarballs
    • Browsing release tarballs
    • Manual tarball extraction
    • Automated tarball extraction
    • Using installed tarballs
  • Installing from native packages
    • Native packages release status
    • Installing on Debian-based systems
    • Installing on RPM-based systems
• Verifying your installation

Multi-arch releases

Key differences from 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 downloads can be scoped to a single GPU instead of always being scoped to a family or "all"

Multi-arch release status

Job description	Status
Build ROCm artifacts/tarballs/packages
Test ROCm artifacts
Build and test Linux PyTorch packages
Build and test Windows PyTorch packages

Package availability:

Installing multi-arch ROCm Python packages

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

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

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 ROCm with device support for your GPU using the unified index. Select your GPU using the [device-*] extras from the table below:

pip install --index-url https://rocm.nightlies.amd.com/whl-multi-arch/ \
    rocm-sdk-device-gfx942 rocm-sdk-device-gfx950

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

After installing, verify your installation:

rocm-sdk test

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.

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:

# 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

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.

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.

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 (multi-arch only)
  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 tarballs (e.g. therock-dist-linux-gfx110X-all-7.13.0a20260430.tar.gz) that include .kpack files only for one family.
• Multiarch 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  ...

Installing multi-arch native Linux packages

In addition to Python wheels and tarballs, ROCm native Linux packages are published for Debian-based and RPM-based distributions via the multi-arch pipeline.

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

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 "20260501-25200531110"
# Step 2: Set the variable below
export RELEASE_ID=20260501-25200531110  # 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 "20260501-25200531110"
# Step 2: Set the variable below
export RELEASE_ID=20260501-25200531110  # 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

Per-family releases

Per-family releases use GPU-family-specific index URLs — you choose the index URL that matches your GPU family, and all packages for that family are served from that URL.

Installing per-family releases using pip

We recommend installing ROCm and projects like PyTorch and JAX via pip, the Python package installer.

We currently support Python 3.10, 3.11, 3.12, 3.13, and 3.14 (PyTorch 2.9+ only).

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

Python packages release status

Platform	ROCm Python packages	PyTorch Python packages	JAX Python packages
Linux
Windows			—

Index page listing

For now, rocm, torch, and jax packages are published to GPU-architecture-specific index pages and must be installed using an appropriate --find-links argument to pip. They may later be pushed to the Python Package Index (PyPI) or other channels using a process like https://wheelnext.dev/. Please check back regularly as these instructions will change as we migrate to official indexes and adjust project layouts.

Installing ROCm Python packages

We provide several Python packages which together form the complete ROCm SDK.

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

Optional profiler package

A new optional package rocm-profiler is available, providing ROCm profiling tools:

• ROCm Systems Profiler (rocprofiler-systems)
• ROCm Compute Profiler (rocprofiler-compute)

Installing the profiler package

Install profiling tools via the meta package:

pip install "rocm[profiler]"

This will install:

• rocm-sdk-core (required runtime + SDK)
• rocm-profiler (profiling tools)

rocm for gfx94X-dcgpu

Supported devices in this family:

Install instructions:

pip install --index-url https://rocm.nightlies.amd.com/v2/gfx94X-dcgpu/ "rocm[libraries,devel]"

rocm for gfx950-dcgpu

Supported devices in this family:

Install instructions:

pip install --index-url https://rocm.nightlies.amd.com/v2/gfx950-dcgpu/ "rocm[libraries,devel]"

rocm for gfx110X-all

Supported devices in this family:

Install instructions:

pip install --index-url https://rocm.nightlies.amd.com/v2/gfx110X-all/ "rocm[libraries,devel]"

rocm for gfx1151

Supported devices in this family:

Install instructions:

pip install --index-url https://rocm.nightlies.amd.com/v2/gfx1151/ "rocm[libraries,devel]"

rocm for gfx120X-all

Supported devices in this family:

Install instructions:

pip install --index-url https://rocm.nightlies.amd.com/v2/gfx120X-all/ "rocm[libraries,devel]"

Using ROCm Python packages

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

pip freeze | grep rocm
# rocm==6.5.0rc20250610
# rocm-sdk-core==6.5.0rc20250610
# rocm-sdk-devel==6.5.0rc20250610
# rocm-sdk-libraries-gfx110X-all==6.5.0rc20250610

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

To initialize the rocm[devel] package, use the rocm-sdk tool to eagerly expand development contents:

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

These contents are useful for using the package outside of Python and lazily expanded on the first use when used from Python.

Once you have verified your installation, you can continue to use it for standard ROCm development or install PyTorch, JAX, or another supported Python ML framework.

Installing PyTorch Python packages

Using the index pages listed above, you can also install torch, torchaudio, torchvision, and apex.

pip uninstall pytorch-triton-rocm

torch for gfx94X-dcgpu

Supported devices in this family:

pip install --index-url https://rocm.nightlies.amd.com/v2/gfx94X-dcgpu/ torch torchaudio torchvision
# Optional additional packages on Linux:
#   apex

torch for gfx950-dcgpu

Supported devices in this family:

pip install --index-url https://rocm.nightlies.amd.com/v2/gfx950-dcgpu/ torch torchaudio torchvision
# Optional additional packages on Linux:
#   apex

torch for gfx110X-all

Supported devices in this family:

pip install --index-url https://rocm.nightlies.amd.com/v2/gfx110X-all/ torch torchaudio torchvision
# Optional additional packages on Linux:
#   apex

torch for gfx1151

Supported devices in this family:

pip install --index-url https://rocm.nightlies.amd.com/v2/gfx1151/ torch torchaudio torchvision
# Optional additional packages on Linux:
#   apex

torch for gfx120X-all

Supported devices in this family:

pip install --index-url https://rocm.nightlies.amd.com/v2/gfx120X-all/ torch torchaudio torchvision
# Optional additional packages on Linux:
#   apex

Using PyTorch Python packages

After installing the torch package with ROCm support, PyTorch can be used normally:

import torch

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

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

Installing JAX Python packages

Using the index pages listed above, you can also install jaxlib, jax_rocm7_plugin, and jax_rocm7_pjrt.

jax for gfx94X-dcgpu

Supported devices in this family:

For JAX 0.8.2:

pip install --index-url https://rocm.nightlies.amd.com/v2/gfx94X-dcgpu/ jaxlib==0.8.2 jax_rocm7_plugin==0.8.2 jax_rocm7_pjrt==0.8.2
# Install matching jax from PyPI
pip install jax==0.8.2

For JAX versions > 0.8.2:

# Replace <jax_version> with one of the supported versions above (e.g. 0.9.2, 0.9.1)
# — keep all three pins in sync.
pip install --index-url https://rocm.nightlies.amd.com/v2/gfx94X-dcgpu/ jax_rocm7_plugin==<jax_version> jax_rocm7_pjrt==<jax_version>
# Install matching jax from PyPI
pip install jax==<jax_version>

jax for gfx950-dcgpu

Supported devices in this family:

For JAX 0.8.2:

pip install --index-url https://rocm.nightlies.amd.com/v2/gfx950-dcgpu/ jaxlib==0.8.2 jax_rocm7_plugin==0.8.2 jax_rocm7_pjrt==0.8.2
# Install matching jax from PyPI
pip install jax==0.8.2

For JAX versions > 0.8.2:

# Replace <jax_version> with one of the supported versions above (e.g. 0.9.2, 0.9.1)
# — keep all three pins in sync.
pip install --index-url https://rocm.nightlies.amd.com/v2/gfx950-dcgpu/ jax_rocm7_plugin==<jax_version> jax_rocm7_pjrt==<jax_version>
# Install matching jax from PyPI
pip install jax==<jax_version>

jax for gfx110X-all

Supported devices in this family:

For JAX 0.8.2:

pip install --index-url https://rocm.nightlies.amd.com/v2/gfx110X-all/ jaxlib==0.8.2 jax_rocm7_plugin==0.8.2 jax_rocm7_pjrt==0.8.2
# Install matching jax from PyPI
pip install jax==0.8.2

For JAX versions > 0.8.2:

# Replace <jax_version> with one of the supported versions above (e.g. 0.9.2, 0.9.1)
# — keep all three pins in sync.
pip install --index-url https://rocm.nightlies.amd.com/v2/gfx110X-all/ jax_rocm7_plugin==<jax_version> jax_rocm7_pjrt==<jax_version>
# Install matching jax from PyPI
pip install jax==<jax_version>

jax for gfx1151

Supported devices in this family:

For JAX 0.8.2:

pip install --index-url https://rocm.nightlies.amd.com/v2/gfx1151/ jaxlib==0.8.2 jax_rocm7_plugin==0.8.2 jax_rocm7_pjrt==0.8.2
# Install matching jax from PyPI
pip install jax==0.8.2

For JAX versions > 0.8.2:

# Replace <jax_version> with one of the supported versions above (e.g. 0.9.2, 0.9.1)
# — keep all three pins in sync.
pip install --index-url https://rocm.nightlies.amd.com/v2/gfx1151/ jax_rocm7_plugin==<jax_version> jax_rocm7_pjrt==<jax_version>
# Install matching jax from PyPI
pip install jax==<jax_version>

jax for gfx120X-all

Supported devices in this family:

For JAX 0.8.2:

pip install --index-url https://rocm.nightlies.amd.com/v2/gfx120X-all/ jaxlib==0.8.2 jax_rocm7_plugin==0.8.2 jax_rocm7_pjrt==0.8.2
# Install matching jax from PyPI
pip install jax==0.8.2

For JAX versions > 0.8.2:

# Replace <jax_version> with one of the supported versions above (e.g. 0.9.2, 0.9.1)
# — keep all three pins in sync.
pip install --index-url https://rocm.nightlies.amd.com/v2/gfx120X-all/ jax_rocm7_plugin==<jax_version> jax_rocm7_pjrt==<jax_version>
# Install matching jax from PyPI
pip install jax==<jax_version>

Using JAX Python packages

After installing the JAX packages with ROCm support, JAX can be used normally:

import jax

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

For building JAX from source or running the full JAX test suite, see the external-builds/jax README.

Installing from 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/  # Extracted tarball location, file path of your choosing
  .info/
  bin/
  clients/
  include/
  lib/
  libexec/
  share/

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

Browsing release tarballs

Release tarballs are uploaded to the following locations:

Manual tarball extraction

To download a tarball and extract it into place manually:

mkdir therock-tarball && cd therock-tarball
# For example...
wget https://rocm.nightlies.amd.com/tarball/therock-dist-linux-gfx110X-all-7.12.0a20260202.tar.gz
mkdir install && tar -xf *.tar.gz -C install

Automated tarball extraction

For more control over artifact installation—including per-commit CI builds, specific release versions, the latest nightly release, and component selection—see the Installing Artifacts developer documentation. The install_rocm_from_artifacts.py script can be used to install artifacts from a variety of sources.

Using installed tarballs

After installing (downloading and extracting) a tarball, you can test it by running programs from the bin/ directory:

ls install
# bin  include  lib  libexec  llvm  share

# Now test some of the installed tools:
./install/bin/rocminfo
./install/bin/test_hip_api

cat install/share/therock/therock_manifest.json
# {
#   "the_rock_commit": "567dd890a3bc3261ffb26ae38b582378df298374",
#   "submodules": [
#     {
#       "submodule_name": "half",
#       "submodule_path": "base/half",
#       "submodule_url": "https://github.com/ROCm/half.git",
#       "pin_sha": "207ee58595a64b5c4a70df221f1e6e704b807811",
#       "patches": []
#     },
#     ...

Installing from native packages

In addition to Python wheels and tarballs, ROCm native Linux packages are published for Debian-based and RPM-based distributions.

Native packages release status

Platform	Native packages
Linux
Windows	(Coming soon)

GPU family and package mapping

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

# Step 1: Find the latest release from https://rocm.nightlies.amd.com/deb/
#         Look for directories like "20260310-12345678"
# Step 2: Look at the "GPU family and package mapping" table above to find
#         the GFX Family for your GPU (e.g., gfx94x, gfx110x, gfx1151)
# Step 3: Set the variables below

export RELEASE_ID=20260310-12345678  # Replace with actual date-runid
export GFX_ARCH=gfx110x              # Replace with GFX Family from the mapping table

# Step 4: Add repository and install
sudo apt update
sudo apt install -y ca-certificates
echo "deb [trusted=yes] https://rocm.nightlies.amd.com/deb/${RELEASE_ID} stable main" \
  | sudo tee /etc/apt/sources.list.d/rocm-nightly.list
sudo apt update
sudo apt install amdrocm-core-sdk-${GFX_ARCH}
# If only runtime is needed, install amdrocm-${GFX_ARCH} instead

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

# Step 1: Find the latest release from https://rocm.nightlies.amd.com/rpm/
#         Look for directories like "20260310-12345678"
# Step 2: Look at the "GPU family and package mapping" table above to find
#         the GFX Family for your GPU (e.g., gfx94x, gfx110x, gfx1151)
# Step 3: Set the variables below

export RELEASE_ID=20260310-12345678  # Replace with actual date-runid
export GFX_ARCH=gfx110x              # Replace with GFX Family from the mapping table

# Step 4: Add repository and install
sudo dnf install -y ca-certificates
sudo tee /etc/yum.repos.d/rocm-nightly.repo <<EOF
[rocm-nightly]
name=ROCm Nightly Repository
baseurl=https://rocm.nightlies.amd.com/rpm/${RELEASE_ID}/x86_64
enabled=1
gpgcheck=0
priority=50
EOF
sudo dnf clean all
sudo dnf install amdrocm-core-sdk-${GFX_ARCH}
# If only runtime is needed, install amdrocm-${GFX_ARCH} instead

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
• For platform-specific troubleshooting when using PyTorch or JAX, see:
  • Using ROCm Python packages
  • Using PyTorch Python packages
  • Using JAX Python packages