TL;DR: If Ollama or llama.cpp ignores your Radeon card and grinds along on the CPU, the cause is almost always that your GPU’s gfx target isn’t on ROCm’s official support list. The fix for most RDNA2/RDNA3 cards is one environment variable — HSA_OVERRIDE_GFX_VERSION — that maps your card to the nearest supported architecture. On an RX 6700 XT that turns roughly 6 tok/s on CPU into 15–40 tok/s on the GPU for Llama 3.1 8B Q4.

What you’ll be able to do after this guide:

• Read the exact ROCm error (no compatible GPUs were discovered, rocBLAS error: Cannot read TensileLibrary.dat) and know what it means
• Find your card’s gfx target and the correct override value for it
• Force GPU acceleration on Linux (systemd), Docker, and Windows — and know the one card family where the override crashes instead of helping

Honest take: The override is a compatibility bypass, not a driver fix. It works reliably on RDNA2 desktop cards mapped to gfx1030, works most of the time on RDNA3, and in 2026 you rarely need it at all on RX 7700/9000-series cards — ROCm 7.2 finally supports them natively. Check whether your card is already supported before you touch anything.

Step 1: Confirm the GPU is actually being ignored

Don’t guess. Load a model and check the processor split:

$ ollama run llama3.1:8b "hi"
$ ollama ps
NAME           ID              SIZE      PROCESSOR    UNTIL
llama3.1:8b    365c0bd3c000    6.7 GB    100% CPU     4 minutes from now

100% CPU on a machine with a discrete Radeon card means ROCm never claimed the GPU. Now find out why. Read the server log while starting Ollama:

$ journalctl -u ollama -f          # Linux systemd
# or run it in the foreground:
$ OLLAMA_DEBUG=1 ollama serve

You’re looking for one of these tells:

• no compatible GPUs were discovered — your gfx target isn’t on Ollama’s built-in ROCm support list.
• amdgpu too old, doesn't support gfx… — same root cause, different wording.
• rocBLAS error: Cannot read /opt/rocm/lib/rocblas/library/TensileLibrary.dat: Illegal seek for GPU arch — ROCm loaded but has no compute kernels compiled for your architecture.

All three point to the same problem: the card physically works, but ROCm has no library build for its exact architecture. That’s exactly what HSA_OVERRIDE_GFX_VERSION is for.

Step 2: Find your gfx target

Run rocminfo and grep for the gfx name, or use rocm-smi:

$ rocminfo | grep -i gfx
  Name:                    gfx1031
$ rocm-smi --showproductname

Match it against this table. The override value is the supported architecture ROCm does ship kernels for, written in x.y.z form:

Your card	gfx target	Natively supported?	Override value
RX 6800 / 6800 XT / 6900 XT / 6950 XT	gfx1030	Yes (RDNA2 baseline)	none needed
RX 6700 XT / 6750 XT	gfx1031	No	10.3.0
RX 6600 / 6600 XT / 6650 XT	gfx1032	No	10.3.0
RX 6500 XT / 6400	gfx1034	No	10.3.0
RX 7900 XTX / XT / GRE	gfx1100	Yes	none needed
RX 7800 XT / 7700 XT	gfx1101	Yes on ROCm 7.2+	11.0.0 on older ROCm
RX 7600 / 7600 XT	gfx1102	Sometimes	11.0.0
Radeon 780M / 760M iGPU	gfx1103	No	11.0.0 (marginal)
RX 9070 / 9070 XT / 9060 XT	gfx1200 / gfx1201	Yes on ROCm 7.2+	none needed
Strix / Strix Halo APU	gfx1150 / gfx1151	Yes on ROCm 7.2+	none needed

The rule of thumb: map to the base architecture of your generation. Any RDNA2 card (gfx103x) overrides to 10.3.0 (which is gfx1030). Any RDNA3 card (gfx110x) overrides to 11.0.0 (which is gfx1100). Never cross generations — overriding an RDNA2 card to 11.0.0 mixes incompatible instruction sets and will crash.

Step 3: Apply the override

Linux (systemd) — the durable fix

Setting the variable in your shell won’t stick, because Ollama runs as a background service. Edit the service instead:

$ sudo systemctl edit ollama

Add this in the drop-in that opens:

[Service]
Environment="HSA_OVERRIDE_GFX_VERSION=10.3.0"

Then reload and restart:

$ sudo systemctl daemon-reload
$ sudo systemctl restart ollama

While you’re here, confirm your user is in the render and video groups — a permissions gap produces the same “no GPU” symptom:

$ sudo usermod -aG render,video $USER   # log out/in afterward

Docker

Pass the variable and the device nodes into the container:

$ docker run -d --device /dev/kfd --device /dev/dri \
    -e HSA_OVERRIDE_GFX_VERSION=10.3.0 \
    -v ollama:/root/.ollama -p 11434:11434 \
    ollama/ollama:rocm

Windows

Windows is the harder case: the official Ollama build only ships ROCm kernels for a short list of cards, and HSA_OVERRIDE_GFX_VERSION alone often isn’t enough because the required library files aren’t in the package. The community solution is the likelovewant/ollama-for-amd fork, which bundles rebuilt rocblas/Tensile libraries for unsupported gfx targets. Install that fork, drop the matching library files into the ROCm folder, then set the environment variable in System Properties → Environment Variables:

HSA_OVERRIDE_GFX_VERSION = 10.3.0

Step 4: Verify it worked

Restart, load a model, and check ollama ps again:

$ ollama run llama3.1:8b "count to five"
$ ollama ps
NAME           ID              SIZE      PROCESSOR    UNTIL
llama3.1:8b    365c0bd3c000    6.7 GB    100% GPU     4 minutes from now

100% GPU is the win. Cross-check that VRAM is actually filling while a prompt generates:

$ rocm-smi --showmeminfo vram

On an RX 6700 XT (12GB), a Llama 3.1 8B Q4_K_M model lands around 15–40 tok/s once the GPU is engaged — community reports on r/LocalLLaMA and the ROCm issue tracker cluster in that range through mid-2026; treat it as directional, not a lab measurement. That’s roughly 4× what the same card’s host CPU manages. For reference, a natively-supported RX 7900 XTX (24GB, 960 GB/s) reaches ~96 tok/s on the same model with no override at all — a reminder that the override buys you working, not fast.

The one card family where the override backfires

There is a known 2026 regression worth flagging before you spend an evening on it. On gfx1031 and gfx1032 cards (RX 6700 XT, RX 6600 series), ROCm 6.4.3 and later versions have shipped builds where HSA_OVERRIDE_GFX_VERSION=10.3.0 loads the model and then segfaults (SIGSEGV) the moment it receives a prompt, silently falling back to CPU (Ollama issue #12111). As of the ROCm 7.2.x line there’s no confirmed one-line fix. If you hit this:

1. Pin to a known-good ROCm/Ollama combination (the pre-6.4.3 ROCm builds were stable for these cards), or
2. Use the likelovewant fork’s rebuilt libraries even on Linux, or
3. Fall back to the Vulkan backend in llama.cpp, which sidesteps ROCm entirely and works on almost any Radeon card — slower than ROCm when ROCm works, but it doesn’t crash.

This is the single most common “I followed every guide and it still doesn’t work” report for AMD in 2026, and it’s not your fault — it’s a driver regression.

Multi-GPU: overriding one card without touching the other

If you run a supported card plus an unsupported one, a blanket override would wrongly rewrite the good card too. Recent Ollama supports per-device overrides with an index suffix (HSA_OVERRIDE_GFX_VERSION_0=10.3.0), but the indexing has changed between releases and is easy to get wrong. The safer, version-proof approach is to select a single GPU for inference with ROCR_VISIBLE_DEVICES and override only that one:

[Service]
Environment="ROCR_VISIBLE_DEVICES=0"
Environment="HSA_OVERRIDE_GFX_VERSION=10.3.0"

Confirm the device order with rocminfo first — GPU 0 in ROCm’s enumeration isn’t always the card in your top PCIe slot.

When the override won’t save you (and what to do instead)

The override maps architectures; it can’t invent VRAM or memory bandwidth. It won’t help if:

• Your card has too little VRAM. A 4GB RX 6500 XT can’t hold an 8B Q4 model (~6.7GB). No override fixes that — you’ll get a CPU/GPU split. Drop to a smaller model or a heavier quant.
• Your card is pre-RDNA (Polaris/Vega, gfx8/gfx9). ROCm support for these is effectively gone in 2026. Vulkan in llama.cpp is your only realistic GPU path.
• You just need it to work today. If you’re fighting a segfaulting driver on deadline, renting a known-good NVIDIA GPU by the hour is the pragmatic escape hatch — a RunPod instance gives you a CUDA box that Just Works while you sort the local rig out on your own time.

If you’re shopping rather than debugging, the honest 2026 answer is to buy into native support: an RX 7900-series card or a new RX 9070 XT runs on ROCm 7.2 with zero environment-variable gymnastics. The override is for the card you already own, not the one you’re about to buy — see our ROCm 7.2 setup guide and RX 9070 XT vs RTX 5060 Ti comparison for the buying side.

FAQ

Is HSA_OVERRIDE_GFX_VERSION safe? It’s safe in the sense that it can’t damage hardware — it only changes which ROCm kernel library gets loaded. The risk is instability: on unsupported cards you may hit crashes or subtly wrong output, because you’re running kernels tuned for a slightly different architecture. Map within your own generation (RDNA2→10.3.0, RDNA3→11.0.0) and you’re on the well-tested path.

What value do I use for an RX 6600 / 6700 XT? 10.3.0. Both are RDNA2 (gfx1032 and gfx1031 respectively), and both map to the natively-supported gfx1030.

Do I still need this on an RX 9070 or RX 7900 XTX? No. ROCm 7.2 (2026) added native support for RDNA4 (gfx1200/gfx1201) and the full RDNA3 desktop line including the RX 7700 series. If rocminfo shows your card and ollama ps reads 100% GPU out of the box, don’t set the variable at all.

LM Studio shows my AMD card but runs slow — same fix? Different symptom. If LM Studio detects the card but inference crawls, that’s usually an offload-slider or CPU-spillover issue, not a detection failure — see LM Studio not using your GPU. This guide is for the case where the GPU is invisible entirely.

Windows says the variable is set but it still uses CPU. On Windows the variable alone rarely works because the ROCm library files for your gfx target aren’t in the official package. You need the likelovewant/ollama-for-amd fork’s rebuilt rocblas libraries in addition to the environment variable.

Sources

1. Hardware support — Ollama documentation — official supported gfx targets and HSA_OVERRIDE_GFX_VERSION syntax.
2. AMD ROCm 7.2 Released With More Radeon Cards Supported — Phoronix — native RX 7700 and RDNA4 support.
3. ROCm compatibility matrix — AMD ROCm Documentation — official architecture support list.
4. SIGSEGV after prompt with HSA_OVERRIDE_GFX_VERSION on gfx1031/1032 — Ollama issue #12111 — the 2026 override-crash regression.
5. Running Ollama on Ubuntu with an Unsupported AMD GPU — Paul Conroy — systemd override walkthrough and CPU-vs-GPU speedup.
6. Running Ollama with an AMD Radeon 6600 XT — Major Hayden — gfx1032 → 10.3.0 real-world example.
7. likelovewant/ollama-for-amd Wiki — Windows rebuilt-library fork for unsupported cards.

---

Prices and support status are as of July 2026 and move quickly — verify your card against rocminfo and the current ROCm compatibility matrix before buying. Building a local AI coding stack? See aicoderscope.com for local-model coding backends, and aifoss.dev for open-source model picks that fit AMD VRAM budgets.

Recommended Gear

• RX 6700 XT — 12GB RDNA2, the classic “needs the override” value card for 7B–13B models.
• RX 7900 XTX — 24GB, 960 GB/s, natively supported, ~96 tok/s on Llama 3.1 8B.
• RX 9070 XT — 16GB RDNA4, runs on ROCm 7.2 with no override needed.