gpt-oss 20B: RTX 3060 12GB vs Ryzen 5 5600G CPU-Only (2026)

Why a mixture-of-experts model changes the usual GPU-or-bust answer

For most of the local-LLM era, "can my CPU run this?" had a short answer for anything above 7B: technically yes, practically no. A dense 13B model reads every one of its weights for every token it generates, and a desktop with dual-channel DDR4 simply cannot stream that many bytes fast enough to feel interactive.

gpt-oss 20B breaks that rule. OpenAI built it as a sparse mixture-of-experts (MoE) model: 20.9B total parameters, of which 3.6B are active for any given token, spread across 24 layers (OpenAI — gpt-oss-120b & gpt-oss-20b model card). Each layer holds 32 experts and a router picks 4 of them per token, per the model's config.json. OpenAI also shipped the expert weights — more than 90% of the parameter count — already quantized to MXFP4 at 4.25 bits per parameter, which is why the model card says it will "run within 16GB of memory." OpenAI released both gpt-oss models as open weights alongside its launch announcement.

That combination puts two groups of readers in front of the same decision. The first already owns an APU box — a Ryzen 5 5600G media PC, homelab node or retired office build — and wants to know whether adding RAM is enough. The second is weighing a used 12 GB card at roughly $295 (getpcparts — used RTX 3060 prices) against spending nothing at all. This synthesis compares the two paths using published llama.cpp measurements, and flags every place where no direct measurement exists.

The short version: the APU path works, and it is more usable than the dense-model intuition suggests. The GPU path is several times faster at generation and more than an order of magnitude faster at reading long prompts, and on this model a 12 GB card is enough.

Key takeaways

• The whole model is about 12 GB at any quant. Unsloth's GGUF files run from 11.47 GB (Q2_K) to 13.79 GB (F16) (Unsloth — gpt-oss-20b-GGUF), because the experts are natively MXFP4.
• A 12 GB RTX 3060 runs it almost entirely in VRAM. Keeping just two layers' experts on the CPU gives 64 tok/s at 16K context in the llama.cpp guide thread; with a 2,048-token context and nothing offloaded, the same poster reports 75 tok/s.
• The APU path lands in the teens. A Ryzen 5 5600H with Vega 7 graphics and dual-channel DDR4-3200 reports 14.05 tok/s generation and 114.91 tok/s prompt processing under Vulkan in the same thread.
• Prompt processing is the real gap. An RTX 3060 llama-bench run in that thread reports 2,229.95 tok/s at pp2048, roughly 19 times the APU's prefill rate.
• The KV cache is tiny. Half the layers use a 128-token window (OpenAI model card), which works out to roughly 0.8 GB at 32K context.

Step 0: total parameters vs active parameters

Before any hardware talk, separate two numbers that usually move together and, on this model, do not.

Total parameters decide capacity. Every weight has to be resident somewhere fast — VRAM or system RAM — because the router may pick any expert for the next token. That is why the file is still about 12 GB and why "just use a smaller quant" does not rescue a machine with 8 GB of memory.

Active parameters decide speed. Generation is limited by how many bytes the hardware must read per token, not by how many bytes are stored. The model card's Table 1 lists 3.61B active parameters out of 20.91B total (OpenAI model card). The MXFP4 GGUF packs 20.91B parameters into 11.27 GiB, per the llama-bench output in the guide thread, which averages about 4.6 bits per parameter.

Put those together and each token reads roughly 2.1 GB of weights. That is arithmetic from the cited inputs, not a measurement. A dense 12B model at the same precision would read about 7 GB per token. The mixture-of-experts design cuts per-token memory traffic by more than two-thirds while keeping the storage cost of a 20B model — exactly the trade that favors a machine with plenty of slow memory.

The practical rule that falls out of this:

Spec delta: RTX 3060 12GB vs Ryzen 5 5600G

NVIDIA lists the RTX 3060 at 12 GB of GDDR6 on a 192-bit bus, 170 W of graphics card power and a 550 W system requirement (NVIDIA — RTX 3060 family). The RTX 30-series reference table gives 360 GB/s and the $329 launch price (Wikipedia — GeForce RTX 30 series); TechPowerUp's database carries the same GA106 configuration (TechPowerUp — RTX 3060 12 GB).

AMD lists the Ryzen 5 5600G with 6 cores and 12 threads, 2 memory channels at up to 3,200 MT/s, a 65 W default TDP, PCIe 3.0, and Radeon graphics with 7 cores at 1,900 MHz (AMD — Ryzen 5 5600G specifications). Tom's Hardware's review gives the $259 launch price (Tom's Hardware — Ryzen 5 5600G review). A DDR4-3200 module moves 25.6 GB/s (Wikipedia — DDR4 SDRAM), so two channels give 51.2 GB/s in theory. The 5800X row uses AMD's own page, which lists 105 W, PCIe 4.0 and "Discrete Graphics Card Required" (AMD — Ryzen 7 5800X).

The column that matters is bandwidth: the RTX 3060 has seven times the memory bandwidth of the 5600G's entire memory system, and the APU's CPU cores and integrated graphics share that 51.2 GB/s.

VRAM and quantization requirements

This table is the part that surprises people. The file sizes barely move across quant levels, because the expert weights were already 4.25-bit before anyone requantized them.

Sizes are from the Unsloth and ggml-org GGUF repositories. The "fits whole" column follows the llama.cpp guide thread: one RTX 3060 owner notes that 378 MB of the card's 12,288 MB is reserved by the Linux driver, and the full model on the GPU is reported only with a 2,048-token context. For anything longer, you move a couple of layers' experts to system RAM — covered below.

For the CPU-only path, 16 GB of system RAM technically holds the file, but the operating system, browser and KV cache push it past comfort. 32 GB is the sensible floor; 64 GB is headroom for other services.

Benchmark table: tokens per second

No published source measures gpt-oss 20B CPU-only on a desktop Ryzen 5 5600G. The table collects the closest published measurements, labelled by exactly what was run, so you can place both paths between them. Prompt-processing and generation figures are kept in separate columns.

How to read it for the two builds in this comparison:

• RTX 3060 12GB in a 5600G box. The four RTX 3060 rows come from Zen 3 desktops with DDR4, which is the same class of host as a 5600G. Expect 60–75 tok/s depending on context length and how many layers' experts you park on the CPU. The one-thread llama-bench row is the floor; it is what happens when the CPU side is starved.
• Ryzen 5 5600G without a GPU. The 5600H row is the closest analog. It is the mobile version of the same Cezanne die with the same 7 graphics cores, running on the same DDR4-3200, but capped at 35 W. A desktop 5600G has more power budget but not more memory bandwidth, so plan on the low-to-mid teens of tok/s on its integrated graphics. That is an estimate from the analog, not a measurement.
• Why the 7950X row is a ceiling, not a target. It is a 16-core Zen 4 chip with AVX-512 and, almost certainly, DDR5; the page does not state the memory. Six Zen 3 cores on DDR4 will generate more slowly and process prompts much more slowly.

A common misquote belongs here: the widely repeated "60 tok/s on a Ryzen 7 5700X with DDR4" is not a CPU-only result. It is the RTX 3060 run in the fourth row.

Why partial offload is the interesting case here

llama.cpp exposes MoE offload directly. --cpu-moe keeps all expert weights in system RAM, and --n-cpu-moe N keeps the experts of the first N layers there (llama.cpp PR #15077). Everything else — attention, the router, embeddings and the remaining experts — stays on the GPU.

The arithmetic explains why this works so well on a 12 GB card. The model card lists 19.12B MLP parameters across 24 layers (OpenAI model card), about 0.8B per layer, or roughly 0.42 GB per layer at 4.25 bits. Moving two layers' experts to the CPU frees about 0.85 GB of VRAM, enough for a 16K context and compute buffers. Each token still consults only 4 of those layers' 32 experts, so the CPU side reads only about 0.1 GB per token for those two layers. At DDR4 speeds that costs a couple of milliseconds, which matches the modest drop from 75 to 64 tok/s in the table. These figures are derived from the cited parameter counts, not measured.

The curve flattens, then falls. Each additional layer you move adds about the same DDR4 traffic, so speed declines steadily as N rises; move all 24 and you arrive at the ~20 tok/s the RX 7900 XT owner reported with -cmoe on dual-channel DDR4-3200. The llama.cpp guide's own advice for an 8 GB card is --n-cpu-moe 22 for full context and 16 for 32K context. For a 12 GB RTX 3060, start at 2, raise it only if the model fails to load at your chosen context, and stop at the smallest value that fits.

One host-side detail helps the 5600G build specifically: plug the monitor into the motherboard so the APU's integrated graphics drives the desktop. That leaves the RTX 3060's full 12 GB for the model instead of sharing it with the compositor. The 5600G's PCIe 3.0 link to the card slows the initial model load, but once weights are resident, generation barely touches the bus.

Prefill vs generation on an APU

Every request runs in two phases. Prefill reads your whole prompt at once; it is a large matrix-multiply job, compute-bound, and it is where a discrete GPU pulls away. Generation produces one token at a time and is bound by memory bandwidth.

On generation, the APU's position is respectable. Its ceiling is set by the same 51.2 GB/s whether the CPU cores or the integrated graphics do the work, and the 5600H analog lands at 14–15 tok/s. For short chat turns, that reads faster than most people type.

Prefill is where the APU hurts. The RTX 3060's llama-bench row processes a prompt at 2,229.95 tok/s; the Vega 7 analog manages 114.91 tok/s. Paste a 4,000-token document and the GPU starts answering in under two seconds; the APU takes about 35 seconds before the first word appears. Retrieval-augmented setups, coding assistants reading whole files, and long-running chats all pay that penalty on every turn.

Does the integrated Vega graphics help at all under Vulkan? For prefill, yes, and it is worth enabling. The 5600H's iGPU processed prompts at 114.91 tok/s. The 16-core 7950X managed 143.07 tok/s CPU-only, and a six-core Zen 3 part has well under half of that chip's compute. For generation, the iGPU mostly relocates the work rather than accelerating it, because it drinks from the same two DDR4 channels as the cores. The thielj report ran every layer on the iGPU (-ngl 100) from 64 GB of shared DDR4, so capacity is not the obstacle on a well-equipped box.

Context length and the KV cache

gpt-oss 20B's attention layers alternate between a banded window and fully dense attention, "where the bandwidth is 128 tokens," with 8 key-value heads of dimension 64 (OpenAI model card). The config.json lists 12 sliding and 12 full-attention layers. Only the full-attention layers grow with context, which works out to about 24 KB per token at 16-bit precision; the sliding layers add a fixed 3 MB or so. The figures below are arithmetic from those inputs.

Two practical notes follow. First, on this model the compute buffers matter more than the cache: the second RTX 3060 owner in the guide thread had to drop the micro-batch (-ub) to 512 to free about 300 MB at 32K. Second, KV-cache quantization is rarely worth it here, because the cache is already small — and on at least one runtime build it backfired badly. An Ollama issue on two RTX 3060s running Gemma 3 12B reported 29.9 tok/s with an f16 cache and 5.5 tok/s with q8_0 or q4_0. Benchmark before and after if you try it.

On the CPU-only path, context costs RAM rather than VRAM, and at 3.2 GB even the full 131K window fits comfortably in 32 GB.

Performance per dollar and per watt

These rows combine cited prices and rated power with the published speeds above. Treat them as a guide, not a measurement.

The efficiency column is closer than the speed column. The 5600H analog produced its 14.05 tok/s under a 35 W package cap, about 0.40 tok/s per watt — on par with the RTX 3060's rated figure. The GPU wins on speed per dollar and on responsiveness; it does not win on energy per token by much.

Running cost is modest either way. US residential electricity averaged 18.34 ¢/kWh in June 2026 (EIA — Electric Power Monthly, Table 5.6.A). Worst case, the RTX 3060 at its full 170 W for eight hours a day uses about 496 kWh a year, roughly $91; a 5600G at 65 W for the same hours uses about 190 kWh, roughly $35. For a 24/7 assistant box, idle draw dominates, and that varies too much by motherboard and power supply to quote — measure at the wall with a plug-in meter before committing.

What to buy: the two builds, part by part

The GPU path (recommended). Either 12 GB card below does the job; the choice is about cooling and case fit. Confirm "12GB" in the listing, because an 8 GB RTX 3060 on a narrower bus also exists.

• ZOTAC Gaming GeForce RTX 3060 Twin Edge OC 12GB — compact two-fan card, the default pick for most mid-tower cases. Check current price on Amazon.
• MSI GeForce RTX 3060 Ventus 2X 12G — the same GA106 chip and 12 GB, a like-for-like alternative when it is cheaper. Check current price on Amazon.

The APU path. The AMD Ryzen 5 5600G is the host for both builds: it runs gpt-oss 20B on its own today, it drives the display so a future GPU keeps its full VRAM, and it ships with AMD's Wraith Stealth cooler. Pair it with 32 GB of DDR4-3200 as two matched sticks. Check current price on Amazon.

The step-up CPU. The AMD Ryzen 7 5800X adds two cores and PCIe 4.0, which helps CPU-side prefill and model loading. It does not raise the dual-channel DDR4 ceiling on generation, and AMD notes it requires a discrete graphics card, so it only makes sense paired with the RTX 3060. Check current price on Amazon.

Model library. The Crucial BX500 1TB reads at up to 540 MB/s with 360 TB of rated endurance (Crucial — BX500 product flyer). At that rate the 12.11 GB file loads in under half a minute, and 1 TB holds dozens of models. Once weights are in memory, the SSD is idle, so a faster drive changes load time only.

Prices change frequently; the retailer page at the time of your visit is authoritative, and the price may vary from any figure quoted here. As an Amazon Associate, SpecPicks earns from qualifying purchases.

Common pitfalls

• Populating one DIMM. A single stick halves memory bandwidth, and bandwidth is the whole game on the APU path. In a llama.cpp CPU performance discussion, one user went from 1.5 to 4 tok/s on a 34B model just by replacing one stick with two.
• Expecting a smaller quant to fit in 12 GB of VRAM. Q2_K is still 11.47 GB. Use --n-cpu-moe instead.
• Letting the RTX 3060 drive the desktop. On a 5600G host, use the motherboard's display output and keep the card headless.
• Oversized micro-batches at long context. Start at -ub 512 when you run 32K on a 12 GB card.
• Quoting the GPU number as a CPU number. The 60 tok/s DDR4 figure is an RTX 3060 result.
• RAM running below its rated speed. Check that XMP/DOCP is enabled; a kit that fell back to JEDEC defaults costs generation speed in proportion to lost bandwidth.

Verdict matrix

Buy the RTX 3060 12GB if…

• you paste documents, code or retrieved context and want the first token in seconds, not half a minute;
• you want 60–75 tok/s generation for interactive chat or coding assistance;
• you already have a Zen 3 host with a free x16 slot and a 550 W power supply.

Stay on the 5600G if…

• your use is short chat turns where 14–15 tok/s reads faster than you type;
• the box runs overnight batch jobs where prompt latency does not matter;
• you can add RAM to reach 32 GB in two matched sticks, but cannot justify another $295 yet.

Skip both if…

• your real target is gpt-oss 120B, which needs 64 GB of system RAM even with a GPU (see the gpt-oss 120B build comparison);
• you use a model a few times a month, where hosted API calls cost less than any hardware;
• your box has 16 GB of RAM and no upgrade path, which leaves no headroom for the 12 GB model plus an operating system.

Bottom line

Buy the used RTX 3060 12GB and put it in the 5600G box rather than choosing between them. Run the native MXFP4 GGUF in llama.cpp with --n-cpu-moe 2 at 16K context, and drive the display from the APU. That combination matches the published 64 tok/s configuration, processes prompts at GPU speed, and costs about $295 on top of hardware you already own. The single condition that flips it: if your prompts are short and your budget is zero, the 5600G alone runs gpt-oss 20B at an estimated 14–15 tok/s, and adding a second stick of RAM is the only upgrade you need.

Live price comparison

• ZOTAC RTX 3060 Twin Edge OC 12GB vs MSI RTX 3060 Ventus 2X 12G — live prices and specs
• Ryzen 5 5600G vs Ryzen 7 5800X — live prices and specs
• RTX 3060 benchmark data · Ryzen 5 5600G benchmark data

Related guides

• gpt-oss 20B vs Phi-4 14B on a 12 GB GPU
• Best hardware for running MoE LLMs locally
• Best GPU for Qwen3 30B-A3B
• Best parts for a CPU-offload local LLM build
• RTX 3060 12 GB for local LLMs

Citations and sources

• OpenAI — gpt-oss-20b model card (Hugging Face) — 21B total / 3.6B active parameters; MXFP4 MoE weights; "run within 16GB of memory" (accessed 2026-09-11)
• OpenAI — gpt-oss-120b & gpt-oss-20b model card (arXiv) — 24 layers; 20.91B total / 3.61B active; 19.12B MLP parameters; 12.8 GiB checkpoint; 4.25-bit MXFP4; 128-token banded attention; 8 KV heads of dimension 64 (accessed 2026-09-11)
• OpenAI — gpt-oss-20b config.json — 32 experts, 4 per token; 12 sliding and 12 full-attention layers; 131,072-token context (accessed 2026-09-11)
• OpenAI — Introducing gpt-oss — launch announcement for the open-weight models (accessed 2026-09-11)
• ggml-org — gpt-oss-20b-GGUF — 12.11 GB MXFP4 GGUF (accessed 2026-09-11)
• Unsloth — gpt-oss-20b-GGUF — Q2_K 11.47 GB through F16 13.79 GB (accessed 2026-09-11)
• llama.cpp — guide: running gpt-oss with llama.cpp — RTX 3060 runs at 75, 64, 56 and 60 tok/s; llama-bench pp2048 2,229.95 / tg128 30.64; Ryzen 5 5600H Vega 7 Vulkan pp512 114.91 / tg128 14.05; -cmoe on DDR4-3200 ~20 tok/s; --n-cpu-moe guidance (accessed 2026-09-11)
• llama.cpp PR #15077 — --n-cpu-moe N keeps the first N layers' MoE weights on the CPU (accessed 2026-09-11)
• ik_llama.cpp discussion #758 — Ryzen 9 7950X CPU-only mainline llama.cpp: 143.07 tok/s prefill, 21.70 tok/s generation (accessed 2026-09-11)
• NVIDIA — RTX 3060 family specifications — 12 GB GDDR6, 192-bit, 170 W, 550 W system power (accessed 2026-09-11)
• Wikipedia — GeForce RTX 30 series — 360 GB/s bandwidth, $329 launch price (accessed 2026-09-11)
• TechPowerUp — GeForce RTX 3060 12 GB — GA106 configuration (accessed 2026-09-11)
• AMD — Ryzen 5 5600G specifications — 6C/12T, 65 W, 2 memory channels, DDR4-3200, PCIe 3.0, 7 graphics cores at 1,900 MHz (accessed 2026-09-11)
• AMD — Ryzen 7 5800X — 8C/16T, 105 W, PCIe 4.0, discrete graphics card required (accessed 2026-09-11)
• Tom's Hardware — Ryzen 5 5600G review — $259 launch price (accessed 2026-09-11)
• Wikipedia — DDR4 SDRAM — 25.6 GB/s per DDR4-3200 module (accessed 2026-09-11)
• getpcparts — used RTX 3060 prices — about $295 from eBay sold listings through September 5, 2026 (accessed 2026-09-11)
• llama.cpp — CPU performance discussion — one DIMM to two raised a 34B model from 1.5 to 4 tok/s (accessed 2026-09-11)
• Ollama issue #11949 — quantized KV cache dropped Gemma 3 12B from 29.9 to 5.5 tok/s on two RTX 3060s (accessed 2026-09-11)
• EIA — Electric Power Monthly, Table 5.6.A — 18.34 ¢/kWh US residential, June 2026 (accessed 2026-09-11)
• Crucial — BX500 product flyer — 1 TB: 540 MB/s read, 360 TB endurance (accessed 2026-09-11)

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