Best local LLM for RX 9070 XT & 9060 XT

RDNA4 in LM Studio: what actually runs

The Radeon RX 9070 XT and RX 9060 XT are RDNA4 cards, and RDNA4 shifts the local-LLM calculus in two ways: the 9070 XT ships with 16 GB of VRAM, and AMD's software stack for these consumer GPUs is still stabilizing. In LM Studio you pick between two llama.cpp backends — ROCm (HIP) and Vulkan — and the right choice depends more on your OS and driver version than on the model itself. This page focuses on that backend choice, 16 GB sizing, and the setup gotchas; for the measured throughput numbers, we keep those on the RX 9070 XT page rather than duplicating them here.

One VRAM fact to confirm before you download anything: the 9070 XT is a 16 GB card, while the 9060 XT ships in both 8 GB and 16 GB variants. The 8 GB version is a genuinely different sizing problem — if that's what you have, start with our 8 GB VRAM guide instead.

ROCm vs Vulkan: which backend to pick

LM Studio ships both backends as swappable runtimes, so you don't have to compile anything. Here's the practical split:

• ROCm (HIP) — AMD's compute path. When the runtime targets your GPU architecture, it is typically the faster of the two and uses VRAM more predictably. Support for consumer RDNA4 has been arriving in stages, and it is more mature on Linux than on Windows.
• Vulkan — the broad-compatibility path. It runs almost anywhere a modern driver exists, which makes it the reliable fallback when ROCm doesn't yet recognize your card. It is usually a little slower but far less fussy.

The pragmatic workflow: open LM Studio's runtime manager, select the ROCm runtime, and load a small model. If the card is detected and output is coherent, keep it. If the GPU isn't detected, you get garbage tokens, or the app crashes on load, switch to Vulkan — that combination almost always means the ROCm build doesn't target your gfx architecture yet. Check the current ROCm documentation for which GPU targets a given release supports before assuming your card is covered. This backend split is one reason many RDNA4 owners weigh runtimes at all; if you're also comparing launchers, see LM Studio vs Ollama.

Which models fit 16 GB

Sizing on 16 GB is mostly arithmetic. A Q4_K_M quant costs roughly 0.58 GB per billion parameters for the weights, and you should budget about 20% on top for the KV cache and runtime overhead at an 8K context. That produces a clear tier list:

So 16 GB comfortably hosts anything up to the 14B class fully on the GPU. If you want the extra quality of a higher-precision quant, note that Q8 runs about 1.07 GB per billion parameters, which still fits a 7–8B model (~9–10 GB with overhead) — a reasonable trade when you don't need the larger model. Bigger context windows raise the overhead figure, so recalculate before pushing past 8K; our VRAM calculator does this for arbitrary sizes, and quantization explained covers what you're giving up at each level. On an 8 GB 9060 XT, even 14B spills — stay at 7–8B Q4 or smaller.

Setup pitfalls on RDNA4

Most RDNA4 headaches are configuration, not hardware. The recurring ones:

• Wrong runtime. The single biggest cause of "my AMD card is slow" is silently running on CPU or an unsupported ROCm build. Confirm the active backend in LM Studio and verify GPU utilization is actually moving.
• Partial offload eating speed. If a model is too big, llama.cpp keeps some layers on the CPU and throughput collapses. Set the GPU offload slider to load all layers (the CLI equivalent is -ngl set high, e.g. -ngl 999) and pick a model that fits fully.
• Context length blowing your budget. Jumping to 32K context can add several GB of KV cache and push a model that fit at 8K into spillover. Raise context deliberately.
• Linux gfx overrides. On Linux, unsupported architectures sometimes work by setting HSA_OVERRIDE_GFX_VERSION to a nearby supported target — but treat this as experimental and verify output quality, since a mismatched override can produce subtly wrong results.
• iGPU confusion. If your CPU has integrated graphics, make sure the runtime selects the discrete Radeon, not the iGPU.

When something regresses after an update, the usual fix is a driver or runtime version mismatch — pin a known-good pairing and check release notes before upgrading both at once.

Recommendations by use case

Match the model to the job rather than always reaching for the largest one that fits:

• General chat and everyday tasks: a 7–8B instruct model at Q4_K_M gives the fastest responses and leaves VRAM headroom for long context. Good default on both 16 GB and 8 GB cards.
• Best quality that still fits on 16 GB: a 12–14B model at Q4_K_M. This is the sweet spot for reasoning and instruction-following without touching the CPU.
• Coding assistance: use a code-specialized model in the 7–14B range and pair it with an editor integration — see best local models for code for current picks.
• Larger models (24B+): possible only with partial offload and a throughput penalty, or by dropping to a smaller quant that starts to hurt quality. On 16 GB, a well-chosen 14B usually beats a crippled 24B.

The families worth trying first are the mainstream open-weight lines (Qwen, Llama, Gemma, Mistral); grab quants from a reputable uploader on Hugging Face and confirm the exact tag against the model card. Backend behavior and llama.cpp's AMD support both move quickly, so if performance looks off, check the llama.cpp repository for open RDNA4 issues before assuming your hardware is the limit.

Frequently asked questions

Does the RX 9070 XT support ROCm in LM Studio?

LM Studio ships a ROCm (HIP) runtime you can select without compiling anything, and RDNA4 support has been rolling out in stages. Whether your specific build recognizes the card depends on the ROCm release and your OS — Linux tends to be ahead of Windows. If ROCm doesn't detect the GPU, switch to the Vulkan runtime, which works reliably as a fallback.

Is ROCm or Vulkan faster on RDNA4?

When the ROCm runtime actually targets your GPU architecture, it is usually the faster of the two and manages VRAM more predictably. Vulkan is typically a bit slower but far more compatible, so it's the right choice when ROCm doesn't yet support your card. Test both with a small model and keep whichever detects the GPU and produces coherent output.

What is the largest LLM I can run on a 16 GB RX 9070 XT?

A 14B-class model at Q4_K_M fits fully on the GPU with room for an 8K context, using roughly 9–10 GB. Models in the 24B–32B range exceed 16 GB once you add KV-cache overhead, so they require partial CPU offload and run much slower. For most work, a 14B that fits entirely beats a larger model that spills.

Is the 8 GB RX 9060 XT enough for local LLMs?

Yes, for smaller models: 7–8B at Q4_K_M runs comfortably within 8 GB and handles general chat and light coding. Larger models won't fit without offloading to the CPU, which hurts speed. If you plan to run bigger models often, the 16 GB variant is the better buy — check which version you have before downloading.

---

By Mohamed Meguedmi — independent comparator of locally-runnable LLMs, benchmarked on a real RTX 5070 Ti (data CC BY 4.0). See the local LLM leaderboard and the best Ollama models.