Best AI Models for the RX 7900 XTX
The 27–32B class at Q4 on AMD’s 24GB card — footprints from Ollama’s tag sizes, speeds as bandwidth ceilings, and the ROCm and Vulkan reality spelled out
The best AI model for the RX 7900 XTX is Qwen3.6 27B — the q4_K_M build is 17GB as Ollama lists it, leaving ~7GB of the 24GB for context, with a bandwidth ceiling of ~56 tok/s (AMD’s 960 GB/s ÷ 17GB — a ceiling, not a measurement). The rule this family runs on is unchanged by the vendor: weights plus KV cache must sit inside VRAM, so a 24GB card’s comfortable class is 27–32B at Q4 (17–20GB) or a 14B at Q8. That makes the list Qwen 2.5 Coder 32B (20GB) for code, Gemma 4 31B (20GB, dense, image input), the MoE Qwen3-Coder 30B (19GB) for fast agent loops and Mistral Small 3.2 24B (15GB) with the most context room. What changes on AMD is the software: Ollama runs this card through ROCm on Linux and Windows, Vulkan is the fallback, and CUDA-only tooling is off the table.
Models that run well on the RX 7900 XTX
| Model | Size | Build | Memory used | Ceiling tok/s* |
|---|---|---|---|---|
| WINNERQwen3.6 27B The headline pick for any 24GB card — Qwen’s strongest dense open model, 256K context, ~7GB of the card left for KV cache. Pull the explicit q4_K_M tag: the bare 27b tag now resolves to an 18–19GB build. ollama pull qwen3.6:27b-q4_K_M | 27B (dense) | Q4_K_M | ~17GB | ceiling ~56 tok/s (960 ÷ 17GB) |
| Qwen 2.5 Coder 32B The coding pick — the strongest dense open coder that fits a single consumer card, and it runs the same on ROCm as on CUDA because llama.cpp’s GGUF path is vendor-neutral. ~4GB left for context. ollama pull qwen2.5-coder:32b | 32B (dense) | Q4_K_M | ~20GB | ceiling ~48 tok/s (960 ÷ 20GB) |
| Gemma 4 31B Google’s dense 31B (30.7B params) with text and image input and a 256K window — the multimodal pick for 24GB. The 26b tag is a different MoE model (~4B active); 31b is the dense one. ollama pull gemma4:31b | 31B (dense) | Q4_K_M | ~20GB | ceiling ~48 tok/s (960 ÷ 20GB) |
| Qwen3-Coder 30B The agentic coder with a 256K native context — 30B-class weights, small-model decode cost. ~5GB of KV room; the fast lane for tool-calling loops. ollama pull qwen3-coder:30b | 30B (MoE, ~3B active) | Q4_K_M | ~19GB | MoE — ~3B active per token; bandwidth is not the limit; not measured |
| Mistral Small 3.2 24B The context-room pick: ~9GB spare on this card, text and image input, strong instruction following. The one to run when you want a long session rather than the biggest weights. ollama pull mistral-small3.2:24b | 24B (dense) | Q4_K_M | ~15GB | ceiling ~64 tok/s (960 ÷ 15GB) |
| Flux.1 dev FP8 (ComfyUI on ROCm) RDNA 3 has no FP8 math units (those arrived with RDNA 4), so the FP8 file is a memory saving, not a speed-up — but 24GB holds it with the T5 encoder resident. Needs the ROCm PyTorch wheels, not the CUDA ones; our ComfyUI-on-ROCm guide walks through the install. ComfyUI (ROCm PyTorch): flux1-dev-fp8.safetensors | 12B | FP8 | ~11GB (~13GB with LoRAs) | diffusion — compute-bound, not timed |
* Ceiling tok/s = the device’s vendor-listed memory bandwidth ÷ the model’s file size as Ollama lists it — the rate a dense model cannot exceed, because every generated token reads the whole weight set once. We have not measured this hardware. Real-world generation usually lands at 50–80% of the ceiling and falls as the context grows; mixture-of-experts rows read only their active parameters, so no ceiling is quoted for them, and image models are compute-bound, so no render time is.
What won't fit on the RX 7900 XTX
- ✗Llama 3.3 70B (needs 43GB at Q4_K_M) — Even the 2-bit llama3.3:70b-instruct-q2_K tag is 26GB — 2GB past the card before any context. Two 24GB cards hold the Q4 build; Ollama splits a model across two Radeons over PCIe.
- ✗Qwen3.6 27B at Q8_0 (needs 30GB) — The near-lossless build of the winner is a 32GB-card job. On 24GB you run it at Q4.
- ✗Qwen 2.5 Coder 32B at Q6_K (needs 27GB) — The q5_K_M tag (23GB) technically loads with ~1GB spare, which is no room for a coding context; Q4_K_M at 20GB is the practical ceiling for a 32B here.
- ✗gpt-oss:120b (needs 65GB) — Workstation class — an 80GB card or a 128GB unified-memory box.
RX 7900 XTX-specific notes
- →Where this page’s numbers come from: we do not own a 7900 XTX. Footprints are the file sizes Ollama prints on each tag page (read 2 Nov 2026), and every tok/s is a ceiling — the “up to 960 GB/s” on AMD’s spec page divided by the gigabytes a dense model reads per token. The 96 MB Infinity Cache does not change that arithmetic for LLM decode, because a 17GB weight set streams through it rather than living in it. Real engines land at roughly 50–80% of the ceiling. We quote no measured rate for this card.
- →Driver reality, from Ollama’s own GPU docs: the RX 7900 XTX is on Ollama’s supported list for both Linux and Windows. On Linux Ollama requires the AMD ROCm v7 driver (installed or upgraded with AMD’s `amdgpu-install` utility), and on Windows a ROCm v7 / HIP7-capable driver stack. AMD’s ROCm system-requirements page lists the 7900 XTX (RDNA 3, gfx1100) as officially supported in the current ROCm 7.14.0 release on Ubuntu 24.04.4 and 22.04.5 and RHEL 10.1 and 9.7. No `HSA_OVERRIDE_GFX_VERSION` trick is needed — that variable is for cards that are not on the list.
- →Vulkan is the fallback, not the plan: Ollama ships a Vulkan backend that is enabled by default when installed and covers AMD cards on Windows and Linux. If ROCm will not initialise, Vulkan gets you running; on some Linux distributions the `ollama` user must be added to the `render` group first, and without root or the `cap_perfmon` capability Ollama estimates VRAM instead of reading it. After any backend change, load a 20GB model and run `ollama ps`: it must read 100% GPU.
- →What CUDA-only means in practice: Ollama, llama.cpp and anything GGUF-based run the full list above on ROCm, and PyTorch has ROCm wheels for ComfyUI and training. What you lose is the CUDA-exclusive layer — TensorRT-LLM, and any ComfyUI custom node or Python package that ships compiled CUDA kernels — plus FP8 hardware, which RDNA 3 does not have. Our full 7900 XTX guide covers the ROCm install and the FlashAttention build.
- →Power, from AMD’s spec page: 355 W typical board power, an 800 W minimum PSU recommendation, and 2× 8-pin connectors — no 12VHPWR cable, no adapter. That is one of the easier 24GB installs. Token generation is a sustained load measured in minutes, so size the supply for 355 W held, not a gaming burst.
- →Price on 2 Nov 2026: AMD’s launch SEP was $999 (13 Dec 2022). videocardprices.com showed a lowest in-stock new price of $1,820.99 at Amazon as of 17 Oct 2026 and an eBay used listing at $1,175 on the day we read it — the memory shortage pushed this card well past its launch price. The comparison that matters is against a used RTX 3090 (our 3090 page carries a dated band): same 24GB, same model list, CUDA versus a ROCm setup you have to maintain. Our 7900 XTX vs RTX 3090 guide goes through it.
- →The three 24GB cards on this hub are closer than the brand war suggests: vendor bandwidth figures are 936 GB/s (RTX 3090), 960 (this card) and 1,008 (RTX 4090), so the decode ceilings on this page are within ~8% of either NVIDIA card. What separates them is software maturity and compute, not what fits. If the model list is the point and you will run Ollama, the 7900 XTX is a real 24GB option; if you live in CUDA-only tooling, it is not.
Quick start
curl -fsSL https://ollama.com/install.sh | shollama run qwen3.6:27b-q4_K_Mollama psGo from "it runs" to actually building
All 561 chapters — running local models, RAG, agents, fine-tuning — plus the Python Lab and every course added later.
Frequently asked questions
What is the best LLM to run on an RX 7900 XTX?
Qwen3.6 27B at Q4_K_M — 17GB as Ollama lists the tag, ~7GB of the 24GB left for context, and a bandwidth ceiling of ~56 tok/s (960 ÷ 17GB). For code, Qwen 2.5 Coder 32B (20GB) or the MoE Qwen3-Coder 30B (19GB) for fast agent loops; for image input, Gemma 4 31B (20GB) or Mistral Small 3.2 24B (15GB). Every figure is a tag size or a ceiling, not a rate we measured.
Does Ollama work on the RX 7900 XTX?
Yes. Ollama’s GPU documentation lists the 7900 XTX as supported on both Linux and Windows. On Linux you need the AMD ROCm v7 driver first (AMD’s amdgpu-install utility handles it); on Windows a ROCm v7 / HIP7-capable driver stack. AMD’s own ROCm requirements page lists the card (gfx1100) as officially supported in ROCm 7.14.0 on Ubuntu 24.04 and 22.04 and RHEL 10.1 and 9.7. If ROCm fails to initialise, Ollama’s Vulkan backend runs the same GGUF models as a fallback.
RX 7900 XTX vs RTX 3090 for local AI — which runs more?
They run the same list: both are 24GB cards, so everything on this page runs on either. Vendor bandwidth is nearly identical (960 vs 936 GB/s), so the decode ceilings are within ~3%. The difference is software: the 3090 runs every CUDA tool ever written; the 7900 XTX needs ROCm (or Vulkan) and skips CUDA-only projects. Neither card has FP8 hardware. Price decides it on the day you buy — compare the dated bands on both pages, then read our 7900 XTX vs 3090 comparison.
Can the RX 7900 XTX run a 70B model?
Not on one card. Llama 3.3 70B is 43GB at Q4_K_M and 26GB even at the 2-bit q2_K tag, so it does not fit 24GB without spilling to system RAM, where generation runs at system-RAM pace. Two 24GB Radeons give you 48GB and the Q4 build fits; Ollama splits a model across both over PCIe. On a single 7900 XTX, a 32B at Q4 answers better than a squeezed 70B.
Do I need HSA_OVERRIDE_GFX_VERSION for the 7900 XTX?
No. That environment variable makes Ollama treat an unsupported Radeon as a similar supported target (Ollama’s own example forces an RX 5400 to run as gfx1030). The 7900 XTX is gfx1100 and is on the supported list, so set nothing. If Ollama still does not see the card on Linux, check that the ROCm v7 driver is installed and that the ollama user is in the render group.
Related guides
Ready to Go Beyond Tutorials?
25 structured courses with hands-on chapters - build RAG chatbots, AI agents, and ML pipelines on your own hardware.
Was this helpful?