Yes — a Ryzen 5 5600G can run local LLMs without a discrete GPU. With 16 GB of dual-channel DDR4 and a quantized 7B–8B model at q4_K_M, you get usable single-digit to low-teens tokens per second via llama.cpp or Ollama, running entirely on the CPU or with light Vulkan offload to the Vega iGPU. It is not fast, but as of 2026 it is genuinely usable for chat, drafting, and short assistant tasks on a budget desktop.
The no-GPU budget AI builder
Every week another wave of "run a local LLM" tutorials assumes you already own an RTX card with 12 GB or more of VRAM. That's not where most desktops start. The AMD Ryzen 5 5600G is the classic budget path: a six-core, twelve-thread Zen 3 APU with integrated Vega 7 graphics, a 65-watt TDP, and a launch price that has since dropped well below $200. It ships with usable graphics, so a builder can skip a discrete GPU entirely and still have a working desktop. The obvious question in 2026 is whether that same rig can also run a language model without buying a card.
The short answer is yes, with heavy caveats. The APU has no dedicated VRAM — everything runs against system memory bandwidth, which on DDR4-3200 tops out around 51 GB/s. Modern GPUs like a 12 GB RTX 3060 push 360 GB/s over GDDR6, and that number is why discrete GPUs win at token generation. But token generation on CPU is bandwidth-bound in the same way, and Zen 3's AVX2 vectorization plus llama.cpp's aggressive quantization make it viable for the size class most home users actually want to run. This guide walks the realistic performance envelope on the 5600G, when to add RAM, when the iGPU actually helps, and the point at which the smart move is to give up and buy a used 12 GB RTX 3060.
Key takeaways
- The 5600G can host 7B–8B models at q4_K_M in 16 GB of RAM at usable single-digit-to-low-teens tok/s CPU-only.
- 13B-class models want 32 GB of RAM and drop to low-single-digit tok/s.
- The Vega 7 iGPU helps prefill more than generation; the DDR4 bandwidth ceiling is the real bottleneck.
- q4_K_M is the practical sweet spot; q2 hurts quality noticeably, fp16 is a waste on CPU.
- Once you want reading-speed generation on 12B+ models, a used RTX 3060 12GB is the cheapest meaningful step up.
How fast is CPU-only inference on the Ryzen 5 5600G?
Real-world numbers from public llama.cpp threads and reproducible builds on Zen 3 six-core parts put CPU-only generation for 4-bit models roughly in these bands:
| Model size (q4_K_M) | RAM footprint | Generation tok/s (5600G, 6c/12t) | Feel |
|---|---|---|---|
| 3B (Phi-3-mini class) | ~2.5 GB | 14–20 | Fast enough for chat |
| 7B (Llama-3.1 8B class) | ~5.5 GB | 6–11 | Usable, slower than reading |
| 8B (Llama-3.1 8B) | ~6.0 GB | 5–9 | Usable |
| 13B | ~9–10 GB | 3–5 | Batch jobs only |
| 32B (offload) | ~20 GB | <1 | Not practical |
These are ballpark figures from the ggml-org/llama.cpp issue tracker and mirror what Phoronix's Ryzen 5600G review shows for AVX2 workloads on the part — the 5600G is a very capable six-core CPU for the money, and llama.cpp's quantized kernels use that horsepower well. The takeaway: 7B at q4 is where the APU shines, 13B is where you start counting seconds between tokens, and anything above that is only interesting for overnight batch jobs.
Does the 5600G's Vega iGPU help with llama.cpp/Vulkan offload?
The Vega 7 integrated graphics on the 5600G can accept a Vulkan backend from llama.cpp, but the practical uplift for generation is small. The reason is architectural: the iGPU shares the same DDR4 memory pool as the CPU, so both are pulling from a ~51 GB/s bandwidth pipe. Token generation is dominated by streaming weights through that pipe once per token, and no amount of GPU compute helps when the bottleneck is memory bandwidth.
Prefill — the initial pass through the prompt tokens — is compute-heavy rather than pure bandwidth. Here the iGPU can genuinely shave a few seconds off long-context ingestion, which matters for retrieval-augmented workflows or long system prompts. For interactive chat with short prompts, the difference between CPU-only and Vulkan-iGPU on the 5600G is inside the noise for most users. If you enable it, use it, but don't buy the 5600G expecting the iGPU to double your tok/s. It won't.
How much system RAM do you need for 7B/8B/13B on an APU?
- 8 GB — not enough. The OS and browser will fight the model for memory. Ignore.
- 16 GB — the practical floor. A 7B–8B q4_K_M model uses ~6 GB, leaving room for the OS, a browser, and a 4K–8K context. Populate as 2×8 dual-channel; single-channel populates murder bandwidth on an APU.
- 32 GB — the sweet spot. Comfortable headroom for 13B q4 models, longer context windows, or keeping a second smaller model resident for embedding tasks. If you're buying RAM new, go here.
- 64 GB — only useful if you plan CPU offload for 30B+ models. On an APU with no VRAM, the DDR4 bandwidth ceiling makes those experiments academic.
A high-capacity Crucial BX500 1TB SATA SSD helps too — model files are big (2–8 GB each for a well-quantized 7B), and cold-loading from a slow drive dominates first-response latency more than most users realize. NVMe like the WD Blue SN550 1TB is faster still and matters if you're rotating through many model files.
What quantization makes the most sense without a discrete GPU?
For a 5600G with 16 GB RAM, q4_K_M is the practical sweet spot. It roughly halves memory versus q8, keeps quality loss small for chat, and the K-quant kernels vectorize well on AVX2. The ladder:
- q2_K — smallest, but quality drops off a cliff for reasoning and code. Only use if a specific model otherwise won't fit.
- q3_K_M — modest quality loss, useful for squeezing 13B into 16 GB.
- q4_K_M — the default. Balanced quality and speed.
- q5_K_M — slightly better quality, ~20% more RAM.
- q6_K — near-fp16 quality, ~50% more RAM than q4.
- q8_0 — negligible quality loss vs fp16, twice the memory of q4. Not a good CPU trade.
- fp16 — do not run this on CPU. You double memory pressure with zero speed benefit.
When should you just add an RTX 3060 12GB instead?
Once you want reading-speed generation on models above 8B, or you're running agent loops with dozens of tool calls per session, the APU stops being fun. A used ZOTAC RTX 3060 12GB is the cheapest meaningful step: 12 GB of GDDR6 at 360 GB/s completely changes the token generation math. Expect several times the tok/s on the same models, room for 13B fully in VRAM, and a viable path to 32B with partial CPU offload.
The AM4 platform makes the upgrade cheap: keep the 5600G, add the 3060, done. If you eventually want more CPU headroom too, the Ryzen 7 5800X is a straight drop-in for the same socket, giving you 8 cores of Zen 3 with a bump in single-thread performance for the prefill and embedding paths.
Spec table: 5600G vs Ryzen 7 5800X
| Spec | Ryzen 5 5600G | Ryzen 7 5800X |
|---|---|---|
| Cores / threads | 6 / 12 | 8 / 16 |
| Base / boost clock | 3.9 / 4.4 GHz | 3.8 / 4.7 GHz |
| L3 cache | 16 MB | 32 MB |
| Integrated GPU | Vega 7 (7 CUs) | None |
| Memory support | DDR4-3200 | DDR4-3200 |
| TDP | 65 W | 105 W |
| PCIe | Gen 3 x16 | Gen 4 x16 |
The 5800X is the better raw-CPU performer — more cores, bigger L3, higher boost — but for a build that will pair with a discrete GPU eventually, the 5600G's iGPU is the value story. You start with a working desktop for less money, add the discrete GPU when your workload demands it, and swap CPUs later if the CPU becomes the bottleneck.
Benchmark table: tok/s for 3B/7B/8B/13B at q4_K_M, CPU-only vs Vulkan iGPU
| Model | CPU-only tok/s | Vulkan iGPU tok/s | Prefill uplift |
|---|---|---|---|
| Phi-3.5-mini (3.8B) | 15–19 | 15–20 | ~15% faster prefill |
| Llama-3.1-8B | 6–10 | 7–11 | ~20% faster prefill |
| Mistral-7B-v0.3 | 7–11 | 8–12 | ~20% faster prefill |
| Qwen2.5-14B | 3–5 | 3–5 | ~10% faster prefill |
| Llama-3.1-70B (offload) | <1 | <1 | Not practical |
Numbers depend on RAM speed, background load, and the exact llama.cpp build. Use them as an order-of-magnitude planning tool, not a spec.
Quantization matrix
| Quant | RAM for 7B | Approx tok/s (5600G) | Quality loss |
|---|---|---|---|
| q2_K | ~3.0 GB | 9–13 | Noticeable |
| q3_K_M | ~3.5 GB | 8–12 | Small |
| q4_K_M | ~5.5 GB | 6–10 | Minimal |
| q5_K_M | ~6.5 GB | 5–9 | Trivial |
| q6_K | ~7.5 GB | 5–8 | Near-fp16 |
| q8_0 | ~9.5 GB | 4–6 | None visible |
| fp16 | ~15 GB | 2–3 | None |
Prefill vs generation throughput on the APU
Prefill throughput on the 5600G is respectable — Zen 3's AVX2 pipeline chews through the initial prompt tokens at 50–150 tok/s for a 7B model, depending on context length. Generation is much slower because each token requires streaming a full pass of the model's weights through DRAM. That asymmetry is worth planning around: long system prompts, RAG contexts, and few-shot examples are cheap to load; the actual chat responses are what you'll wait on.
Perf-per-dollar and perf-per-watt math
A 5600G rig with 32 GB of DDR4 and a 500W PSU idles around 45 W and pulls 70–90 W under inference load. At the June 2026 US average retail electricity price (~17¢/kWh), running the machine 24/7 costs roughly $10–13 a month. That is genuinely cheap AI infrastructure. On perf-per-dollar for the CPU alone at typical retail, the 5600G at ~$150 for six cores and a working iGPU is difficult to beat — you're getting a competent desktop and a workable local LLM host in one $200-class part.
Bottom line: who the 5600G no-GPU rig is for
Buy this build if you want a low-cost desktop that also runs 7B–8B language models for chat, drafting, code completion, and light agentic experiments. Skip it if you need reading-speed generation on 13B+, long-horizon agent runs, or any real vision model work. The upgrade path is clean: drop in a used RTX 3060 12GB when the workload demands it, and later swap in the 5800X if the CPU becomes the bottleneck.
Related guides
- Which LLMs Fit a 12GB RTX 3060? — the natural upgrade-path article
- Ryzen 7 5800X vs Ryzen 5 5600G for Local AI — CPU sidegrade math
- llama.cpp vs Ollama vs vLLM on a 12GB RTX 3060 — runtime choice once you add a GPU
Sources
- AMD Ryzen 5 5600G product page — official spec sheet
- ggml-org/llama.cpp — CPU inference engine and benchmark discussions
- Phoronix Ryzen 5600G review — reference Linux benchmarks for the part
