The Best GPUs for Running AI Locally in November 2026: VRAM, Real Model Requirements, and What to Buy

style="clear: both;">

The best GPU for local AI in November 2026 is not the fastest gaming card on the shelf — it is the card with the most VRAM your budget can buy, running on a softwa stack that actually works. If you want to run large language models with Ollama, LM Studio or llama.cpp, or generate images with ComfyUI and Flux, the decision starts and ends with memory. This guide walks through the real VRAM math, the exact model requirements for 2026's models, honest card-by-card analysis of NVIDIA, AMD, Intel and Apple options, the software reality on Windows, Linux and macOS, and clear buying recommendations by budget tier — all with November 2026 prices, sourced and dated.

The market backdrop matters. GPU prices have climbed through 2026 on a memory crisis: TechSpot's Q4 2026 pricing update, published 2 November 2026, found the RTX 5090 at $9,400 in the US, 370% above its $1,999 launch price, with overall prices up 11% month over month and 35% over three months (ShiftDelete summary of TechSpot). Meanwhile the long-awaited RTX 50 Super refresh — the 24GB cards local AI builders have been waiting for — is reportedly finished but sitting in board partners' warehouses, with leaks pointing at a CES 2027 reveal instead of a 2026 launch (more on that rumour below). In this environment, buying the wrong card is an expensive mistake. This guide makes sure you buy the right one.

Why VRAM Is the Only Spec That Truly Matters for Local AI

Gamers compare CUDA cores, clock speeds and ray-tracing frames. For local AI, almost none of that matters — VRAM capacity decides what you can run, and memory bandwidth decides how fast it runs. An LLM is a giant file of numbers (weights) that must be loaded into memory before a single token can be generated. If the model does not fit in your GPU's VRAM, the excess spills into system RAM, and generation speed collapses because the GPU then waits on the far slower system memory bus. A card with 12GB of VRAM will run an 8-billion-parameter model smoothly and a 70-billion-parameter model at a crawl or not at all — regardless of how many CUDA cores it has.

Memory bandwidth is the second spec that matters. Generating text is a memory-bound operation: roughly speaking, every generated token requires reading the entire model once, so tokens per second ≈ memory bandwidth ÷ model size. That is why an RTX 4090 with 1,008 GB/s of bandwidth feels snappier than a card with more cores but a narrower bus, and why Apple's unified memory — 614 GB/s on an M5 Max — can feel competitive despite modest "GPU" specs on paper. Capacity decides what fits; bandwidth decides how fast it talks.

This has one counter-intuitive consequence that surprises every beginner: an older, slower card with more VRAM beats a newer, faster card with less VRAM for local AI. A used RTX 3090 with 24GB of VRAM from 2020 runs a 27-billion-parameter model that a brand-new RTX 5070 with 12GB simply cannot load. When you see the RTX 3060 12GB back at the top of the October 2026 Steam hardware survey — reclaiming first place at 3.62% of surveyed systems — remember that part of that card's legendary longevity comes from AI builders who bought it for its 12GB frame buffer, not its gaming speed. We covered that comeback in detail in our RTX 3060 comeback article.

The VRAM Math, Explained Simply

You can compute any model's VRAM footprint with one formula: VRAM in GB ≈ parameters (in billions) × bits per weight ÷ 8. The "bits per weight" comes from quantization — the compression applied to the model's numbers. Full precision (FP16) uses 16 bits per weight, so a 70B model in FP16 needs about 140GB: firmly datacenter territory. The community standard for local use is Q4_K_M, a 4-bit quantization from the llama.cpp project that stores each weight in roughly 4.8–4.9 bits (block metadata pushes it slightly above 4), working out to about 0.60GB per billion parameters, per the llmconfigurator.com VRAM guide (October 2026) and the Guide to Artificial Intelligence VRAM calculator.

At Q4_K_M, the arithmetic is friendly: 8B × 4.9 ÷ 8 ≈ 4.9GB of weights; 70B × 4.9 ÷ 8 ≈ 43GB. Those numbers match the published model files almost exactly — llama.cpp's own measurements put a 70B Q4_K_M file at 43.1GB (Guide to Artificial Intelligence). Quality holds up remarkably well at 4-bit: llama.cpp's tests show Q4_K_M adding only 0.18 points of perplexity on Llama 3 8B, while dropping below 4 bits (Q2_K adds 3.5 points) visibly degrades the model (Pasquale Pillitteri's quantization explainer).

But the weights are not the whole bill. Three hidden costs sit on top of the file size: the KV cache, the context window, and framework overhead. The KV cache is memory the model uses to "remember" the conversation; it grows with context length and is not included in the model file at all. A long-context chat on a big model can add several gigabytes — Pasquale Pillitteri's guide calculates that Llama 3.3 70B with 128,000 tokens of context needs about 43GB for the KV cache alone, the same as its Q4 weights. At the small end, an 8B model at 8K context needs about 7GB total: a 4.9GB file, 1.1GB of context cache and roughly 1GB of buffers (LocalAIMaster's Llama 3.1 8B guide). Framework overhead is roughly 0.8–1GB (llmconfigurator.com).

Practical rule: take the weights number, add 30–50% for cache and overhead, and buy the card above that total. Ollama itself adapts to your VRAM automatically — its documentation notes it sets default context from available memory: about 4,000 tokens below 24 GiB of VRAM, 32,000 tokens up to 48 GiB, and 256,000 above that (via the Guide to Artificial Intelligence). Shorter context saves real gigabytes, which is why a 24GB card can sometimes squeeze in a model that "shouldn't" fit.

What Fits: The Model-Size VRAM Table

Here is the honest table for Q4_K_M — the quantization almost every local AI user actually runs — including typical context and overhead. Read the "comfortable card" column, not the weights column: the weights alone will mislead you.

Model size	Weights at Q4_K_M	Realistic total (8K context + overhead)	Comfortable card	Example models (2026)
3B	~1.8 GB	~3 GB	Any 8GB+ card	Small chat models, coding assistants
7–8B	~4.9 GB	~7 GB	8GB card minimum; 12GB comfortable	Llama 3.1 8B, Qwen3 8B
14B	~8.6 GB	~11 GB	12GB card	Qwen3 14B
20–24B	~12–14 GB	~15–17 GB	16GB card	Mid-size instruct models
27B	~16–17 GB	~19–21 GB	24GB card (tight on 16GB only with short context/offload)	Qwen3 27B-class, Gemma 3 27B
30–32B	~18–20 GB	~22–24 GB	24GB card	Qwen3 32B, DeepSeek distills
70B	~43 GB	~46 GB+	Dual 24GB GPUs, 48GB+ card, or 64GB+ unified memory	Llama 3.3 70B

Two rows deserve emphasis. The 27B row is the line that divides the market: at roughly 17GB of weights plus cache, it genuinely does not fit on a 16GB card for comfortable use — a point the local-AI site RunAIHome made bluntly when noting that a 27B model at Q4 "doesn't load" within a 16GB ceiling (RunAIHome, September 2026). That is exactly why the rumoured 24GB RTX 5070 Ti Super became the most-wanted card among AI builders. And the 70B row is the line no single consumer card crosses comfortably: 43GB of weights means even a 32GB RTX 5090 needs partial CPU/RAM offload, which meaningfully slows generation (OpenSourcesAI's RTX 5090 review, July 2026).

Mixture-of-experts (MoE) models deserve a footnote: VRAM follows the total parameter count, because every expert must be resident in memory even though only a few activate per token (llmconfigurator.com). An MoE with 30B total parameters but only 3B active still needs ~18GB of VRAM — but it will generate tokens much faster than a dense 30B model, since speed follows the active count.

Image Models Need VRAM Too: Flux, SDXL, and Friends

LLMs are only half the local-AI story. Image generation has its own VRAM ladder, and in 2026 it is dominated by one model family: Flux, from Black Forest Labs, the community standard for quality. The numbers are well documented across current guides:

Image model	Precision	VRAM needed	Works on
Flux.1 Dev (12B params)	FP16	~24 GB	RTX 3090/4090/5090
Flux.1 Dev	FP8	~8–12 GB	RTX 3060 12GB and up, comfortably
Flux.1 Dev	GGUF Q4	~6–7 GB	Even 8GB cards with offloading
Flux.1 Schnell	FP8	~8 GB	8GB cards
Flux 2 Klein 4B	GGUF Q4	~8 GB floor	8GB cards, 4-step generation
SDXL	FP16	~8–12 GB	12GB card runs it cleanly

The key insight: FP8 quantization cuts Flux.1 Dev's VRAM use nearly in half with quality loss that is usually imperceptible in blind tests (Aliteq's Flux guide, updated October 2026), and GGUF Q4 builds — loadable in ComfyUI via the ComfyUI-GGUF plugin, downloadable from Civitai and Hugging Face — squeeze Dev onto roughly 6–7GB. Full precision wants 24GB (Thunder Compute's Flux guide, October 2026; OfflineCreator).

Concrete speeds put this in perspective: on a 12GB RTX 3060, community measurements place a 1024px SDXL image at 20–35 seconds and Flux.1 Dev in FP8 at 60–90 seconds per image (SpecPicks, September 2026). Twelve gigabytes is the threshold where image generation stops feeling cramped: at 8GB every Flux workflow needs aggressive offloading, while 16GB buys you batches, unquantized Flux and ControlNet pipelines (SpecPicks). If image generation is your main workload, a 12GB card is the honest minimum and 16–24GB is the comfort zone.

The Software Stack: Choose Your Tools Before Your Card

Your GPU choice constrains your software, so pick the stack first. The five tools that matter in 2026 are Ollama, LM Studio, llama.cpp, vLLM and ExLlamaV2 — and for images, ComfyUI.

Ollama (ollama.com, verified 3 Nov 2026) is the one-line path: it downloads a Q4_K_M build automatically and starts a chat session, runs on Windows, macOS and Linux, and needs no account. It is the default recommendation for beginners. LM Studio (lmstudio.ai, verified 3 Nov 2026) is the polished GUI alternative — download models in-app, chat, and run its Bionic agent for work and code, powered by MLX and llama.cpp under the hood. llama.cpp (github.com/ggml-org/llama.cpp, verified 3 Nov 2026 — 133,000+ stars, MIT licensed) is the engine underneath both: plain C/C++ with no heavy dependencies, prebuilt binaries for every release, and backends for CUDA, AMD HIP, Apple Metal, Vulkan and Intel SYCL, plus CPU+GPU hybrid inference that partially accelerates models larger than total VRAM.

vLLM (docs.vllm.ai, verified 3 Nov 2026) is the power-user choice: an OpenAI-compatible server with PagedAttention, continuous batching, and tensor/pipeline/expert parallelism across multiple GPUs, supporting NVIDIA and AMD GPUs plus FP8, MXFP4, GPTQ, AWQ and GGUF quantization. Choose it when you want to serve models or split a 70B model across two cards. ExLlamaV2 (github.com/turboderp/exllamav2) is the specialist backend for EXL2-quantized models, popular with tuners chasing maximum speed on NVIDIA cards. For images, ComfyUI (github.com/Comfy-Org/ComfyUI, verified 3 Nov 2026) is the default pipeline: a node-based interface with the best VRAM efficiency, a desktop app for Windows and macOS, portable builds for NVIDIA/AMD/Intel, and native support for Flux, SDXL and quantized GGUF workflows.

One practical note: models come from Hugging Face, which hosts the GGUF quants (look for well-known quant uploaders), and Flux quants also circulate on Civitai. Budget 40–50GB of free disk space for a ComfyUI install plus one Flux checkpoint, its VAE and text encoders (Tech-Insider's ComfyUI tutorial, September 2026). Disk space is the forgotten requirement of local AI — model files are enormous, and a 1TB drive fills faster than you expect.

CUDA vs ROCm vs Metal vs XPU: The Backend Reality in November 2026

Here is the honest state of GPU software for local AI as of November 2026. NVIDIA's CUDA remains the default that everything supports first — every tool above runs best on NVIDIA, every quantization format targets CUDA first, and every tutorial assumes it. If you want the path of least resistance, buy NVIDIA. That is not brand loyalty; it is ecosystem arithmetic.

AMD's ROCm has become genuinely credible — on Linux. ROCm 7.14.0 shipped 15 July 2026 and 7.14.1 on 2 September 2026, alongside the new ROCm Core SDK line (10.0.0 on 26 August, 10.1.0 on 5 October 2026), with ROCm 7.2 bringing official RDNA 4 (RX 9070/9070 XT) support (LocalAIMaster's ROCm setup guide, updated 2 Nov 2026). Ollama, llama.cpp, vLLM, PyTorch, JAX and Triton all ship ROCm builds, and Ollama's supported list covers RX 6800 through RX 9070 series (LocalAIMaster). On Windows, ROCm is much weaker: AMD's own documentation says PyTorch on Windows includes ROCm components but not the full stack — PyTorch-only framework support, no ML training support, and batch-size restrictions on some LLM workloads (KnightLi's ROCm 7.2 guide). A native full Windows installer is still "planned for later in 2026" as of ROCm 10 (TensorRigs' ROCm 10 guide, October 2026). ComfyUI Desktop added official AMD ROCm support from v0.7.0, which makes Windows image generation viable, but for LLMs on AMD, plan on Linux or accept friction. Note also that Ollama's Windows support list covers the RX 7000 series but RX 9000 cards are supported through ROCm on Linux only, per Ollama's docs (BestFreeWebResources' RX 7900 XTX guide, October 2026).

Apple's Metal/MLX path is the smoothest non-NVIDIA experience. llama.cpp treats Apple Silicon as a first-class citizen (Metal backend, verified in its README), LM Studio runs on MLX, and everything "just works" on macOS — the trade-off is speed per gigabyte, since unified memory bandwidth tops out at 614 GB/s on M5 Max versus 1,008 GB/s on an RTX 4090. Intel Arc is the weakest AI option: ComfyUI supports Arc through PyTorch's built-in XPU backend (Aliteq's AMD/Intel guide, October 2026), and llama.cpp ships a SYCL backend for Intel GPUs, but LLM tooling on Arc remains thin — buy Arc for gaming value, not for a primary AI rig.

Operating system summary: NVIDIA works everywhere; AMD wants Linux; Apple needs macOS (obviously); Intel Arc wants patience. WSL2 on Windows is a workable middle ground for NVIDIA users who want Linux-only tools, but VRAM is VRAM — the OS does not change the capacity math.

RTX 5090 32GB: The King You Probably Cannot Afford

The RTX 5090 is the fastest, highest-capacity single consumer GPU for local AI: 32GB of GDDR7 on a 512-bit bus with 1,792 GB/s of bandwidth (GPUSmith's spec analysis), Blackwell architecture with FP4 support, and CUDA everywhere. Its real strength is 32B-class models at high quantization — comfortable, fast, production-quality inference at the highest single-GPU consumer tier (OpenSourcesAI). The problem is price and availability, not performance.

TechSpot's Q4 2026 pricing update (2 November 2026) put the cheapest in-stock RTX 5090 in the US at $9,400 — 370% above its $1,999 launch MSRP, up 36% in a single month — with a normalized global average of about $7,240 (ShiftDelete; ItsCai's summary). Live trackers on 3 November 2026 show minimum prices around $6,118 (DropReference). Worse, on 10 October 2026 Tom's Hardware reported a leaked factory notice saying NVIDIA would stop manufacturing the RTX 5090 and reserve its GB202 chip for professional and datacenter cards — that discontinuation is a rumour, not an announcement: NVIDIA has not confirmed it and maintains the card is still in production (TensorRigs, October 2026; Pasquale Pillitteri).

Two technical caveats for AI builders. First, the RTX 5090 has no NVLink — like the RTX 4090 before it, it is PCIe-only, so two 5090s do not form a single 64GB address space; multi-GPU use needs a tensor-parallel runtime such as vLLM or Ollama/llama.cpp layer-splitting (OpenSourcesAI; GPUSmith). Second, 32GB is still tight for a full 70B model: Llama 3.3 70B at Q4_K_M needs ~41–43GB, so a 5090 runs it only with partial CPU/RAM offload, trading away speed (OpenSourcesAI). Verdict: the dream card at a nightmare price — only worth it if you find one near sane pricing and need maximum single-card capacity today. See NVIDIA's official RTX 5090 page for specifications.

The Used-Market 24GB Kings: RTX 4090 and RTX 3090

For local AI in November 2026, the smart money is on used 24GB cards. Twenty-four gigabytes is the capacity tier where 27B and 32B models — the current sweet spot of open models — run comfortably with room for context, and the used market is the only place to get it at a sane price.

The RTX 3090 (24GB GDDR6X, 936 GB/s, 350W) is the cheapest 24GB on the market. As of 3 November 2026, the median US eBay sold price is $1,471 based on 327 real sold listings over 90 days, with most sales between $1,370 and $1,567 and the 7-day median trending up 6% (PCPrice.watch, refreshed 3 Nov 2026). At that price it is the undisputed VRAM-per-dollar champion: a full 27B model at Q4 with context headroom, Flux.1 Dev at full FP16 precision, and mature CUDA support in every tool. Downsides are real: no warranty, 350W power draw, cards that may have mined cryptocurrency for years, and older Ampere architecture without FP8/FP4 support. Buy from sellers with strong ratings, check completed-listing prices before bidding, and stress-test immediately on arrival (more in the mistakes section).

The RTX 4090 (24GB GDDR6X, 1,008 GB/s, 450W) is the faster, more efficient 24GB option. Used cards recently sold for about $2,300 on eBay with median asking prices around $3,000 (Beam.cloud, November 2026); one tracker measured a $3,093 median on US eBay in the two weeks to 29 October 2026 (Giga Screens). Production wound down in late 2024 and no new supply is coming, so prices rose instead of falling. For AI specifically, the 4090's advantages over the 3090 are meaningful: higher bandwidth (faster token generation), FP8 support, better efficiency, and Ada Lovelace features. If your budget reaches ~$2,500–3,000, a used 4090 is the best 24GB AI card you can buy; if it doesn't, the 3090 at ~$1,470 is the value king.

The 16GB Middle Class: Fast Cards With a Hard Ceiling

Sixteen gigabytes is the awkward middle of the 2026 market: plenty for 14–20B models and every image workload, but a hard wall below the 27B tier. Know the ceiling before you buy.

Card	VRAM / bandwidth	US street price (Oct–Nov 2026)	AI verdict
RTX 5080 16GB	16GB GDDR7, 960 GB/s	$2,200 (TechSpot, 2 Nov 2026); pulled from NVIDIA's US store	Fastest 16GB, but 120% over MSRP — terrible value for AI
RTX 5070 Ti 16GB	16GB GDDR7, 896 GB/s	$1,250 (TechSpot); live min ~$1,009	Good speed, same 16GB ceiling
RTX 5060 Ti 16GB	16GB GDDR7, 448 GB/s	$790 (TechSpot); live min ~$770	Cheapest new 16GB NVIDIA — the sensible mid-range AI pick
RTX 4060 Ti 16GB	16GB GDDR6, 288 GB/s	Street prices fluctuate — check current listings	Older, slower memory; only if discounted below the 5060 Ti
RX 9070 XT 16GB	16GB GDDR6, 640 GB/s	$870 (TechSpot); live min ~$821	Great hardware, but needs Linux for best ROCm experience
RX 7900 XTX 24GB	24GB GDDR6, 960 GB/s	~$1,821 new / ~$1,000 used (17 Oct 2026 tracker)	24GB AMD value — Linux recommended; 167–191 tok/s on 7B in llama.cpp benches

Prices: TechSpot Q4 2026 via ShiftDelete and ItsCai; live minimums via DropReference (3 Nov 2026); 7900 XTX via BestFreeWebResources (17 Oct 2026). The RTX 5080's situation is remarkable: Tom's Hardware reports it was pulled from NVIDIA's US store while the cheapest listing hit $2,199.99 — 2.2× its $999 launch price (Pasquale Pillitteri, November 2026).

The honest summary: 16GB cards are excellent for everything up to ~20B parameters and for all image generation, but they cannot grow into the 27B+ tier. The RTX 5060 Ti 16GB at ~$790 is the rational new-card choice for a mid-range AI build — GDDR7 bandwidth (448 GB/s) gives it meaningfully faster token generation than AMD's 16GB options at this bus width (the RX 9060 XT 16GB manages 322 GB/s). The RX 7900 XTX sneaks into this section as a 24GB card at 16GB-card used pricing (~$1,000), but only for buyers comfortable with Linux and ROCm's quirks — on Windows it is a compromise. And the RTX 4060 Ti 16GB, with its narrow 128-bit GDDR6 bus (288 GB/s), only makes sense at a steep discount under the 5060 Ti; we could not verify a current street price, so check live listings.

Budget Tier: RTX 3060 12GB, and What Else $500 Buys

The RTX 3060 12GB remains the budget local-AI champion in November 2026, five years after launch. Twelve gigabytes runs 8B and 14B models comfortably, handles Flux.1 Dev in FP8 and GGUF quants, and runs SDXL at full precision — the complete starter local-AI experience. Its return to #1 in the October 2026 Steam survey (3.62%, edging the RTX 5070 at 3.56%) reflects both its installed base and continued availability as manufacturers push it while RTX 50 supply stays tight (TweakTown). AI builders have long prized its VRAM-per-dollar, and that logic still holds. We could not verify a current new-unit street price for November 2026 — street prices fluctuate, so check current listings — but it remains far cheaper than any new 16GB card. Our full analysis: The RTX 3060 Is Back — Again.

The Intel Arc B580 (12GB GDDR6, 456 GB/s) looks tempting on paper for the money, but Arc is the weakest AI option in this guide: LLM tooling is thin, with ComfyUI supporting Arc only through PyTorch's XPU backend and llama.cpp's SYCL backend as the main LLM route (Aliteq). Buy it as a gaming card that can dabble in image generation, not as a primary AI rig. The older RTX 3060 12GB used and even the 8GB cards (RTX 3060 Ti, RTX 4060) can run small models — an 8GB card handles a 7–8B model at Q4 with short context — but 8GB is a dead end for growth: Flux needs aggressive offloading and 14B models won't fit. At the budget tier, 12GB is the minimum that still feels like a real local-AI machine.

Apple Silicon: The 128GB Unified-Memory Alternative

Apple plays a different game: instead of VRAM, Macs have unified memory shared between CPU, GPU and Neural Engine — and at the high end, there is simply more of it than any consumer GPU offers. The November 2026 lineup, reshaped by Apple's 28 October 2026 MacBook Pro announcement (Apple Newsroom), looks like this for local AI:

Chip / machine	Memory	Bandwidth	Price (US, Nov 2026)	AI verdict
M5 Pro (MacBook Pro 14")	24–48GB (64GB max)	307 GB/s	From $2,499 (standard display)	14B dense / 20B MoE class
M5 Max 40-core (MacBook Pro)	48/64/128GB	614 GB/s	From $4,499; 128GB config well above	70B at 4-bit measured at 13.1 tok/s
M5 Max (Mac Studio)	48–128GB	614 GB/s	From $2,499; 128GB ~$5,099	Best value for 70B on a desk
M5 Ultra (Mac Studio)	Up to 512GB	Up to 1.2 TB/s	From $5,499; 512GB from $22,299	Runs what no consumer GPU can; workstation money
Mac mini M5 Pro	Up to 64GB	307 GB/s	From $1,699	Cheapest M5 Pro Mac ever

Specs and prices from LocalAIMaster's M5 guide (2 Nov 2026), PromptQuorum (2 Nov 2026) and MacObserver (30 Oct 2026). The headline number: a published review measured a 4-bit Llama 3.3 70B at 13.1 tokens/second on the 128GB M5 Max — slow by datacenter standards, but a 70B model running on a laptop (LocalAIMaster). Note the base 14-inch MacBook Pro is now the M6 chip (up to 32GB, ~170 GB/s) — an 8B-to-14B machine, not a 70B one. Only the 40-core M5 Max takes 128GB; the 32-core version is fixed at 36GB.

The Apple trade-off is simple: unmatched memory capacity and a frictionless software experience (llama.cpp Metal backend, LM Studio on MLX) against lower bandwidth per gigabyte and premium pricing. A Mac Studio M5 Max with 128GB (~$5,099) is arguably the most sensible 70B-capable machine a home user can buy — no dual-GPU complexity, no 1000W PSU, no driver wrangling. But if your models fit in 24GB anyway, a used RTX 3090 system costs a third as much and generates tokens faster.

The Pro Tier, Dual-GPU Setups, and Practical Concerns

Above the consumer stack sits the RTX PRO 6000 Blackwell: 96GB of GDDR7 with ECC, the maximum single-card memory at full bandwidth — at around $15,599, with the 72GB RTX PRO 5000 from $9,209 (TensorRigs, October 2026). This tier is price-prohibitive for home users and we do not recommend it for hobbyists — it exists here so you know the ceiling. Note that even the RTX PRO 6000 does not support NVLink (GPUSmith).

Dual-GPU is the enthusiast's answer to 70B. Two used RTX 3090s give you 48GB — 50% more than an RTX 5090 — for roughly $2,940 at current eBay medians, about half the price of a single 5090 at today's inflated pricing (TensorRigs). Since no consumer card has NVLink, the GPUs communicate over PCIe, and you need a tensor-parallel runtime: vLLM, GPUStack, or Ollama/llama.cpp layer-splitting (OpenSourcesAI). Practical requirements: a motherboard with two full-length PCIe slots (bifurcation to x8/x8 on a PCIe 5.0 slot works), a 1000W+ quality PSU, and a case with serious airflow. Two RTX 5060 Ti 16GB cards (32GB total) are another modern dual-GPU path for ~$1,580 new. Dual-GPU is powerful but complex — only for builders who enjoy tinkering.

Practical concerns nobody mentions until it's too late: power, heat, noise and connectors. A 450W RTX 4090 or 575W RTX 5090 needs a quality 1000W PSU and uses the 12V-2x6 16-pin connector — check your PSU has the native cable or a proper adapter, and seat it fully. These cards are 3–4 slots thick and over 300mm long; measure your case. Under sustained AI loads (unlike bursty gaming), fans run constantly — a blower or liquid-cooled card, or simply an undervolt, makes a home office livable. And remember the used-market rule: budget for the PSU and cooling, not just the card.

One more rumour to handle honestly: leaks suggest a 24GB RTX 5080 could appear around December 2026–January 2027 (ChannelGate via Pasquale Pillitteri), alongside the broader RTX 50 Super refresh rumoured for CES 2027 (BenchLife via VideoCardz, TweakTown). NVIDIA has never announced these cards — treat every date as rumour. The reported cause is the 3GB GDDR7 modules they need, reportedly $60–70 per chip versus ~$20 for 2GB modules, with memory makers prioritizing AI datacenter demand (Tech-Insider; RunAIHome). Our advice, echoing our RTX 50 Super delay coverage: do not pause a purchase for a card with no confirmed price, spec sheet or launch date.

What to Buy by Budget: Five Clear Tiers

Stop comparing specs and pick your tier. Every price below is US, sourced and dated; street prices move weekly in this market, so treat them as orientation and check live listings before buying.

Tier	Budget	Buy	Runs comfortably
Starter	~$250–400	RTX 3060 12GB (new or used)	8B–14B LLMs, Flux FP8/GGUF, SDXL
Mid-range	~$770–900	RTX 5060 Ti 16GB (~$790, TechSpot 2 Nov 2026) or RX 9070 XT 16GB (~$870, Linux)	Up to ~20B LLMs, all image work, batches
Sweet spot	~$1,400–1,600	Used RTX 3090 24GB (~$1,471 median eBay sold, 3 Nov 2026)	27B–32B LLMs, Flux FP16, LoRA experiments
Enthusiast	~$2,300–3,100	Used RTX 4090 24GB (~$2,300 sold / ~$3,000 asking, Nov 2026)	Same capacity as 3090, much faster + FP8
Maximum	~$5,000+	Mac Studio M5 Max 128GB (~$5,099) for 70B simplicity, or dual used RTX 3090s (~$2,940) for 48GB tinkering	70B models at 4-bit

Price sources: TechSpot Q4 2026 via ShiftDelete; PCPrice.watch; Beam.cloud; PromptQuorum. The single best value in local AI right now is the used RTX 3090 at ~$1,470 — 24GB under warranty-free but under half the cost-per-gigabyte of anything new. The single best beginner buy is the RTX 3060 12GB. The single most sensible 70B machine is the Mac Studio M5 Max 128GB.

Seven Mistakes That Waste Your Money on an AI GPU

1. Buying an 8GB card "for AI" in 2026. An 8GB card runs a 7–8B model today and nothing bigger tomorrow. The $100–150 saved versus a 12GB card buys you a dead end. Twelve gigabytes is the minimum; sixteen is the comfort zone.

2. Forgetting the KV cache and context. The model file is not the total. A 27B model at "17GB" needs ~20GB with context and overhead — which is why it doesn't fit on a 16GB card. Always add 30–50% headroom to the weights number.

3. Buying AMD for Windows-only AI use. ROCm on Windows is PyTorch-components only, with no training support and batch-size restrictions (KnightLi). If you won't run Linux, buy NVIDIA or Apple.

4. Assuming two GPUs pool their memory like one. No consumer NVIDIA card has NVLink — not the 4090, not the 5090, not even the RTX PRO 6000 (GPUSmith). Two 24GB cards give you 48GB only through tensor-parallel software (vLLM, Ollama/llama.cpp splitting), never as a single address space.

5. Waiting for the RTX 50 Super cards. They are rumoured for CES 2027, unannounced by NVIDIA, with no confirmed price or date (TweakTown). Waiting means months without a machine for a card that may not arrive on schedule.

6. Paying scalper prices for the 5090. At $6,100–9,400, the 5090 costs 3–4.7× its $1,999 MSRP (TechSpot, 2 Nov 2026). Two used 3090s give you 48GB for ~$2,940. Never pay panic pricing.

7. Buying a used mining card blind. Check the seller's ratings and return policy, compare against completed eBay sold listings (not asking prices), avoid listings "for parts," and stress-test with a long inference run the day it arrives — VRAM faults show up as crashes under sustained load, not in a 30-second benchmark.

Frequently Asked Questions

How much VRAM do I need to run AI locally?

Use the formula: parameters in billions × bits per weight ÷ 8, plus 30–50% for cache and overhead. At the standard Q4_K_M quantization (~4.9 bits/weight), that means ~7GB for an 8B model, ~20GB for a 27B model, and ~46GB+ for a 70B model. For image generation, 12GB is the practical minimum for Flux, 24GB for full-precision comfort.

Is 12GB of VRAM enough for local AI?

Yes — 12GB is the sweet minimum. It comfortably runs 8B and 14B language models, Flux.1 Dev in FP8 or GGUF quantization, and SDXL at full precision. You cannot run 27B+ language models on 12GB, but for chat, coding assistance and image generation, 12GB (RTX 3060 12GB and similar) is a genuine local-AI machine.

Can I run a 70B model on a 32GB RTX 5090?

Only with compromises. A 70B model at Q4_K_M needs ~43GB for weights alone, so 32GB requires partial offload to system RAM, which meaningfully slows generation (OpenSourcesAI). For comfortable 70B inference you need dual 24GB GPUs, a 48GB+ card, or 64GB+ of Apple unified memory.

AMD or NVIDIA for local AI?

NVIDIA for the easiest experience, AMD for value if you run Linux. CUDA is supported first by every tool; ROCm is genuinely credible on Linux in 2026 (ROCm 7.14/10.1) but limited on Windows. An RX 7900 XTX at ~$1,000 used is excellent 24GB value — on Linux.

Can I combine two GPUs to get more VRAM?

Yes, but not as one pool. Consumer cards lack NVLink, so memory doesn't merge into a single address space. Instead, tensor-parallel runtimes (vLLM, GPUStack, OllMakers/llama.cpp layer-splitting) split the model across cards over PCIe. Two 24GB cards effectively run 70B-class models.

Do more CUDA cores make AI faster?

Only if VRAM is equal — capacity first, bandwidth second, cores third. Token generation is memory-bandwidth bound: speed ≈ bandwidth ÷ model size. A 24GB card with modest cores beats a 12GB card with more cores for any model that needs the memory.

Is the RTX 3060 12GB still worth buying in November 2026?

Yes, as a budget AI card. It's the cheapest way to get 12GB, runs the full starter workload (8B–14B LLMs, Flux, SDXL), and remains widely available — it reclaimed #1 in the October 2026 Steam survey. See our RTX 3060 comeback analysis for the full story.

Should I wait for the RTX 50 Super cards?

No — buy for today's needs. The Super refresh (rumoured 12–24GB models) is unannounced by NVIDIA, with leaks pointing to CES 2027 and the delay reportedly caused by expensive 3GB GDDR7 modules. Details in our RTX 50 Super delay article. Never wait on rumoured hardware.

Mac or PC for local AI?

PC with NVIDIA for maximum flexibility and value; Mac for maximum memory simplicity. A used-RTX-3090 PC (~$1,470 for the card) is far cheaper than any 70B-capable Mac, but a Mac Studio M5 Max 128GB (~$5,099) runs 70B models with zero multi-GPU complexity. If your models fit in 24GB, the PC wins on price; if you need 70B+, the Mac is the simpler machine.

Used or new GPU for local AI?

Used, for 24GB cards; new, for 12–16GB cards. Used RTX 3090s (~$1,471) and 4090s (~$2,300) are the only sane path to 24GB in 2026's inflated market. For 12–16GB, new cards (RTX 3060 12GB, RTX 5060 Ti 16GB ~$790) carry warranties and current architectures. Always verify used prices against eBay sold listings, not asking prices.

Conclusion

The best GPU for running AI locally in November 2026 is the one with the most VRAM your budget allows, on a software stack you will actually use. The market is distorted — $9,400 RTX 5090s, a rumoured-then-delayed Super refresh, memory prices climbing into 2027 — but the physics hasn't changed: parameters × bits ÷ 8, plus cache, decides everything. A used RTX 3090 at ~$1,470 remains the value king of local AI. The RTX 3060 12GB remains the budget champion. The RTX 5060 Ti 16GB is the sensible new mid-range buy. Apple's 128GB unified memory is the elegant answer to 70B. Pick your tier, check a live price, verify the card fits your case and PSU, and start with Ollama — you'll be chatting with a local model within the hour. The cloud can wait.

Sources

VRAM requirements and quantization: llmconfigurator.com — How Much VRAM for Local LLMs? (Oct 2026); Guide to Artificial Intelligence — VRAM calculator; Pasquale Pillitteri — Quantization explained; ByteRiderX — What Q4_K_M actually costs; LocalAIMaster — Llama 3.1 8B VRAM guide. Software: Ollama; LM Studio; llama.cpp; vLLM docs; ExLlamaV2; ComfyUI (all verified 3 Nov 2026). Image models: Aliteq — How to Run Flux Locally (Oct 2026); Thunder Compute — Flux ComfyUI Guide (Oct 2026); SpecPicks — ComfyUI on RTX 3060 12GB (Sep 2026); OfflineCreator — Run Flux on a local GPU. AMD/ROCm: LocalAIMaster — AMD ROCm local LLM setup (2 Nov 2026); KnightLi — ROCm 7.2 ComfyUI guide; TensorRigs — ROCm 10 guide (Oct 2026); Aliteq — Stable Diffusion on AMD and Intel Arc (Oct 2026); BestFreeWebResources — RX 7900 XTX for Local AI (Oct 2026). RTX 5090 and multi-GPU: GPUSmith — RTX 5090 specs and limits; OpenSourcesAI — RTX 5090 for Local LLMs (Jul 2026); TensorRigs — RTX 5090 discontinuation report (Oct 2026). RTX 50 Super delay (rumour): TweakTown; Tech-Insider; RunAIHome (Sep 2026). Prices: ShiftDelete — TechSpot Q4 2026 pricing (2 Nov 2026); ItsCai — GPU prices Q4 2026; DropReference — live US GPU prices (3 Nov 2026); PC Server and Parts — Tom's Hardware price index analysis (Oct 2026); PCPrice.watch — used RTX 3090 eBay prices (3 Nov 2026); Beam.cloud — RTX 4090 prices (Nov 2026); Giga Screens — RTX 4090 build guide (Oct 2026); Pasquale Pillitteri — Radeon price hike report (Nov 2026). Steam survey: TweakTown — October 2026 Steam survey; Hardware Busters — survey analysis (2 Nov 2026). Apple Silicon: Apple Newsroom — MacBook Pro announcement (28 Oct 2026); LocalAIMaster — Apple M5 for Local AI (2 Nov 2026); PromptQuorum — M5 memory bandwidth guide (2 Nov 2026); MacObserver (30 Oct 2026). Model hubs: Hugging Face; Civitai. Internal: NVIDIA RTX 50 Super Delayed to CES 2027; The RTX 3060 Is Back — Again.