witcheer/windows-rtx-4060ti-8gb-moe-offload-bench-2026-05

RTX 4060 Ti 8GB — Multi-Model Benchmark (2026-05)

practitioner benchmarks on consumer hardware (8GB VRAM, 32GB RAM). 10 models tested, covering MoE expert offload, hybrid SSM architectures, dense models, MLA, dense partial GPU offload, and the 1B speed ceiling. all runs on the same physical rig, same methodology.

current leaderboard (decode tok/s at sweet spot)

model	active params	GGUF size	sweet spot tok/s	quality (6 tests)	architecture
Llama 3.2 1B	1.24B	771 MB	228.2	4p 2f	dense transformer
Gemma 4 E2B	2.3B	2.9 GB	117.8	4p 2pt	dense + PLE
Mistral 7B v0.3	7.3B	4.1 GB	56.4	5p 1pt	dense transformer
LFM2 24B A2B	2.3B	13.4 GB	52.2	4p 2pt	hybrid SSM+conv+MoE
Qwen3 8B	8.2B	4.7 GB	50.8	4p 1pt 1f	dense transformer
gpt-oss-20b	3.6B	11 GB	39.45	agentic: 10/10	transformer MoE
Qwen3.6 35B A3B	3B	22.1 GB	35.4	4p 2f	hybrid SSM+attn MoE
GLM 4.7 Flash	~3B	18 GB	29.9	4p 2f	MoE + MLA (deepseek2)
Gemma 4 26B A4B	3.8B	16 GB	29.3	—	transformer MoE
Qwen3.6 27B	27B	17.5 GB	3.28	5p 1f	hybrid SSM+attn (dense)

p = pass, pt = partial, f = fail. quality tests: JSON, code gen, logic, system prompt, hallucination, format switching.

hardware

component	spec
GPU	RTX 4060 Ti 8GB (Ada Lovelace, sm_89)
system RAM	32GB DDR5-6000 dual-channel
CPU	AMD Ryzen 5 7600X (6c/12t)
platform	WSL2 Ubuntu 26.04 on Windows 11

data files

file	model	rows	date	notes
source/bench-2026-05-06.jsonl	Qwen3.6 35B A3B	2	2026-05-06	full offload (LM Studio)
source/bench-2026-05-07.jsonl	Qwen3.6 35B A3B	5	2026-05-07	ncmoe sweep + context scaling
source/bench-2026-05-13.jsonl	Gemma 4 26B A4B	6	2026-05-13	ncmoe sweep + context scaling
source/bench-lfm2-2026-05-13.jsonl	LFM2 24B A2B	6	2026-05-13	ncmoe sweep + context scaling + turbo3 test
source/bench-gemma4e2b-2026-05-14.jsonl	Gemma 4 E2B	6	2026-05-14	context scaling (dense, full GPU)
source/bench-mistral7b-2026-05-14.jsonl	Mistral 7B v0.3	6	2026-05-14	context scaling (dense, full GPU)
source/bench-glm47flash-2026-05-15.jsonl	GLM 4.7 Flash	6	2026-05-15	ncmoe sweep + context scaling + quality tests
source/bench-qwen3-8b-2026-05-16.jsonl	Qwen3 8B	5	2026-05-16	context scaling + quality tests (dense)
source/bench-llama32-1b-2026-05-16.jsonl	Llama 3.2 1B	5	2026-05-16	context scaling + quality tests (speed ceiling)
source/bench-qwen36-27b-dense-2026-05-18.jsonl	Qwen3.6 27B	5	2026-05-18	dense partial GPU offload (MoE vs dense control)

methodology

MoE models (Qwen3.6 35B A3B, Gemma 26B, LFM2, GLM 4.7 Flash)

• engine: llama-server (turboquant fork, CUDA build)
• -ngl 999 -ncmoe N -fa on --cache-type-k q8_0 --cache-type-v [q8_0 or turbo3]
• GLM 4.7 Flash: flash attention OFF (required for MLA/deepseek2 arch), --jinja required
• sweep: find optimal ncmoe (most expert layers on GPU without hitting 8GB VRAM cliff)
• context scaling: test at various depths to measure decode degradation
• temperature 0 or 0.7 depending on run

dense models (Gemma 4 E2B, Mistral 7B v0.3, Qwen3 8B, Llama 3.2 1B)

• engine: same llama-server build
• -ngl 999 -fa on --cache-type-k q8_0 --cache-type-v q8_0 (no ncmoe needed)
• context scaling: baseline through max context
• quality tests: 6-test battery

dense partial GPU offload (Qwen3.6 27B)

• engine: same llama-server build
• -ngl 20 -fa on --cache-type-k q8_0 --cache-type-v q8_0 -c 32768
• only 20 of 64 layers on GPU (5.5 GB model weights on GPU, 11.2 GB on host RAM)
• control experiment: same family as the MoE (Qwen3.6 35B A3B), proving MoE expert offload is faster than dense layer offload

quality tests (7 models)

starting from the LFM2 round, we run targeted quality tests beyond pure speed:

• JSON compliance: structured output, correct schema
• code generation: Python with type hints and memoization
• logic puzzle: classic surgeon riddle
• system prompt adherence: uppercase pirate constraint
• hallucination resistance: fictional study citation
• format switching: bullets then markdown table

full prompt/response traces are in the companion bench-results markdown files (linked in discussion posts).

key findings

MoE offload is 10.8x faster than dense offload (same family)

the capstone experiment: Qwen3.6 35B A3B (MoE, -ncmoe 30) vs Qwen3.6 27B (dense, -ngl 20) on the same hardware. MoE: 35.4 tok/s. dense: 3.28 tok/s. 10.8x faster. the gap widens to 16.7x at 24K context because MoE has zero context degradation (SSM layers) while dense loses -35.4%.

why: MoE expert offload keeps the hot path (3B active params) entirely in VRAM. dense layer offload splits every layer across GPU and CPU, so every token must bounce through PCIe for all 64 layers. on VRAM-constrained hardware, the offload strategy matters more than the model size.

quality is marginally better on dense (5/6 vs 4/6), but 3.28 tok/s is unusable for interactive work.

speed ceiling: 228 tok/s

Llama 3.2 1B at 771 MB sets the absolute speed ceiling for this hardware. 228 tok/s decode, 16,791 tok/s prompt eval at 8K. the GPU is barely loaded. only 2.1 GB VRAM used.

the 8GB VRAM cliff

crossing ~7 GB total GPU usage triggers CUDA page faults through PCIe. throughput drops ~50% instantly. this is the single most important constraint on this hardware. MoE models must be tuned with ncmoe to stay below this line.

architecture matters more than param count

LFM2 (2.3B active, hybrid SSM) runs 78% faster than Gemma 26B (3.8B active, transformer MoE) despite both using expert offload. SSM layers have fixed-size recurrent state instead of growing KV cache, leaving more VRAM for expert layers.

MLA gives flattest context scaling

GLM 4.7 Flash loses only -14.7% at 24K context, the best of all models tested. Multi-Head Latent Attention compresses the KV cache, so VRAM barely moves (+20 MiB from baseline to 24K). compare: Mistral 7B loses -46% at 24K with full attention.

thinking mode is a double-edged sword

Gemma E2B, GLM Flash, Qwen3 8B, and both Qwen3.6 variants all have built-in thinking modes that output reasoning_content. this helps structured output quality but can consume the entire token budget (GLM, Qwen3 8B, and both Qwen3.6 models all failed code gen: all 2,048 tokens on reasoning, zero content). models without thinking mode (Mistral, LFM2, Llama 1B) pass code gen cleanly.

hallucination resistance scales with knowledge

Qwen3.6 27B (27B dense) has the best hallucination resistance of all 9 models: firm refusal with explicit "potentially fictional" flag. Qwen3 8B (8.2B dense) and Llama 3.2 1B also correctly identified the fictional study. larger active param counts give models enough world knowledge to know what doesn't exist. GLM (30B total, ~3B active) had the worst hallucination, fabricating an entire paper.

turbo3 V-cache: model-dependent

turbo3 helps Qwen (+13% speed) but hurts LFM2 (-37%). compute-bottlenecked models pay the dequantisation overhead without benefiting from VRAM savings. test before adopting.

caveats

• Gemma 4 E2B: PLE (Per-Layer Embeddings) not fully implemented in llama.cpp as of 2026-05-14. quality may improve when that lands.
• Gemma 4 E2B: built-in thinking mode consumes token budget. set max_tokens to 2048+ for reliable output.
• GLM 4.7 Flash: requires flash attention OFF and --jinja flag. ncmoe tuning has a narrow sweet spot.
• GLM 4.7 Flash: worst hallucination of all models tested, fabricated a complete paper with specific details.
• Qwen3 8B: 4.7 GB model + 2.4 GB KV cache at 32K fills nearly all 8GB VRAM. reduce context to 16K for safety.
• Qwen3.6 27B: requires 24GB+ WSL2 memory allocation and partial GPU offload (-ngl 20). 3.28 tok/s is not usable interactively.
• all numbers are from a single rig with specific driver/CUDA versions. your mileage may vary.

collection

this dataset is part of the 8GB VRAM local LLMs: practitioner-tested collection.