Nitish-Goud/local-llm-8gb-vram-benchmark

What actually happens when a local LLM doesn't fit in your GPU? A controlled benchmark of 11 Ollama models across 3 context windows, with GPU residency measured directly.

---

TL;DR

On a consumer laptop GPU with 8 GB of VRAM, three things stood out:

#	Finding	Evidence
1	A 12B model that only partly fits on the GPU is 5-7x slower than 8B models that fit.	gemma4:12b keeps only ~68% of its weights in VRAM and generates 12 tok/s, versus 65 tok/s for llama3.1:8b and 82 tok/s for gemma4:latest.
2	Raising the context window can silently push a model off the GPU.	qwen3-vl:8b runs at 60.7 tok/s at num_ctx=2048, then drops to 20.2 at 4096 and 19.0 at 8192 (GPU residency 100% to 86% to 80%). That is a 3x slowdown from one setting.
3	Parameter count alone does not predict speed.	granite3.1-moe (a mixture-of-experts model) reaches 268 tok/s, about twice the dense 3B models, while gemma4:latest (8.0B) outruns llama3.1:8b (8.0B) by 25%.

GPU residency (gpu_fraction) comes straight from Ollama's ps output (size_vram / size), so it is a measurement, not an inference from RAM or CPU usage.

---

Throughput by model

Context window effect

The offload penalty

Each point is one (model, context window) configuration, averaged over 12 runs. Everything below 100% GPU residency pays a speed penalty.

---

Models tested

All models were run at Q4_K_M quantization. "Memory" is the runtime footprint Ollama reported (ollama ps), averaged over contexts.

Model	Params	Quant	Memory	On GPU	tok/s	Stopped early
granite3.1-moe:latest	3.3B	Q4_K_M	2.3 GB	100%	268	0%
qwen2.5:3b	3.1B	Q4_K_M	2.1 GB	100%	136	17%
llama3.2:3b	3.2B	Q4_K_M	2.5 GB	100%	134	25%
phi4-mini:latest	3.8B	Q4_K_M	3.0 GB	100%	114	50%
qwen3:4b	4.0B	Q4_K_M	3.1 GB	100%	104	0%
gemma4:latest	8.0B	Q4_K_M	3.0 GB	100%	82	0%
llama3.1:8b	8.0B	Q4_K_M	5.0 GB	100%	65	0%
deepseek-r1:8b	8.2B	Q4_K_M	5.3 GB	100%	60	0%
qwen3.5:9b	9.7B	Q4_K_M	5.3 GB	96%	53	0%
qwen3-vl:8b	8.8B	Q4_K_M	5.8 GB	89%	33	0%
gemma4:12b	11.9B	Q4_K_M	8.3 GB	68%	12	0%

Parameter counts and quantization were read from Ollama (ollama show), not typed by hand. Model digests are in the digest column.

Generation speed (tok/s) by context window

Model	2048	4096	8192
granite3.1-moe:latest	263.9	270.2	268.9
qwen2.5:3b	134.1	137.3	137.2
llama3.2:3b	135.0	133.9	132.9
phi4-mini:latest	111.9	114.1	114.7
qwen3:4b	103.6	103.5	103.5
gemma4:latest	81.5	81.8	81.8
llama3.1:8b	65.6	65.6	64.7
deepseek-r1:8b	60.4	60.7	60.1
qwen3.5:9b	57.4	57.4	44.9
qwen3-vl:8b	60.7	20.2	19.0
gemma4:12b	11.6	12.6	12.1

GPU residency for the models that moved: qwen3-vl:8b 1.00 / 0.86 / 0.80, qwen3.5:9b 1.00 / 1.00 / 0.88, gemma4:12b 0.69 / 0.69 / 0.67.

---

Files

File	Description
benchmark_runs.csv	396 rows, one per timed generation call.
benchmark_metadata.json	GPU, driver, CPU, RAM, OS, Ollama version, and generation settings.
analysis.py	Reproduces every chart in this card from the CSV.
assets/	Chart images used in this card.

Quick start

from datasets import load_dataset

ds = load_dataset("Nitish-Goud/local-llm-8gb-vram-benchmark", split="train")
df = ds.to_pandas()

# Mean speed per model, and how much of each model sat in VRAM
print(df.groupby("model")[["tokens_per_sec", "gpu_fraction"]].mean().sort_values("tokens_per_sec"))

Column dictionary

Column	Type	Meaning
model	str	Ollama model tag.
family	str	Model family reported by Ollama.
parameter_size_b	float	Parameters in billions, as reported by ollama show.
quantization	str	Quantization level reported by Ollama (all Q4_K_M).
digest	str	First 12 characters of the model digest from ollama list.
prompt_label_tokens	int	Nominal prompt label (50 / 200 / 500 / 1000). Not the real token count.
prompt_actual_tokens	int	Prompt tokens actually processed (prompt_eval_count). Range 17-271.
context_window	int	num_ctx setting: 2048, 4096, or 8192.
run_index	int	Repeat number, 1 to 3.
timestamp	str	ISO timestamp of the run.
latency_seconds	float	Wall-clock time of the generate call (warm model).
load_seconds	float	Cold model load time from the warm-up call. Constant within a (model, context) configuration.
prompt_eval_seconds	float	Time spent processing the prompt.
eval_seconds	float	Time spent generating tokens.
output_tokens	int	Tokens generated (eval_count), capped at 512.
tokens_per_sec	float	output_tokens / eval_seconds. The recommended speed metric.
done_reason	str	length (hit the 512-token cap) or stop (model finished).
peak_cpu_percent	float	Peak CPU of Ollama processes. Summed over threads, so it can exceed 100.
peak_ram_mb	float	Peak resident memory (RSS) of Ollama processes.
baseline_vram_mb	float	GPU memory in use with the model unloaded.
vram_after_load_mb	float	Total GPU memory in use after the warm-up load.
peak_vram_total_mb	float	Peak total GPU memory during the run.
peak_vram_delta_mb	float	peak_vram_total_mb - baseline_vram_mb.
vram_settled	bool	Whether baseline VRAM stabilized before the run (true for all rows).
model_total_mb	float	Runtime memory footprint of the loaded model (ollama ps size).
model_in_vram_mb	float	Portion of that footprint resident in GPU memory (size_vram).
gpu_fraction	float	model_in_vram_mb / model_total_mb. 1.0 means fully on GPU.

---

Method

How each run was measured

For every (model, context window) pair:

1. Unload the model and wait until it disappears from ollama ps.
2. Baseline: wait for GPU memory to settle (three consecutive readings within 5 MB) and record it.
3. Warm-up: one short generate call loads the model at the target num_ctx. Its load time is recorded as load_seconds.
4. Timed runs: 4 prompts x 3 repeats on the warm model, while a background thread samples CPU, RAM, and GPU memory every 60 ms.
5. Offload snapshot: after each call, read size and size_vram from ollama ps.

Generation settings: num_predict=512, temperature=0, seed=42. Loop order is model, then context window, then prompt, so each model reloads only once per context size.

The 4 prompts range from a one-line question to a long multi-part request. Their actual lengths are 17-271 tokens, so the context-window effect here comes from the KV-cache allocation that num_ctx triggers, not from long inputs.

Limitations

Read these before drawing conclusions:

• One machine, one session. NVIDIA GeForce RTX 5060 Laptop GPU (8 GB), AMD Ryzen CPU (8 cores / 16 threads), 31 GB RAM, Windows 11, Ollama 0.40.2. Laptop power and thermal limits apply, and Windows reserves some VRAM for the display. Results will differ on desktop GPUs and other operating systems.
• Throughput only, not quality. This dataset says nothing about answer quality. Reasoning models (deepseek-r1, qwen3, qwen3.5, qwen3-vl) likely spend much of the 512-token budget on hidden thinking.
• Output length differs across models. Seven models hit the 512-token cap on every run, but phi4-mini (50%), llama3.2:3b (25%), and qwen2.5:3b (17%) sometimes stopped early. Compare models with tokens_per_sec, not latency_seconds.
• Short prompts. Actual prompt lengths are 17-271 tokens. Behavior with long prompts that fill the context window was not tested.
• Nominal prompt labels. prompt_label_tokens is a label, not a measured length. Use prompt_actual_tokens.
• Runtime memory footprints are as reported. gemma4:latest reports a runtime footprint of about 3 GB. This is reported as measured, and no explanation is offered here.
• Small sample per configuration. 12 runs per (model, context) pair, with fixed seed and temperature 0, so repeats mostly measure timing noise.
• Ollama version and defaults matter. Offload behavior depends on Ollama's scheduler and may change between releases.

Roadmap

This dataset is the foundation for a rebuilt Local LLM Performance Predictor: more models, and a PyTorch neural network trained to predict latency and memory use from model and hardware features. Updates will be posted in this repo.

Citation

@dataset{katta_local_llm_8gb_benchmark_2026,
  author    = {Katta, Nitish},
  title     = {Local LLM Benchmark on an 8 GB GPU},
  year      = {2026},
  publisher = {Hugging Face},
  url       = {https://huggingface.co/datasets/Nitish-Goud/local-llm-8gb-vram-benchmark}
}

Author

Katta Nitish Goud, AI/ML engineering student, Hyderabad. GitHub | Portfolio

Feedback and corrections are welcome. If you reproduce this on a different GPU, open a discussion on the repo.