Best GPU Under $400 for Llama-Class 8B Models in 2026

As of 2026, the best GPU under $400 for running Llama-class 8B models locally is the MSI GeForce RTX 3060 Ventus 3X 12G OC. Its 12 GB of GDDR6 comfortably holds an 8B model at four-bit quantization plus a real context window, and CUDA support in llama.cpp and vLLM keeps it faster in practice than 8 GB alternatives that theoretically compute more per second but constantly spill to system RAM.

Step 0: decide which model size you actually need before shopping

Before you look at a single card, decide honestly which model you plan to run. The answer changes everything below. If you only need an 8B model — a Llama 3.1 8B, a Qwen 3 8B, a Mistral Small 3 variant — then a 12 GB card is genuinely enough and a $300-$400 budget is realistic. If you keep telling yourself you want to "leave headroom for 14B or maybe try 32B eventually," you have already left the segment this article covers, and no card under $400 will make you happy. Public benchmarks from the r/LocalLLaMA community consistently show that people who buy a 12 GB card intending to run 32B models return three months later to shop again. Pick your target model, quantization, and context window before you shop, not after.

Why VRAM capacity beats raw compute at this price point

Under $400 in mid-2026, you have exactly one job: buy the most usable VRAM you can, backed by tolerable memory bandwidth and a stable driver stack for the frameworks you actually run. Everything else is decoration. Public benchmarks show that for single-user chat inference, token generation is memory-bandwidth-bound rather than compute-bound: the GPU spends most of its time streaming weights through the memory subsystem, not doing math. A card with more shaders but less VRAM will still lose to a card with adequate VRAM and slower cores, because the moment weights or the key-value cache spill to system memory over PCIe, throughput collapses by an order of magnitude and no amount of raw TFLOPS recovers it.

That is why the RTX 3060 12 GB, a 2021 mid-range gaming card, keeps beating flashier options in this bracket for local LLM work. The chip is unremarkable, but 12 GB of GDDR6 on a 192-bit bus at 360 GB/s (per TechPowerUp) is the cheapest ticket to fitting an 8B model plus a real context window without offload. The 170 W TGP means a basic PSU and a $50 cooler are enough. The CUDA stack means llama.cpp, vLLM, exllama, ollama, and text-generation-webui all just work, without the driver adventures that AMD ROCm still occasionally serves. That combination is what you are paying for.

Key takeaways

• The 12 GB MSI RTX 3060 Ventus 3X 12G OC is the reference budget pick for 8B-class local inference in 2026; it fits an 8B model at Q4 or Q5 with a usable context window and stays on the mature CUDA path.
• 8 GB cards look cheaper on paper but push you into offload the moment context grows, so real-world throughput on longer conversations is worse than a slower 12 GB card.
• Intel Arc A770 16G is a genuine wildcard — the extra VRAM is real, but framework support (IPEX-LLM, llama.cpp Vulkan backend) still lags CUDA, so treat it as a project card, not a plug-and-play choice.
• Memory bandwidth predicts generation tok/s better than shader counts do for single-user chat.
• If you use a model less than an hour a day, a hosted API is cheaper than any GPU you can buy.

How much VRAM does an 8B model really need?

The weights are the floor, not the ceiling. An 8-billion-parameter model at Q4_K_M lands near 5 GB of weights per llama.cpp's published size tables (llama.cpp on GitHub), but you also need room for the key-value cache, activations, CUDA graphs, and whatever the framework decides to hold. The KV cache grows with the context you actually use, not the context the model theoretically supports. Reserve headroom or you will hit an out-of-memory error the first time you paste a long log file.

The quantization ladder for an 8B model, using llama.cpp-style GGUF sizing conventions, breaks down roughly as follows.

The tok/s bands above sit inside the range r/LocalLLaMA measurements consistently report for the RTX 3060 12 GB running Llama 3.1 8B and Qwen 3 8B with a modest 4k-8k context; wider context always drags the number down.

Spec-delta table: the sub-$400 field

Every price below is a new-card street price sighted in mid-2026. Used prices are a separate discussion further down.

Read that table carefully. The RTX 4060 8 GB looks competitive at Q4 only if your context stays short and you never grow it. The 16 GB alternatives all beat the 3060 12 GB on paper VRAM but hand you a support-quality tax that most builders under-budget for.

Why 12 GB is the practical floor, and what breaks at 8 GB

You can absolutely load an 8B model at Q4 on an 8 GB card. Once. In a fresh session, with a small system prompt and a short question, it will look great and hit competitive tok/s. Then you paste in a 6,000-token document, or the KV cache from a long chat starts to accumulate, and the runtime silently offloads a chunk of layers to system memory. Throughput drops from 45-55 tok/s to 8-15 tok/s and stays there. The card feels "fine" on benchmarks and broken in daily use.

Twelve gigabytes buys you three things at once: room for the weights at Q4 or Q5, room for a real 8k-16k context window, and enough headroom to try a 13B-class model quantized aggressively without immediately hitting the wall. It also buys you a second life for the card as a 1080p gaming GPU when you eventually replace it, which is a real resale consideration.

Prefill vs generation: which one your card is actually bad at

Two very different workloads hide behind the word "inference." Prefill — processing the prompt you send in — is compute-heavy and scales well with shader count. Generation — emitting tokens one at a time — is memory-bandwidth bound and scales with GDDR throughput. Budget cards are usually worse at prefill relative to their generation numbers, because the compute deficit hurts more when the model has to chew through a long input in one shot. The practical effect: on a 12 GB RTX 3060, a short question feels snappy, a long pasted document takes several seconds before the first token appears. That "time to first token" is what many builders forget to measure. If your workflow involves long inputs — code review, summarization, RAG with big chunks — read benchmark tables for prefill separately from tok/s.

Context length impact: how a 32k window eats the headroom you thought you had

The KV cache scales roughly linearly with tokens in context and with model layer count. For a 32-layer, 4096-hidden 8B model in FP16 KV cache, you spend roughly 512 KB per token, so a 32k window costs about 16 GB just for the cache. That is why builders quantize KV cache too (Q8 or Q4 KV in llama.cpp), often halving or quartering that footprint. Even after aggressive KV quantization, a 32k context is still hundreds of megabytes to a few gigabytes on top of the weights.

Do the math for your real use case. If you plan to run 8k contexts, you can comfortably load Q5 or Q6 weights on a 12 GB card and still have breathing room. If you insist on 32k or 64k contexts, you probably want a 16 GB or 24 GB card, or you need to accept Q4 weights with quantized KV cache and no headroom for anything else.

Does multi-GPU help at this budget, or is it a trap?

Almost always a trap under $400 total. Splitting a model across two cards is supported in llama.cpp and vLLM, but the interconnect latency (PCIe, not NVLink at this tier), the doubled idle draw, the added heat, and the case/PSU/cooling complications rarely pay off. Two $200 8 GB cards do not equal one 16 GB card in real-world throughput — you lose a nontrivial fraction of the memory bandwidth advantage crossing PCIe, and you gain a synchronization tax on every generation step. Multi-GPU earns its complexity when a single affordable card physically cannot hold the model at all, typically 70B-class weights. For 8B-class work, one 12 GB card beats two 8 GB cards on ergonomics, power, and often raw speed.

The rest of the box: CPU, NVMe, and cooling for a budget inference machine

Once you have the GPU picked, the rest of the parts list gets easy. Local LLM inference is not CPU-bound as long as the model fits in VRAM, so paying for a 16-core enthusiast CPU is wasted. Two sensible choices:

• The AMD Ryzen 5 5600G is the cheapest sane pairing. Six Zen 3 cores, integrated Vega graphics you can use for display output so the 3060's VRAM stays 100% dedicated to the model, and low power draw. Perfect for a headless or single-monitor inference box that you may occasionally boot without the dedicated GPU installed.
• The AMD Ryzen 7 5700X is the upgrade if you plan to also do software development, small dataset preprocessing, or occasional gaming on the same box. Eight cores, no iGPU, better multithreaded throughput for compiling, indexing, and preparing training data for a LoRA.

Both drop into AM4 boards that are cheap and plentiful on the used market as of 2026. Skip DDR5 platforms unless you already own one — inference on a discrete GPU does not care.

For storage, a fast NVMe drive matters more than most people expect, because model files are large and you will download, extract, and load them repeatedly. The WD_BLACK 250GB SN770 NVMe SSD is a good primary boot and hot-model drive: fast PCIe 4.0 sequential reads shorten model load times noticeably, and 250 GB holds a handful of 8B-class GGUFs at Q4 or Q5 comfortably. Pair it with a cheap 2 TB SATA SSD for your model archive if you plan to hoard weights, which everyone in this hobby eventually does.

Cooling matters because a GPU under sustained inference load runs hot for hours at a time, not the bursty pattern of a game. A Noctua NH-U12S on the CPU is overkill for the 65 W 5600G and appropriately sized for a 105 W 5700X. Its low noise floor makes the machine tolerable next to a desk, and cooling the CPU well helps the case stay cooler around the GPU too. Two case fans and reasonable airflow keep the 3060 in a healthy temperature band even during long generation runs.

Perf-per-dollar and perf-per-watt

Roughly, using the tok/s bands above at Q4:

• RTX 3060 12G: ~50 tok/s / $300 = 0.17 tok/s per dollar, ~0.29 tok/s per watt
• RTX 4060 8G: ~48 tok/s / $300 = 0.16 tok/s per dollar, ~0.42 tok/s per watt (but only when it fits)
• RTX 4060 Ti 16G: ~52 tok/s / $450 = 0.12 tok/s per dollar, ~0.31 tok/s per watt
• Intel Arc A770 16G: ~32 tok/s / $315 = 0.10 tok/s per dollar, ~0.14 tok/s per watt
• AMD RX 7600 XT 16G: ~28 tok/s / $340 = 0.08 tok/s per dollar, ~0.15 tok/s per watt

The 3060 wins perf-per-dollar in the 8B tier. The 4060 wins perf-per-watt when the model fits and your context stays short. Everything else is chasing more VRAM at a support-quality cost.

Verdict matrix: buy, upgrade, or skip

Buy the 12 GB RTX 3060 if:

• You want a plug-and-play 8B-class local LLM machine that works on day one with llama.cpp, ollama, vLLM, exllama, and text-generation-webui.
• Your context needs are under about 16k tokens.
• You want CUDA compatibility for occasional Stable Diffusion, ComfyUI, or Whisper work on the same card.

Spend more (RTX 4060 Ti 16G, or used RTX 3090 24G) if:

• You genuinely plan to run 13B-14B models daily.
• You need 32k+ context routinely.
• You are training or fine-tuning even small LoRAs, where the training-step VRAM footprint is much larger than inference.

Use a hosted API instead if:

• You use models less than an hour a day. The math never works for a GPU you leave idle.
• You need frontier reasoning quality that no 8B open-weight model matches.
• You want to prototype product features on constantly-changing frontier models rather than pin a workflow to one open weight.

Common pitfalls

1. Buying an 8 GB card thinking Q4 will fit. Q4 weights fit. Q4 weights plus a real KV cache do not. As soon as your conversation grows past a few thousand tokens or you paste in a document, layers offload to system RAM and throughput collapses. The card feels fast on the first benchmark and slow in daily use. Twelve gigabytes is the practical floor for 8B-class inference in 2026, and it will only feel tighter over time as context windows in real workloads keep growing.
2. Assuming used prices track new. The used RTX 3060 12 GB market is thinner than you think, because these cards became the community-recommended budget LLM card and prices firmed up rather than falling. A "$180 used 3060" on Craigslist is often a coin-mined card with degraded thermal pads. Warranty on a new Ventus 3X at ~$300 is often worth the $50-$80 premium over a random used unit.
3. Ignoring driver stack maturity. llama.cpp is broadly cross-platform, but CUDA remains the smoothest path. ROCm for the AMD RX 7600 XT is real and improving, but you will read GitHub issues, patch backends, and troubleshoot Vulkan fallbacks. Intel Arc through IPEX-LLM works well when it works and confusingly when it doesn't. Under $400, the CUDA tax is worth paying with your time savings.
4. Overspending on the CPU and skimping on the GPU. A $300 CPU and a $200 8 GB GPU is the opposite of the right build. The inference workload does not care about CPU cores as long as the model fits in VRAM. Put the money in the GPU.
5. Forgetting the PSU headroom. A 170 W GPU plus a 65-105 W CPU pulls transiently well above the sum during load spikes. A good 650 W 80+ Gold PSU is cheap and eliminates a whole class of "why did my machine reboot" bugs during long generation runs.

When NOT to buy a $400 GPU

Not every problem is a hardware problem. Skip the purchase entirely if:

• You use LLMs occasionally. Hosted APIs charge fractions of a cent per thousand tokens. A GPU has to run tens of millions of tokens per year before it beats a Claude Haiku or Gemini Flash bill you would have paid instead. If you use models a few times a week, the API wins.
• You already own an RTX 3060 12 GB or better. Reasonably new 12 GB cards, especially the 3060 12 GB and RTX 3080 12 GB, are already excellent for 8B-class work. Upgrading inside the same tier rarely delivers a visible improvement in daily use.
• You actually want a 32B model. Nothing under $400 handles a 32B model at Q4 without heavy offload and painful tok/s. If your target is Qwen 3 32B or a similarly sized model, either budget for a 24 GB card (used RTX 3090 remains the community answer) or accept API costs. Buying a 12 GB card to run 32B locally is the most common regret purchase in this space.
• Your power budget is tight. A dedicated inference box that draws 250-350 W under load for hours a day adds real electricity cost. Do the math against API pricing in your region before committing.
• You need vision or multimodal. Local vision-language models at usable quality still push VRAM footprints past 12 GB even at aggressive quantization. This is a bad segment to buy into today.

Worked scenarios

The developer running local code completion nightly

You use a coding assistant every evening: repository chat, code explanations, boilerplate generation, occasional refactoring. You have privacy reasons (client code, NDAs) for keeping it off cloud APIs. You want Qwen 3 8B Coder or Llama 3.1 8B Instruct with a comfortable 8k context, and you value response snappiness because you interact with it constantly.

The MSI RTX 3060 Ventus 3X 12G OC is exactly right. Q5_K_M weights fit with room for 8k context, generation lands in the 40-55 tok/s band which is faster than you can read, and the CUDA path means your favorite runtime (ollama, LM Studio, vLLM) works without setup drama. Pair it with the Ryzen 7 5700X so you can compile the projects you are working on without waiting, put the models on the WD_BLACK SN770 for quick loads, and drop a Noctua NH-U12S on the CPU to keep the whole rig quiet. Total build under $700 excluding chassis, and it will comfortably serve this workflow for years. Public benchmarks from developer-heavy corners of r/LocalLLaMA and r/homelab consistently describe this exact configuration as the "boring, works, done" answer.

The hobbyist running a Discord chatbot

You want a friendly conversational bot for your community server. Traffic is bursty — nothing for hours, then a flurry of chat when everyone is online. You do not need frontier reasoning, but you do want personality, decent context memory, and ideally the ability to hand off longer questions without offloading and stalling. A single RTX 3060 12G handles this workload fine at Q4 or Q5 with a 4k-8k context. Even the Ryzen 5 5600G is enough CPU here — the iGPU means you can leave the 3060 fully dedicated to the model and use the integrated graphics for any display output during setup. If the Discord bot is the only local workload, you can leave the box headless and remote in for maintenance. This is the segment where a used 3060 makes the most sense if you find a clean one, since the workload is undemanding and downtime is tolerable. If you want to run a slightly better 13B model quantized to Q4_K_S when it fits, a 16 GB alternative like the RTX 4060 Ti 16G (~$430-$480) is worth the stretch, but for pure 8B chat, the 3060 12 GB is the honest answer.

The builder training a small LoRA

You want to fine-tune an 8B model on a modest dataset — a few hundred to a few thousand examples for a domain style or vocabulary. Training is dramatically more VRAM-hungry than inference: optimizer states, gradients, and higher-precision working copies of the weights all live alongside the model. Even a QLoRA (4-bit weights, LoRA adapters in higher precision) on an 8B model wants 10-12 GB just for the training step, before you factor in batch size and sequence length. A 12 GB RTX 3060 can do QLoRA training on an 8B model at short sequence lengths (512-1024 tokens) with batch size 1, and it will feel slow — hours-to-a-day territory for small datasets. If training is a serious part of your workflow rather than an occasional experiment, this is where the budget breaks: you want at least 16 GB, ideally the used RTX 3090 24G route, or you want to rent an H100 hour on a cloud service for the occasional training run and keep the local card for inference. Puget Systems' workstation performance writeups (Puget Systems Labs) consistently show that training benchmarks fall off a cliff below adequate VRAM, in a way inference benchmarks do not. Plan accordingly.

Bottom line

For running Llama-class 8B models locally in 2026 on a budget of $400 or less new, the answer is the 12 GB MSI RTX 3060 Ventus 3X 12G OC. It is not the fastest card at its price and it does not have the most VRAM at its price, but it is the only card that combines enough VRAM, adequate memory bandwidth, mature CUDA support, and low enough power draw to build a quiet, reliable, single-user inference machine that just works. Pair it with a Ryzen 5 5600G or Ryzen 7 5700X on AM4, a WD_BLACK SN770 250 GB for hot models, and a Noctua NH-U12S to keep the whole rig near silent, and you have a build that will serve you until your model appetite genuinely outgrows 12 GB — at which point the answer stops being a $400 GPU anyway.

If you can stretch to $450-$500, the RTX 4060 Ti 16G is the honest step up. If you can stretch to a clean used RTX 3090 24G, that is the last card you will need for 8B-class work. Everything else in this bracket asks you to trade support maturity for VRAM, and under $400, that trade rarely wins in practice.

Citations and sources

• TechPowerUp — GeForce RTX 3060 12 GB specs
• llama.cpp on GitHub
• Puget Systems Labs — workstation and AI performance writeups

This piece is editorial synthesis based on publicly available information. No independent first-party benchmarking is reported.