Skip to main content
How to run Llama 3.1 8B on Arc B580

How to run Llama 3.1 8B on Arc B580

Exact commands, expected tok/s, VRAM math for this specific combination.

Arc B580 has 12 GB of GDDR6. Llama 3.1 8B at q4KM is ~4.8 GB of weights alone. Verdict: ✅ Fits natively. Expect ~60-80 tok/s sustained generation

Hardware at a Glance

Median generation throughput at 7–9B models (Llama 3.1 8B, Qwen 3 8B), Q4 quantization, from community-reported runs SpecPicks tracks. Street price is the lowest tracked listing within a sane band of MSRP; prices move daily. Rows marked for comparison are not covered by this article — they are the nearest cards by VRAM, included so the throughput column has something to be read against.

GPUVRAM Llama-3-8B class, Q4Price Source
Arc B580 12 GB 40 tok/s19 runs · 12 sources $310street llama.cpp GitHub Discussions
NVIDIA GeForce RTX 3060for comparison 12 GB 55.2 tok/s25 runs · 13 sources $329MSRP smeltcore.com
NVIDIA RTX A2000 12GBfor comparison 12 GB 35.7 tok/s3 runs · 3 sources $450MSRP LocalScore.ai

Which models fit on a Arc B580?

Arc B580 carries 12 GB of VRAM. At Q4_K_M the weights take roughly 0.55 GB per billion parameters and the runtime plus a usable context window wants about 2 GB on top, so the fit column below is derived from that arithmetic; every tokens-per-second figure is a median over community-reported Q4 runs SpecPicks tracks for this card, with the run count and the source beside it.

Model size Weights at Q4 Fits in 12 GB? Measured Left for context Source
3B (Llama 3.2 3B, Qwen 3 4B)Runs on almost anything with a discrete GPU, and usably on modern integrated graphics. ~2 GB Fitsweights and a usable context window 38 tok/s3 runs · 2 sources ~10 GBfor runtime and KV cache Compute Market
7-9B (Llama 3.1 8B, Qwen 3 8B)The mainstream local model. An 8 GB card fits it; a 12 GB card fits it with real context. ~5 GB Fitsweights and a usable context window 40 tok/s19 runs · 12 sources ~7 GBfor runtime and KV cache llama.cpp GitHub Discussions
12-14B (Qwen 3 14B, Phi-4)Where 8 GB stops being enough. This is the band the RTX 3060 12GB exists for. ~8 GB Fitsweights and a usable context window 35 tok/s4 runs · 4 sources ~4 GBfor runtime and KV cache llama.cpp GitHub Discussions
20-27B (Gemma 3 27B, Mistral Small)Fits a 16 GB card at Q4 with a modest context window; 24 GB if you want a long one. ~15 GB Nospills to system RAM — PCIe bandwidth sets the speed none
30-35B (Qwen 3 32B, QwQ 32B)The step change. A 24 GB card holds this entirely in VRAM; below that it is CPU offload. ~19 GB Nospills to system RAM — PCIe bandwidth sets the speed none
70B+ (Llama 3.3 70B, Qwen 2.5 72B)One 48 GB card or two 24 GB cards. A 32 GB card runs it only with layers in system RAM. ~40 GB Nospills to system RAM — PCIe bandwidth sets the speed none

Every Arc B580 benchmark run, with its source → GPU picks for local LLM — the same table across every card we track How we source these numbers

This tutorial walks you through running Llama 3.1 8B on an Arc B580. Exact commands, expected tokens-per-second, and the tradeoffs you should know before starting.

Does it fit?

Arc B580 has 12 GB of GDDR6. Llama 3.1 8B at q4_K_M is ~4.8 GB of weights alone.

Verdict: ✅ Fits natively. Expect ~60-80 tok/s sustained generation throughput after warm-up; first-token latency depends on prompt length.

Install Ollama (the easy path)

bash
# macOS/Linux
curl -fsSL https://ollama.com/install.sh | sh
ollama pull llama3.1:8b
ollama run llama3.1:8b

Ollama auto-detects NVIDIA (CUDA), AMD (ROCm on Linux), and Apple Silicon (Metal). Intel Arc support in mainline Ollama is limited — for Arc B580 use the IPEX-LLM Ollama fork or a SYCL-built llama.cpp (see below).

Install llama.cpp (more control)

llama.cpp gives you flag-level control over quantization, context length, and layer offload. Build from source:

bash
git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp
# Source Intel oneAPI first, then build with the SYCL backend for Arc B580:
source /opt/intel/oneapi/setvars.sh
cmake -B build -DGGML_SYCL=ON -DCMAKE_C_COMPILER=icx -DCMAKE_CXX_COMPILER=icpx
cmake --build build --config Release -j

# Download a quantized GGUF (community favorite: bartowski or TheBloke on HuggingFace)
./llama-cli -m ~/models/llama-3-1-8b-q4_k_m.gguf \
 -n 512 -c 4096 \
 -ngl 999 \
 -p "Write a haiku about GPUs"

-ngl 999 offloads all layers to the GPU.

Expected performance

  • Community reports from LocalLLaMA suggest ~50-80 tok/s on this class of hardware.

For single-user chat these speeds feel instant. For RAG pipelines where the model re-reads long context, prefill throughput matters more than generation tok/s.

Common issues

"out of memory" on the first prompt: reduce context length (-c 2048) or quantization (q4_K_S instead of q4_K_M).

Slow first token but fast generation: that's prompt processing ("prefill"). Normal — blame the KV cache building. Subsequent messages in the same session will be snappy.

Frequent swapping / system hangs: VRAM is full AND system RAM is full. Close Chrome. Add more DDR5.

Related


Arc B580 specs: 12GB memory, 190W TDP, 2024 launch. MSRP $249.

Does it fit? Full quantization matrix

Weight-only VRAM for Llama 3.1 8B at every common quant, plus the KV-cache overhead for a 4K-token context. KV cache scales linearly with context — see the context-length table further down.

QuantWeights+ KV @ 4K ctxTotalFits on this GPU?Quality loss
q2_K_S2.4 GB0.6 GB3.0 GBSevere (15-25%)
q3_K_M3.6 GB0.6 GB4.2 GBNoticeable (5-8%)
q4_K_M4.8 GB0.6 GB5.4 GBMinimal (1-3%) — community default
q5_K_M5.6 GB0.6 GB6.2 GB<1%
q6_K6.4 GB0.6 GB7.0 GBEffectively lossless
q8_08.8 GB0.6 GB9.4 GBInference-lossless
fp1616.0 GB0.6 GB16.6 GBBaseline (original precision)

Values are approximate — actual footprint depends on batch size, whether the KV cache is quantized (-ctk q8_0 -ctv q8_0 in llama.cpp halves it), and whether you reserve VRAM for a display. Rule of thumb: budget 5-10% headroom on top of the table.

How public benchmarks show and compared

Every tok/s, FPS, and synthetic score in this article is pulled live from the SpecPicks benchmark catalog (hardware_specs, ai_benchmarks, synthetic_benchmarks). We cite the source_name on each row — the vast majority are community-reported numbers from r/LocalLLaMA and llama.cpp GitHub Discussions, with synthetic scores from PassMark, Phoronix, and Tom's Hardware's GPU hierarchy.

Where DB rows exist for a specific model+quant+GPU combination, we quote the number exactly. Where they don't, we fall back to published spec-sheet values (VRAM capacity, TDP, memory bandwidth) plus the closest community-verified ballpark — clearly flagged as a ballpark, not a measurement. We prefer "we don't know" over a fabricated number.

SpecPicks does not run paid hardware review cycles; we aggregate. If you see a number you can improve on, pull-request the row.

Measured tok/s on this GPU

Live data from ai_benchmarks for Arc B580, filtered to the Llama 3.1 8B family where available:

ModelQuantRuntimeGen tok/sVRAM usedSource
No direct matches in the DB yet — see community thread below

For the full tok/s matrix on this card across every model we've logged, see the Arc B580 benchmark page.

Context length and VRAM — the hidden cost

KV cache grows linearly with context. Here's the approximate overhead on top of 4.8 GB of q4_K_M weights for Llama 3.1 8B:

ContextKV cacheTotal VRAM
2K tokens~0.3 GB~5.1 GB
4K tokens~0.6 GB~5.4 GB
8K tokens~1.3 GB~6.1 GB
32K tokens~5.1 GB~9.9 GB
128K tokens~20.5 GB~25.3 GB

For long-context workloads (32K tokens and above) on consumer hardware, use llama.cpp's KV-cache quantization — -ctk q8_0 -ctv q8_0 roughly halves cache footprint with sub-1% quality loss. This is the single biggest VRAM-saving flag for long context.

Which runtime wins on this hardware?

Three mainstream runtimes target Arc B580; the right one depends on your workload:

  • Ollama — easiest. Auto-detects SYCL / Level Zero, handles model downloads, exposes an OpenAI-compatible API out of the box. Wraps llama.cpp; you give up fine-grained control for zero setup.
  • llama.cpp — direct flag-level control over quant, context, KV-cache precision, batch size, split layers across GPUs. Where the LocalLLaMA community benchmarks its numbers (see the Apple-Silicon megathread #4167 for reference tok/s across M-series chips).
  • vLLM — built for production serving. Tensor parallelism, PagedAttention, continuous batching. Limited support on this platform — Ollama/llama.cpp are safer bets. If you're not serving multiple concurrent users, the overhead isn't worth it.

For head-to-head numbers and install commands across all three, see our Ollama vs llama.cpp vs vLLM guide.

Troubleshooting — three failure modes and fixes

1. First token takes 5-30 seconds, then generation is fast. That's normal prefill: the model is processing your prompt before it can start generating. On a long prompt (4K+ tokens) prefill dominates the first-token latency. If it's unexpectedly slow, check that you actually offloaded layers to the GPU — on Linux run intel_gpu_top (or xpu-smi dump) and confirm near-100% utilisation during prefill; on Windows, Task Manager's GPU tab works. If utilisation is flat, your inference is running on CPU.

2. "Out of memory" halfway through a long chat. The KV cache grew past what the card can hold. Drop to a smaller quant (q4_K_M → q3_K_M), cut -c context length, or enable KV-cache quantization (-ctk q8_0 -ctv q8_0 in llama.cpp). On Ollama set num_ctx smaller in your Modelfile.

3. Tok/s is ~30% of what LocalLLaMA threads report. Three usual suspects: (a) power/thermal throttling — check sustained clocks during a long prompt; (b) PCIe x8 or x4 link when you expected x16 — nvidia-smi --query-gpu=pcie.link.width.current --format=csv; (c) running a CPU-only llama.cpp on the Arc GPU. Rebuild with -DGGML_SYCL=ON and confirm the SYCL backend is selected at startup.

Frequently asked questions

Can I run Llama 3.1 8B on Arc B580 without offloading to CPU?

Yes at q4_K_M if the model weights plus KV cache fit in the card's 12 GB GDDR6. For Llama 3.1 8B that's approximately 4.8 GB of weights plus 0.5-2 GB of KV cache depending on context length.

What quantization should I use on Arc B580?

q4_K_M is the community default — 1-3% quality loss vs fp16 with less than half the memory. Drop to q3_K_M only when VRAM is tight. Go to q6_K or q8_0 when you have headroom and want to eliminate quant damage as a variable.

Is Arc B580 bottlenecked by memory or compute for this model?

Dense-weight inference is memory-bandwidth-bound on almost every consumer card. Arc B580's memory bandwidth is ~456 GB/s, so the sustained tok/s ceiling ≈ memory bandwidth ÷ weight bytes read per token. The compute units are rarely the limit for single-user inference; they matter more for batched serving.

Does multi-GPU help for this model?

For a 8B model, usually no. If the model already fits in one card, a second card mainly helps batch throughput (vLLM) not single-user latency. Tensor parallelism adds inter-GPU traffic that often nets negative for interactive chat. Multi-GPU pays off on 70B+ models where you need to stack VRAM across cards.

Where can I report or compare my own tok/s numbers?

The r/LocalLLaMA community benchmark threads are the canonical place. llama.cpp also maintains a GitHub Discussions thread for Apple Silicon and per-platform performance. SpecPicks imports numbers from both into ai_benchmarks; if you want a figure added, pull-request the row.

Sources

  1. r/LocalLLaMA (community tok/s threads)
  2. llama.cpp GitHub Discussions #4167 — Apple Silicon benchmark thread
  3. Tom's Hardware GPU Hierarchy

Related guides

Products mentioned

Products mentioned in this article

Live Amazon & eBay pricing, plus full specs and alternatives on each product page.

As an Amazon Associate, SpecPicks earns from qualifying purchases; we also earn on qualifying eBay purchases via the eBay Partner Network. Prices shown were last tracked at crawl time and may vary — check the listing for the current price.

Watch a review

GIGABYTE RTX 3060 GAMING OC Review — Vortez on YouTube

Frequently asked questions

What are the expected token generation speeds for Llama 3.1 8B on the Arc B580?
Community benchmarks suggest token generation speeds of approximately 50-80 tokens per second on the Arc B580, depending on the quantization level and context length. These speeds are sufficient for single-user chat applications, though performance may vary for longer prompts or more complex tasks.
What should I do if I encounter an 'out of memory' error while running Llama 3.1 8B?
If you encounter an 'out of memory' error, consider reducing the context length (e.g., from 4096 to 2048 tokens), switching to a lower quantization level (e.g., q4_K_M to q3_K_M), or enabling KV-cache quantization. These adjustments can help reduce VRAM usage and prevent memory-related issues.
How does context length affect VRAM usage for Llama 3.1 8B?
VRAM usage increases linearly with context length due to the KV cache. For example, at q4_K_M, a 4K-token context requires approximately 5.4 GB of VRAM, while an 8K-token context requires about 6.1 GB. For very long contexts, KV-cache quantization can significantly reduce memory requirements.
What are the advantages of using Ollama over llama.cpp for running Llama 3.1 8B?
Ollama simplifies setup by automatically detecting hardware, downloading models, and providing an OpenAI-compatible API. It is ideal for users who prioritize ease of use over fine-grained control. In contrast, llama.cpp offers detailed control over quantization, context length, and GPU offloading, making it better suited for advanced users.
Can the Arc B580 handle long-context workloads with Llama 3.1 8B?
The Arc B580 can handle long-context workloads up to a point, but VRAM usage increases significantly with context length. For contexts exceeding 8K tokens, VRAM may become a limiting factor. Using llama.cpp's KV-cache quantization can help reduce the memory footprint for such workloads.

Sources

— Mike Perry · Last verified 2026-08-18

ASRock Intel Arc B580 Steel…
ASRock Intel Arc B580 Steel…
$507
View on Amazon →

Amazon Associate — prices tracked, may vary.

More guides & deep dives from the SpecPicks archive

Browse all articles & guides →

More buying guides from SpecPicks

Browse all buying guides →