Can a Ryzen 5 5600G Run Local LLMs With No GPU? CPU + iGPU Inference Tested

Yes — a Ryzen 5 5600G runs local LLMs without a GPU, but only up to about 7B parameters at usable speed. Expect ~5–7 tokens/sec on Llama 3.1 8B Q4_K_M with dual-channel DDR4-3600, dropping to ~2 tokens/sec on 13B and slower still on anything larger. The integrated Vega 7 iGPU doesn't help meaningfully. If you want conversational latency at 13B or above, you need a discrete GPU.

The GPU-less local-LLM audience and where the 5600G fits

There is a real audience for GPU-less local LLM inference: budget builders on AM4, people repurposing a home-office PC as an off-hours LLM sandbox, and privacy-first users who want a Llama running on a machine that never sees a discrete GPU. The AMD Ryzen 5 5600G — six Zen 3 cores, twelve threads, Vega 7 iGPU, 65W TDP — is the classic pick for this. It ships new for around $160 and drops routinely to $130 on deals. Nothing else in the AM4 lineup gives you a usable desktop and a shot at CPU inference in one part.

But "usable" needs a number attached. Below we pin down exactly what token-per-second range you can expect at 7B, 13B and 32B on the 5600G, when the Vega iGPU actually helps, why dual-channel RAM speed matters more than clock, and when the math tips over to buying a discrete GPU like the MSI GeForce RTX 3060 Ventus 2X 12G. All numbers are from our own bench with llama.cpp b3800 on Ubuntu 24.04, and cross-checked against the public llama.cpp benchmark threads on the llama.cpp GitHub repository.

Key takeaways

• 7B at Q4_K_M on CPU-only: ~5–7 tok/s with DDR4-3600 dual-channel. Chatty but not instant.
• 8B (Llama 3.1) at Q4_K_M: ~5 tok/s. Usable for background jobs, painful for interactive chat.
• 13B at Q4_K_M: ~2 tok/s. Effectively unusable for interactive work.
• 32B at Q4_K_M: sub-1 tok/s. Batch-only.
• Vega 7 iGPU offload: technically works via Vulkan, adds ~15% throughput at best, uses shared system RAM.
• RAM bandwidth is the throttle: DDR4-3200 → DDR4-3600 buys you a real 8–12% at 7B.
• First-token latency: 4–8 seconds on 7B, 15+ seconds on 13B. This dominates the felt-experience.
• Break point: if you're chatting on a 13B, buy a discrete GPU. If you're batching on a 7B, stay on the 5600G.

How fast is a 5600G at 7B/13B on CPU only?

Bench methodology: AMD Ryzen 5 5600G at stock, 32 GB DDR4-3600 CL18 dual-channel, no discrete GPU, Ubuntu 24.04, llama.cpp b3800, all cores enabled, -t 12 -tb 12. All models Q4_K_M unless stated. Numbers are the median of five 128-token generations, prompt length 512.

7B and below is the usable sweet spot on the 5600G. Once you cross ~10 GB working set you start seeing token generation drop into the 1–2 tok/s band, which is fine for batched summarisation jobs but frustrating for interactive chat.

Quantization matrix on CPU (7B model)

Quantization affects both memory footprint and CPU throughput on the 5600G. Q4_K_M is the mainstream sweet spot; Q5/Q6 improve quality with a real throughput hit; Q8 and fp16 are largely academic on a CPU-only rig.

If throughput is what you care about, park at Q4_K_M and don't look back. Q3_K_M gains you ~10% throughput at a real quality cost that shows up first in code generation.

Does the Vega iGPU help, or is it all CPU + RAM bandwidth?

The Vega 7 iGPU on the 5600G shows up as an OpenCL/Vulkan device to llama.cpp. In practice:

• The iGPU shares system memory. There's no separate VRAM to offload into.
• With --n-gpu-layers set through the Vulkan backend, we saw a modest bump from 7.1 to 8.2 tok/s on Qwen 2.5 7B — about +15%.
• Prompt processing improves more than generation, because prefill is compute-bound and the iGPU adds parallel ALUs the CPU doesn't have.
• The iGPU competes with the CPU for the same DDR4 bandwidth, so the win is smaller than the raw FLOPS suggest.
• On 13B+ models the iGPU can't hold enough layers to make a dent. Stick to CPU.

Verdict: don't buy a 5600G "because it has an iGPU that helps LLMs." The iGPU is a small bonus for 7B, not a real accelerator.

How much does dual-channel RAM speed change tok/s on the 5600G?

More than you'd think. Token generation on a CPU is memory-bandwidth-bound — each generated token requires reading every weight tensor at least once. The 5600G's dual-channel DDR4 memory controller peaks at ~51 GB/s at DDR4-3200 and ~57 GB/s at DDR4-3600. That maps directly to throughput.

Measured on Qwen 2.5 7B Q4_K_M:

The jump from single-channel to dual-channel is huge (+70%). The jump from DDR4-3200 to DDR4-3600 is meaningful (+10%). Anything past DDR4-3600 hits diminishing returns because the Zen 3 memory controller is the bottleneck. If you have a 5600G and one stick of RAM, buying a second identical stick is the single cheapest tok/s upgrade you can make.

Prefill vs generation: why first-token latency dominates the CPU experience

The felt experience of interactive chat on the 5600G is dominated by two numbers: first-token latency and generation tok/s. First-token latency is roughly prompt_len / prefill_tok_s. On the 5600G at Q4_K_M:

• 7B, 512-token prompt: prefill ~19 tok/s → first token in ~27 seconds.
• 7B, 128-token prompt: prefill ~22 tok/s → first token in ~6 seconds.
• 13B, 512-token prompt: prefill ~11 tok/s → first token in ~46 seconds.

That's the wall. A 45-second delay before the first character on a 13B model is the difference between "usable" and "abandoned." Keep prompts short, batch long jobs, don't use it as a live chat assistant on 13B+.

When should you stop and add an RTX 3060 12 GB instead?

Perf-per-dollar math, snapshot Q2 2026:

• Bare Ryzen 5 5600G build: ~$500 total (CPU, board, RAM, PSU, case, storage).
• Add a used MSI GeForce RTX 3060 Ventus 2X 12G: +$220.
• Total: ~$720.

Throughput jump on 7B: 7 tok/s → 58 tok/s (~8x). Throughput jump on 13B: 2 tok/s → 34 tok/s (~17x). First-token latency drops from ~30 s to under 1 s on typical prompts.

If you plan to chat interactively with any model above 7B or you value first-token latency, the extra $220 pays for itself in minutes of your time saved. If you're batching summarisation jobs on a 7B and don't care about latency, stay CPU-only and pocket the money.

Some users pair a 5600G with a beefier Ryzen 7 5700X to bench dGPU-less inference on more cores — the 5700X's eight cores give +25% prefill throughput at 7B, but it's still bandwidth-limited on generation, so the payoff is smaller than you'd hope.

5-column spec-delta table

The step from CPU-only to CPU + RTX 3060 is the largest single throughput jump you can buy under $250 in 2026.

Verdict matrix

Stay CPU-only on the 5600G if…

• You only run 7B or smaller models.
• You batch jobs and don't care about first-token latency.
• You already own the parts and are experimenting.
• Your budget cap is under $500 total.

Add a 12 GB GPU if…

• You want interactive chat at 13B or above.
• First-token latency matters (real-time UI, agent loops).
• You want to run 14B coders and be productive.
• You have $200–250 extra to spend.

Skip the 5600G entirely if…

• You're building fresh and can pick any AM4 CPU.
• You'd rather have a Ryzen 7 5700X or 5800X and a used discrete GPU for the same money.
• You want IOMMU + more PCIe lanes for a second GPU later.

Threads, cores and the -t flag

llama.cpp exposes a -t (threads) knob that people habitually push to the maximum. On a 12-thread Ryzen 5 5600G the sweet spot is around -t 12 for generation and -t 6 for prefill on 7B — pushing threads past physical-core count sometimes hurts because SMT contention outweighs the extra ALUs. Verify on your machine with the bench binary; small tweaks can buy you 5–8%. Also disable NUMA balancing in the kernel — it's a nonzero drag on a single-socket Zen 3 chip because llama.cpp's memory access pattern doesn't benefit from the OS shuffling pages between the (single) node.

Prompt caching: the underused throughput trick

llama.cpp supports prompt caching via --prompt-cache <file> — the first call to a system prompt eats the full prefill, subsequent calls to the same prefix skip it. On the 5600G that's the difference between "6 seconds to first token every time" and "6 seconds once, then <1 second forever." If you're running an assistant with a stable system prompt, wire this up and your effective throughput on short interactions doubles. Ollama supports the same idea via its keep_alive flag on the server — the model and its prefill state stay in RAM.

Bottom line

The 5600G is a valid, cheap "toe in the water" for local LLMs, but the water is shallow. Treat it as a way to prove the workflow works on your data, then plan for a discrete GPU the moment you outgrow 7B. Run llama.cpp with -t 12 and dual-channel DDR4-3600 for the best CPU-only numbers, and don't overinvest in Q5/Q6 — Q4_K_M is where the 5600G actually earns its keep. Cross-shop the RTX 3060 12 GB as the natural upgrade path — a used one costs less than a decent 32 GB RAM kit and delivers an order-of-magnitude better tok/s.

Related guides

• Which GPU for Which LLM? A per-model VRAM guide
• Ryzen 5 5600G vs Ryzen 7 5700X for budget 1080p gaming
• OpenAI Codex watch-once-repeat and local coding rigs

Sources

• AMD Ryzen 5 5600G product page — official TDP, cache, iGPU spec.
• ggml-org/llama.cpp — benchmark methodology and Vulkan backend reference.
• TechPowerUp — Ryzen 5 5600G CPU specs — memory controller ceiling, base/boost clocks, cache sizes.