The open-weight model landscape has shifted dramatically in early 2026. Four families now dominate: Alibaba’s Qwen3, Meta’s Llama 4, Zhipu AI’s GLM-5, and Google’s Gemma 3. Marketing materials claim they all “rival GPT-4” and “run locally,” but what does that actually mean for your hardware?
We compiled real benchmark data and VRAM requirements to answer the question that matters: which model should you run on your actual GPU?
The February 2026 Rankings
According to the Onyx AI Open Source LLM Leaderboard, the current top performers are:
- GLM-5 (Reasoning) - Quality Index 49.64
- DeepSeek V3.2 Speciale - Quality Index 57
- Qwen3-235B-A22B - Quality Index 57
For coding specifically, WhatLLM’s February analysis shows:
- DeepSeek V3.2 Speciale: 90% on LiveCodeBench
- GLM-4.7 (Thinking): 89%
- MiMo-V2-Flash: 87%
But here’s the problem: those flagship models require enterprise hardware. GLM-5’s 744 billion parameters need multiple data center GPUs. What about the rest of us?
What Actually Fits on Consumer Hardware
8GB VRAM (RTX 4060, RTX 3070)
Your options are limited but usable:
| Model | Parameters | Quantization | Speed | Best For |
|---|---|---|---|---|
| Llama 3.1 8B | 8B | Q4_K_M | ~40 tok/s | General chat |
| Qwen3 8B | 8B | Q4_K_M | ~45 tok/s | Multilingual |
| Gemma 3 4B | 4B | Q4_K_M | ~60 tok/s | Fast responses |
At this tier, you’re getting roughly GPT-3.5-level performance. Adequate for basic tasks, but limited for complex reasoning or long contexts.
12-16GB VRAM (RTX 4070 Ti, RTX 4080)
This is where things get interesting:
| Model | Parameters | Quantization | Speed | Best For |
|---|---|---|---|---|
| Gemma 3 12B | 12B | Q4_K_M | ~35 tok/s | Balanced performance |
| Qwen3 14B | 14B | Q4_K_M | ~30 tok/s | Coding, reasoning |
| DeepSeek-R1-Distill-Qwen-14B | 14B | Q4_K_M | ~28 tok/s | Deep reasoning |
The 14B class delivers a significant quality jump. Qwen3 14B handles coding tasks that stump 8B models, and DeepSeek’s distilled reasoning model brings o1-style thinking to consumer hardware.
24GB VRAM (RTX 4090, RTX 3090)
The sweet spot for local inference:
| Model | Parameters (Active) | Quantization | Speed | Best For |
|---|---|---|---|---|
| Qwen3-30B-A3B | 30B (3B active) | Q4_K_M | ~65 tok/s | Best efficiency |
| Gemma 3 27B | 27B | Q4_K_M | ~25 tok/s | Multimodal |
| Llama 4 Scout | 109B (17B active) | 1.78-bit | ~20 tok/s | 10M context |
Qwen3-30B-A3B deserves special attention. Despite having 30 billion total parameters, its Mixture of Experts (MoE) architecture activates only 3.3 billion per token. The result? It scores 91.0 on ArenaHard while running at speeds that embarrass much smaller models.
Llama 4 Scout is the context length champion. Its 10 million token window means you can feed it entire codebases, but the aggressive quantization required for 24GB VRAM does impact quality.
The MoE Advantage
Both Qwen3-30B-A3B and Llama 4 Scout use Mixture of Experts architectures. Here’s why that matters:
Traditional dense models activate every parameter for every token. A 30B model needs 30B parameters’ worth of compute per word. MoE models route each token to a small subset of “expert” subnetworks.
Qwen3-30B-A3B has 30.5 billion total parameters but activates only 3.3 billion per token. This means:
- Faster inference: Fewer calculations per token
- Lower memory bandwidth needs: Only active experts move through your GPU
- Similar quality: The full 30B of knowledge is still there, just selectively accessed
The catch? MoE models still need VRAM for all parameters, even inactive ones. You can’t fit a 30B MoE on an 8GB card just because it only activates 3B.
Coding Performance: The Numbers That Matter
If you’re using local models for development, coding benchmarks are more relevant than general reasoning:
On SWE-Bench Verified:
- Qwen3-30B-A3B: 69.6%
- Llama 4 Maverick: ~67% (comparable to DeepSeek V3)
- Gemma 3 27B: ~45%
On LiveCodeBench (fresh GitHub PRs):
- Qwen3-30B-A3B: 32.4% pass@5
- Qwen3-Coder-480B: 71.3% (but requires 64GB+ RAM)
The gap between flagship coding models and what fits on consumer hardware is significant. If coding is your primary use case, consider:
- Qwen3-30B-A3B on 24GB for the best local experience
- DeepSeek-R1-Distill-Qwen-14B on 16GB for reasoning-heavy tasks
- Qwen3 14B on 12GB for general development
Apple Silicon: A Different Calculation
M-series Macs with unified memory change the math. MLX benchmarks show:
- M4 Pro (24GB): Handles 7B-14B models comfortably
- M4 Max (64GB): Runs Qwen3-Coder-80B at Q4_K_M (48.5GB)
- MLX Framework: ~230 tok/s sustained on optimized models
The M4 Pro at 24GB unified memory offers better model flexibility than a 24GB discrete GPU because there’s no CPU/GPU memory split. The tradeoff is lower raw throughput compared to an RTX 4090.
Our Recommendations
Best overall (24GB VRAM): Qwen3-30B-A3B The MoE architecture delivers exceptional speed without sacrificing quality. Thinking mode rivals much larger models on complex reasoning.
Best for coding (16GB VRAM): Qwen3 14B or DeepSeek-R1-Distill-Qwen-14B The distilled DeepSeek model brings chain-of-thought reasoning to consumer hardware. Qwen3 14B is faster if you don’t need explicit reasoning traces.
Best context length (24GB VRAM): Llama 4 Scout Nothing else offers 10 million tokens in this VRAM class. Accept the quality tradeoffs for use cases that demand massive context.
Best multimodal (16GB+ VRAM): Gemma 3 27B Google’s image understanding capabilities set it apart. If you’re processing mixed text and images, Gemma 3 is the clear choice.
Best budget (8GB VRAM): Qwen3 8B Multilingual support and instruction following that punch above its weight class.
What This Means
The gap between open-weight and proprietary models continues shrinking. Onyx AI’s analysis shows open models now trail proprietary ones by only 5-7 quality index points on average.
More importantly, the MoE architecture revolution means you’re no longer choosing between speed and capability. Qwen3-30B-A3B delivers flagship-adjacent quality at 8B-like speeds.
If you have 24GB of VRAM and aren’t running a local model, you’re leaving capability on the table. The January 2026 integration of llama.cpp into Hugging Face made setup easier than ever. There’s no technical barrier left - just download and run.