ROCm 7.2 RX 9070 XT Setup: Avoid Day-One Breakage

ROCm 7.2 on RX 9070 XT requires three critical steps: pin your kernel to 6.11+, explicitly target gfx1201 during setup, and set HIP_VISIBLE_DEVICES before ROCR_VISIBLE_DEVICES. Skip any and you'll hit HSA failures or inference hangs. This guide walks the exact order-of-operations that separates "install completed" from "inference actually works."**

Why RDNA4 + ROCm 7.2 Needs Extra Care

RDNA4 introduces architectural changes that ROCm 7.2 doesn't auto-detect. The installer can't assume gfx1201 (RX 9070 XT GPU ID) without explicit flags. Skip this and the driver loads—but inference fails mid-model. Kernel mismatches cause "HSA initialization failed" errors that only surface when you run your first model. Setting ROCR_VISIBLE_DEVICES before HIP_VISIBLE_DEVICES causes inference to hang indefinitely, wasting hours debugging.

The RX 9070 XT launched April 2026. The first ROCm 7.2 patch cycle backported support, so fixes exist. But you need precise kernel + driver alignment to unlock them. Skip any step and you hit breakage that looks like a hardware defect.

What Makes RDNA4 Different from RDNA3

The gfx1201 introduced in RX 9070 series features 96 compute units, up from 80 compute units in gfx1030 (RX 7900 XT). That redesign isn't just more cores. RDNA4's memory controller changed fundamentally. It requires kernel 6.11 or later for full driver compatibility. Older kernels can't route memory traffic correctly to the new architecture.

ROCm 7.2's HSA runtime triggers illegal instruction traps on kernels below 6.10. Your system won't lock up—the driver will simply refuse to initialize. You'll see the error message, reinstall, and assume something went wrong. This is where many first-time RDNA4 builders get stuck.

Community drivers (amdvlk) mask problems during install but fail under memory-heavy models. Running a 70B quantized model exposes every kernel-driver mismatch that rocm-smi missed.

Verify Your Hardware: gfx1201 Detection

Before you download anything, confirm your system has what it takes. Run rocm-smi before any driver install to confirm gfx1201 is reported. Check kernel version with uname -r; it must be 6.11 or later for RDNA4 support. On kernel 6.10 or below, upgrade first—the HSA runtime won't initialize otherwise.

Look at /sys/kernel/debug/dri/0/amdgpu_gfxoff and disable power-gating if it's set to 1 (write 0 to disable). Gfxoff can mask GPU ID detection during early boot. Run lspci to spot PCIe conflicts or duplicate device entries. These cause the driver to see two GPUs when you have one.

Running Your First GPU Detection

Install rocm-smi: sudo apt update && sudo apt install -y rocm-smi (Debian/Ubuntu; adjust for your distro). Run it immediately:

rocm-smi --showproductname

It should print "AMD Radeon RX 9070 XT". Confirm the GPU ID:

rocm-smi --showid

This must report gfx1201, never "gfx1030" or "unknown". If gfx1201 shows "unknown," reboot BIOS into default settings or reseat the GPU in its slot. A loose card will report garbage on every attempt.

Pre-Install Checklist: Kernel Pin + Dependencies

Kernel pinning prevents unattended upgrades from breaking your HSA driver stack mid-season; pin to kernel 6.11.x once you're stable. You'll install dependencies first: build-essentials, libelf-dev, and linux-headers matching your current kernel version must be in place before the ROCm package lands.

If AMDGPU fails to load during install (look for "module signature mismatch"), disable secure boot in BIOS. That's UEFI Secure Boot rejecting the kernel module. Take a system snapshot (timeshift, btrfs, or LVM) in case installation breaks your system. ROCm 7.2 is fresh and occasionally breaks SSH without manual boot-line edits.

Pinning Kernel to 6.11.x

Check current kernel:

uname -r

Note the major.minor (e.g., 6.11.5). Now pin the kernel packages so apt won't upgrade them silently:

sudo apt-mark hold linux-image-generic linux-headers-generic linux-modules-extra-generic

Verify the pin:

sudo apt-mark showhold

All three packages should be listed. The next time you run sudo apt upgrade, the kernel will be held back. Confirm this before proceeding with the full system update. Once ROCm 7.2 is stable, you can unhold and drift forward to newer kernels, but for the first month, lock it down.

Installing ROCm 7.2 with gfx1201 Targeting

Download the ROCm 7.2 installer and pass --gpu-deploy gfx1201 during install to force correct architecture targeting. This flag tells the installer to build and configure code paths specific to gfx1201, not the generic fallback that assumes your GPU might be anything. Install to /opt/rocm-7.2 (not a symlink to /opt/rocm) until installation is verified and tested—symlinks can hide state and make debugging harder.

Watch for "HSA initialization" messages during install; failures here indicate kernel version mismatch. The installer will report every step. Don't interrupt or reboot mid-installation even if it seems slow. Post-install, run rocm-smi --showid again to confirm the driver reports gfx1201. If it still says "unknown," the installation didn't complete cleanly.

Installer Command and Flags

Download from the official AMD repository:

wget https://repo.radeon.com/rocm/apt/latest/jammy/rocm-7.2.0.tar.gz

(Adjust the URL for your Ubuntu LTS version—focal, jammy, or noble.) Extract and navigate:

tar -xzf rocm-7.2.0.tar.gz && cd rocm-release-7.2.0

Install with explicit gfx1201 targeting:

sudo bash install.sh --gpu-deploy gfx1201 --install-path /opt/rocm-7.2

Wait for "ROCm runtime ready" confirmation. Do not interrupt or reboot mid-installation. The process takes 3–5 minutes. Rushing causes corruption that forces a complete reinstall.

Environment Variables: The Order That Works

Set HIP_VISIBLE_DEVICES=0 before ROCR_VISIBLE_DEVICES=0; reversed order causes 30-second hangs during inference. Both variables control which GPU the runtime exposes, and they're processed in sequence. If ROCR runs first, it locks the GPU before HIP claims it. The inference engine stalls indefinitely waiting for access.

Add /opt/rocm-7.2/bin to PATH before any CUDA or OpenCL paths to avoid symbol name collisions. Both ROCm and CUDA runtimes define hipMemcpy, hipLaunch, and core functions. If the wrong library loads first, you get "symbol not found" errors. Set HSA_OVERRIDE_GFX_VERSION=gfx1201 explicitly if gfx1201 is still not auto-detected by the runtime.

Test variables with echo $PATH, rocm-smi --showid, and a lightweight model (Phi 2 or Mistral 7B) before production use. A quick validation now prevents four hours of debugging when you launch a 70B model.

.bashrc / .zshrc Setup

Open ~/.bashrc or ~/.zshrc and add these lines in this exact order:

export PATH=/opt/rocm-7.2/bin:$PATH
export LD_LIBRARY_PATH=/opt/rocm-7.2/lib:$LD_LIBRARY_PATH
export HIP_VISIBLE_DEVICES=0
export ROCR_VISIBLE_DEVICES=0
export HSA_OVERRIDE_GFX_VERSION=gfx1201

Apply the changes:

source ~/.bashrc

(Or restart your terminal if using zsh.) Verify the PATH:

echo $PATH | grep rocm

It should print /opt/rocm-7.2/bin before /usr/local/cuda or any system paths. If CUDA shows up first, move /usr/local/cuda out of your PATH entirely or delete it if you're not using it. CUDA + ROCm in the same PATH causes "inference times out" on this hardware—the #1 support issue.

First Inference Test: Spotting and Fixing Day-One Breakage

Use Ollama to test inference: ollama pull mistral:7b && ollama run mistral:7b "Hello world" to validate the full stack. Ollama is lightweight enough to isolate driver issues from application code. If it works, your ROCm setup is solid. If it hangs or errors, you'll know exactly which layer failed.

Watch for three failures: "HSA initialization failed" (kernel too old), "Cannot find symbol" (CUDA path collision), "Timeout" (env var order wrong). If inference hangs beyond 30 seconds, kill the process immediately and re-check env var order with env | grep -E 'HIP|ROCR|HSA'. Hangs longer than 30 seconds aren't glitches—they're structural problems requiring fixes.

Phi 2 single-token inference should complete in under 2 seconds. Over 5 seconds means GPU throttling or memory saturation. If you hit 5+ seconds, check GPU clocks with rocm-smi --showtemp. Thermal throttling can look like driver problems.

Troubleshooting the Five Most Common Day-One Failures

"HSA initialization failed" — Your kernel is older than 6.11 or secure boot is enabled. Run uname -r and check BIOS settings. If you're on 6.10.x, boot to 6.11 or later before trying ROCm again.

"Cannot find symbol hipMemcpyDtoH" — An old CUDA installation is in your PATH. Move /usr/local/cuda out of the way or delete it entirely. Verify with which hipcc—it should be /opt/rocm-7.2/bin/hipcc, not /usr/local/cuda/bin/hipcc.

Inference hangs for 30+ seconds then times out — gfx1201 is not detected. Set HSA_OVERRIDE_GFX_VERSION=gfx1201 explicitly in your shell or bashrc and re-run inference. If it completes, your environment variable setup was incomplete.

rocm-smi shows gfx1201 but Ollama sees unknown GPU — Your env var order is reversed. Re-apply HIP_VISIBLE_DEVICES before ROCR_VISIBLE_DEVICES in bashrc and source the file again.

GPU clock stuck at 300 MHz (no boost) — The AMDGPU power profile is set to "conservative". Run this to enable dynamic boosting:

echo performance | sudo tee /sys/class/drm/card0/device/power_dpm_force_performance_level

Your inference will jump from 5+ seconds per token to 1–2 seconds.

After ROCm is stable, explore the vram-tier-ladder to match your 24 GB VRAM to model sizes and quantization levels. If you're building on Windows instead, AMD GPU + Windows Ollama + Vulkan explains why this Linux path isn't available there and what to use instead.