Best Ollama Coding Models by NVIDIA RTX GPU: VRAM Tier Guide

Model listings checked on October 14, 2026. The picks below are a test order for different workloads, not results from a new controlled coding benchmark. Leave memory for context and runtime buffers as well as model weights.

The right local coding model is the largest one that fits entirely in your GPU’s VRAM, with room left for context. That last part matters more than people expect. A 32B model that runs at 60 tokens per second when it fits in VRAM drops to 1-2 tokens per second the moment it spills into system RAM. For a coding agent that loops through dozens of tool calls, that is the difference between usable and abandoned.

So the question is not “what is the best Ollama coding model,” it is “what is the best model my card can hold.” This guide maps current NVIDIA RTX consumer GPUs to the coding model that fits, the speed to expect, and the point where you should stop forcing local inference and reach for a cloud model.

For the model rankings on their own merits, see best Ollama models for coding agents. This post is the hardware companion to it.

Quick map: GPU to model

GPU	VRAM	Current candidates to test	Context budget
RTX 5090	32GB	qwen3.8:27b, muse-glimmer:30b, qwen3-coder:30b	Begin bounded; measure before expanding
RTX 4090 / 3090	24GB	Same workstation candidates with a suitable build	Less headroom; inspect actual allocation
RTX 5070 Ti / 4070 Ti Super / 4060 Ti 16GB	16GB	gemma4:e4b, qwen3:8b, smaller verified 14B builds	Shorter context; account for runtime overhead
RTX 3060 12GB	12GB	qwen3:8b, gemma4:e4b if the build fits	Short context
8GB cards	8GB	A smaller Gemma or Qwen build that actually fits	Check weights plus context, not name alone

No new tokens-per-second benchmark was run for this refresh. Older speed numbers cannot be assigned to Qwen3.8 or Muse Glimmer. Use ollama ps during a representative task to inspect residency and memory use.

32GB: RTX 5090

Compare Qwen3.8 27B, Muse Glimmer 30B, and Qwen3 Coder 30B on the same repository task. The Qwen3.8 and Muse Glimmer default downloads are about 18GB, leaving some room on a 32GB card for context and runtime buffers.

ollama pull qwen3.8:27b

Download size is not the full working allocation. Measure memory and latency at your intended context size before choosing a default. Nemotron 3.5 Lightning has a larger default download of about 25GB; long contexts require more headroom.

24GB: RTX 4090 and RTX 3090

Qwen3.8 27B, Muse Glimmer 30B, and Qwen3 Coder 30B are candidates for this tier. An approximately 18GB download leaves less headroom on 24GB hardware than on a 32GB card. Check your actual context allocation rather than assuming the maximum advertised window fits.

ollama pull qwen3.8:27b

Different quantizations change both quality and memory use. Use a tag listed by the model publisher, then compare correct task completion and latency on your card.

16GB: RTX 5070 Ti, 4070 Ti Super, 4060 Ti 16GB

Start with Gemma 4 E4B, Qwen3 8B, or a verified smaller build of Qwen3 14B. Keep room for context and runtime buffers.

ollama pull qwen3:8b

gpt-oss 20B has an approximately 14GB download, so 16GB hardware can be tight during an agent session. Short contexts may work, but check actual allocation. A MoE model’s active parameters describe computation, not how many expert weights must be stored.

12GB: RTX 3060 12GB and similar

At 12GB the sweet spot is the 8B class. Qwen3 8B runs at interactive speeds and handles the everyday agent work: explaining unfamiliar code, writing small functions, drafting tests, summarizing logs.

ollama pull qwen3:8b

You can squeeze a 14B model at Q4 (about 8GB) onto a 12GB card, but context space gets tight quickly. For a smooth agent loop, an 8B model that stays fully resident usually feels better than a 14B model fighting for memory.

8GB: entry-level cards

Eight gigabytes needs a small build and a short context. Check the actual Gemma 4 E4B or Qwen3 8B download plus runtime allocation before assuming it fits.

ollama pull gemma4:e4b

Set expectations accordingly. This tier is good for code explanation, boilerplate, and small single-file edits. It is not the place to run a coding agent through a multi-file refactor. Smaller models lose the thread once the agent starts opening files, revising patches, and juggling tool output.

The rule that beats every benchmark

Keep the model fully in VRAM. Everything else is secondary.

• CPU offload can sharply reduce throughput; measure the actual model and offload configuration
• Quantization is how you make a model fit: Q4_K_M is the practical default, Q5/Q8 only when you have spare VRAM
• Prompt processing is fast on every card; token generation is the bottleneck, and it scales with memory bandwidth
• A smaller model that stays resident beats a bigger model that swaps, every time

When you are picking a quant, leave headroom for context. A model that fits at 0K context but overflows at 16K will swap mid-session, which is the worst case.

When to use a cloud model instead

Local is best when privacy, cost, or offline work matters. It is not automatically better for every task, and no consumer GPU changes that. Reach for a cloud model when:

• The task spans many files
• The bug is subtle and needs strong reasoning
• You need reliable tool calling
• The change will touch production
• You do not have time to review every generated line

The practical setup is local-first, not local-only. Run Qwen3 Coder or a 14B model on your RTX card for cheap private work, then escalate to a stronger cloud model when the task gets hard.

How to route local and cloud together

• haimaker.ai — a cloud provider you can configure alongside Ollama in your agent, with one key for the cloud models you compare
• Ollama — runs the local model on your RTX card with an OpenAI-compatible API on localhost
• Your coding agent — point OpenCode, OpenClaw, or any OpenAI-compatible agent at the local endpoint for cheap work and the cloud endpoint for everything else

ROUTE LOCAL AND CLOUD MODELS WITH HAIMAKER

The bottom line

Choose a model and context that fit your actual card. Test current workstation candidates on 24–32GB hardware and smaller builds below that. A newer model is useful only if it finishes the task accurately at a latency you can tolerate.

---

For the model rankings on their own merits, see best Ollama models for coding agents. For OpenClaw-specific local setup, see best local models for OpenClaw.