Das beste lokale LLM für Programmierung im August 2026, nach VRAM: Qwen3-Coder 30B, gpt-oss-20b, Qwen 2.5 Coder 7B

Das beste lokale LLM fürs Programmieren im August 2026 wird in erster Linie durch deinen VRAM bestimmt. Wenn du eine 24-GB-Karte hast — eine RTX 3090 oder 4090 — führe Qwen3-Coder-30B-A3B-Instruct aus: 30B Gesamtparameter, von denen nur 3,3B pro Token aktiv sind, ein Kontextfenster von 262.144 Token und die insgesamt besten lokal messbaren Coding-Werte, die wir verifizieren können. Bei 16 GB ist es gpt-oss-20b, ein Apache-2.0-Mixture-of-Experts-Modell von OpenAI, das mit ~14 GB vollständig in die GPU passt und etwa 140 Token/s erreicht. Bei 8 GB ist es Qwen2.5-Coder-7B, das zuverlässige Arbeitstier mit ~4,7 GB. Der Rest dieser Seite beschreibt die Begründung, die Messwerte und die spezifischen Situationen, in denen jede dieser Empfehlungen falsch ist.

Was Seite eins richtig macht — und was sie auslässt

Das Ranking für „best local llm for coding" ist derzeit eine Mischung aus einem wirklich nützlichen Beitrag und viel Domain-Stärke. Tembos Leitfaden (5. Juni 2026) hat die Struktur richtig — er gliedert nach 8GB / 12–16GB / 24GB-Stufen und landet bei der Qwen-Coder-Familie — veröffentlicht aber keine Benchmark-Werte für die lokalen Modelle, keine Tokens-pro-Sekunde-Zahlen, keine Kontextfenstergrößen und keine Apple-Silicon-Empfehlungen nach RAM. Ein GitHub-Eval-Harness (gauravvij/local-llm-coding-eval) hat echte Zahlen, aber kein Urteil, und lief nur auf der CPU. Der Rest sind Meinungsbeiträge einzelner Autoren (XDA, Yahoo Tech) und dünne Listicles (apidog, Security Boulevard, SitePoint), die nach Domain-Stärke ranken und nicht danach, ob sie nützlich sind.

Was sie alle auslassen, geordnet nach dem, was es dich kostet:

• Die Agenten-Lücke. Codegenerierung ist nicht dasselbe wie das Steuern eines Agenten durch eine Änderung mehrerer Dateien. Die erste Seite erwähnt sie kaum; sie ist der Unterschied zwischen einem Modell, das man behält, und einem Modell, das man deinstalliert.

• Kontextfenster. Agentisches Codieren verbraucht Tokens beim Laden von Dateien und Testausgaben. Die Behauptung „30B passt in 24GB" ist bedeutungslos, bis man fragt, für welchen Kontext das gilt.

• Quantisierungsmathematik.Niemand erklärt, dass 4-Bit ungefähr so viele Gigabyte benötigt, wie das Modell Parameter hat, oder dass Q3 sich VRAM auf Kosten subtiler Syntaxfehler erkauft.

• Gemessene Geschwindigkeit. Wenige Artikel nennen Tokens/sec für die Modelle, die sie empfehlen, und diejenigen, die es tun, weichen stark voneinander ab, weil Kontext und Quantisierung alles verändern.

• Wenn lokal die falsche Wahl ist. Ein Feldtest aus 2026 an einer 15.000-zeiligen Flutter-App (EPAM) zeigt weiterhin, dass Cloud-Frontier-Modelle die schwierigsten mehrstufigen Refactorings für sich entscheiden. Keiner der Listicles verrät dir, wann du aufhören sollst.

Die VRAM-Mathe, die die meisten Listicles überspringen

Die Faustregel, die jede andere Zahl in diesem Artikel verständlich macht: {{1}}bei 4-Bit-Quantisierung entspricht der Speicherbedarf eines Modells grob seiner Parameteranzahl in Gigabyte — 7B ≈ 5GB, 30B ≈ 18GB+, vor KV-Cache-Overhead{{/1}}. {{2}}Q4 ist der Sweet Spot fürs Programmieren; Q3 und darunter sparen VRAM, führen aber messbar zu subtilen Syntaxfehlern{{/2}}. Und der KV-Cache wächst mit deinem Kontextfenster, weshalb „{{3}}ein 30B in 24GB passt{{/3}}“ nur bei einem Kontext gilt, den du tatsächlich angeben musst.

Mixture-of-Experts verändert die Mathematik auf eine Weise, die für die beiden großen Empfehlungen unten relevant ist. Die Gesamtparameter bestimmen den Fußabdruck; die aktiven Parameter bestimmen die Geschwindigkeit. Deshalb fühlen sich Qwen3-Coder-30B-A3B (30B gesamt, 3,3B aktiv) und gpt-oss-20b (20,9B gesamt, 3,61B aktiv) beide viel schneller an, als es ihr Gewicht auf der Festplatte vermuten lässt, und weshalb DeepSeek V4 Flash — 284B gesamt, 13B aktiv — trotz günstiger API eine schlechte lokale Wahl ist.

24 GB VRAM: Qwen3-Coder 30B

Qwen3-Coder-30B-A3B-Instruct ist derzeit der stärkste lokale Allround-Coder, auf den wir verweisen können. Im Juli 2025 von Alibabas Qwen-Team unter Apache 2.0 veröffentlicht, ist es ein Mixture-of-Experts-Modell mit insgesamt 30B Parametern und 3,3B aktiven pro Token, einem Kontextfenster von 262.144 Token und einem 4-Bit-Speicherbedarf von etwa 17–20 GB — was auf einer 24-GB-Karte echten Spielraum für den KV-Cache lässt, den eine lange Programmier-Sitzung benötigt.

In dem unabhängigen lokalen Testrahmen, dem wir am meisten vertrauen (gauravvij/local-llm-coding-eval, vier Modelle werden lokal über Ollama auf der CPU ausgeführt), erzielte qwen3-coder:30b 80 % bei der Codegenerierung, 77 % bei der Toolauswahl und 80 % bei der Agentengenauigkeit – das ausgewogenste Ergebnis der vier und das einzige Modell, das bei allen drei Aufgaben gleichzeitig stark war. Drittanbieter-Tracker beziffern sein SWE-bench Verified auf etwa 50,3, Aider Polyglot auf 66,2 und LiveCodeBench v6 auf 58,9; behandeln Sie diese als zusammengestellte Zahlen, nicht als offizielle Alibaba-Zahlen – Letzteres ist alles, was Qwen für dieses Modell veröffentlicht hat.

Die gemessene Geschwindigkeit variiert stark je nach Hardware. Die nützlichsten Datenpunkte: Ein Community-TurboQuant-Setup betreibt es auf einer 8-GB-RTX-3060-Ti mit etwa 29 Token/s Generierung bei vollem 262K-Kontext, und der oMLX-Benchmark maß den 4-Bit-MLX-Build auf einem M4 Pro (48 GB) mit 73,6 Token/s bei 1K-Kontext, abfallend auf 13,5 Token/s bei 64K. Auf einer 24-GB-Karte in einem normalen Ollama-Setup solltest du den Bereich von zig Token pro Sekunde erwarten, nicht hunderte – der Preis dafür, einen nahezu modernsten Coder zu Hause auszuführen.

Der ehrliche Hinweis: Es ist nicht der schnellste lokale Coder, und ein neueres Qwen3-Coder-Next existiert, das eher für gehostete und CLI-Nutzung gedacht ist als für quantisierte lokale Installationen. Aber für agentische, repo-weite Arbeit auf einer einzelnen Karte ist Qwen3-Coder-30B heute die richtige Wahl.

16GB VRAM: gpt-oss-20b

Auf einer 16-GB-Karte lautet die Antwort gpt-oss-20b — und das ist nicht einmal knapp. Am 5. August 2025 von O​penAI unter Apache 2.0 veröffentlicht, ist es ein Mixture-of-Experts-Modell mit 20,9 Milliarden Gesamtparametern und 3,61 Milliarden aktiven Parametern pro Token, einem Kontextfenster von 131.072 Token, und seine native MXFP4-Quantisierung kommt auf etwa 14 GB. Das ist die entscheidende Tatsache: Es läuft zu 100 % auf der GPU einer 16-GB-Karte, ohne dass etwas in den Systemspeicher ausgelagert wird.

Warum die On-GPU-Residenz wichtiger ist als jeder Benchmark: Ein Modell, das in den VRAM passt, ist 3–11x schneller als eines, das auslagert. Ein unabhängiger Benchmark maß 139,93 Tokens/Sek. für gpt-oss-20b auf einer RTX 4080 — etwa 2,8x eine dichte Alternative bei gleicher Speichergröße — und die Bewertung eines Testers aus dem Jahr 2026 ergab einen „Intelligenzindex“ von 52,1, wobei es als unübertroffen in der 16-GB-Klasse für professionelles Programmieren und Debugging bezeichnet wurde. Es passt knapp, also führen Sie es allein aus und halten Sie den Kontext moderat; die Qualität nimmt am oberen Ende des Fensters ab.

Die agentische Alternative auf 16 GB ist Devstral 24B (devstral-small-2:24b), die den einzigen veröffentlichten SWE-bench-Verified-Wert unter den lokalen Codern der 16-GB-Klasse aufweist — 46.8% — aber sie ist langsam und erfordert oft CPU-Offloading bei ~18 Token/s. Wenn deine Arbeit aus Agent-Edits über mehrere Dateien besteht und du die Geschwindigkeit in Kauf nehmen kannst, hat Devstral seinen Platz verdient; wenn du Geschwindigkeit plus sauberen Code willst, ist gpt-oss-20b die bessere Standardoption. Dense-14B-Modelle — Qwen3-Coder 14B oder Qwen2.5-Coder 14B bei Q5 — sind die komfortablen, günstigen Fallbacks.

8GB VRAM: Qwen 2.5 Coder 7B

Bei 8 GB lautet die ehrliche Antwort Qwen2.5-Coder-7B: 7B Parameter bei ~4,7 GB in Q4_K_M, ein nativer Kontext von 32.768 Token, erweiterbar auf 128K, und die stärksten Code-Vervollständigungs-Benchmarkwerte in der 7B-Klasse. Es ist ein älteres Modell – veröffentlicht im November 2024 – und das ist in Ordnung, denn nichts Neueres im 8-GB-Bereich hat es entthront. Community-Tests verorten es bei etwa 50 Token/s auf einer RTX 4060 oder 3070; ein unabhängiger RTX-4060-Test im März 2026 maß 28–35 Token/s, eine Spanne, die fast ausschließlich durch die Kontexteinstellungen bestimmt wird.

Drei Dinge sind bei 8 GB wichtig, die anderswo keine Rolle spielen. Erstens: Begrenze den Kontext auf 4–8K. Es ist der KV-Cache, der den Speicher einer 8-GB-Karte sprengt, nicht die Gewichte — ein Benchmark zeigte einen Geschwindigkeitssprung von ~3,6 auf ~37 Tokens/Sekunde, allein durch die Begrenzung des Kontexts. Zweitens: Überprüfe mit ollama ps, dass das Modell zu 100 % auf der GPU läuft; jeder CPU-Anteil bedeutet einen Geschwindigkeitseinbruch. Drittens: Q4_K_M, nicht Q3 — Q3-Syntaxfehler kosten dich mehr, als du an VRAM sparst.

Die bemerkenswerte Entwicklung im Jahr 2026 ist, dass Qwen3-Coder-30B-A3B-Instruct nun mithilfe der TurboQuant-KV-Cache-Kompression auf 8 GB gequetscht werden kann – ein Community-Setup maß etwa 7,5 GB und ~29 Token/s auf einer RTX 3060 Ti bei vollem 256K-Kontext. Es funktioniert, und es ist fummelig genug, dass wir es nicht als Standard empfehlen. Wenn Sie eine neuere Option wünschen, die sofort einsatzbereit ist, ist Qwen3 8B (~5,2 GB, hybrider Denkmodus) ein kleiner Schritt gegenüber Qwen2.5-Coder-7B beim allgemeinen Denken, bleibt aber beim reinen Code etwas zurück.

Was ist mit Apple Silicon?

Unified Memory verändert das Kalkül in eine Richtung: Die Kapazität steigt, die Generierungsgeschwindigkeit sinkt. Ein M4 Pro mit 48 GB kann Modelle halten, die eine Windows-Grafikkarte mit 16 GB nicht kann, aber er generiert bei langem Kontext Token weitaus langsamer. Die Zahlen, die wir haben: Der 4-Bit-MLX-Build von Qwen3-Coder-30B-A3B-Instruct belegte auf einem M4 Pro 16,6 GB bei 1K-Kontext und 25,5 GB bei 64K-Kontext, wobei die Generierungsgeschwindigkeit von 73,6 Token/Sek. auf 13,5 Token/Sek. fiel, als der Kontext wuchs (oMLX-Benchmark). gpt-oss-20b passt bequem in 16 GB Unified Memory und ist eine gute Wahl für den Mac. Wenn du Multimodalität auf Apple Silicon möchtest: Gemma 4 12B läuft mit rund 16 GB Unified Memory und einem 256K-Kontext – die stärkste lokale Option, wenn deine Programmierarbeit neben bildlastigen Dokumenten stattfindet.

Die unabhängigen Zahlen: Codegen ist nicht die Fähigkeit, die zählt.

Die klarsten Daten, die wir gefunden haben, sind ein einzelner lokaler Benchmark, der es wert ist, vollständig zitiert zu werden. gauravvij/local-llm-coding-eval führte vier Modelle lokal über Ollama aus, auf CPU, ohne Cloud – Codegenerierung, Funktionsaufrufe und eine mehrstufige Agentenaufgabe – mit Ergebnissen, die gegen die Intuition „größere Codegen-Zahl gewinnt" sprechen:

• Qwen3.6 27B (qwen3.6:27b, dense, ~17GB): 80.0% Codegen, 84.6% Tools, 100% Agent — der beste Allrounder.

• Qwen3.6 35B A3B (qwen3.6:35b-a3b, MoE, ~18 GB): 70,0 % Codegen, 84,6 % Tools, 100 % Agent.

• Qwen3-Coder-30B-A3B-Instruct (qwen3-coder:30b, MoE, ~17GB): 80.0 % Codegenerierung, 76.9 % Tools, 80 % Agent — am ausgewogensten.

• DeepSeek-Coder-V2 33B (deepseek-coder:33b, dense, ~18GB): 90,0 % Codegenerierung — das Beste der vier — aber 10 % Agent, Schlusslicht bei mehrstufiger Arbeit.

Dieser letzte Satz ist die ganze Lektion. Ein Modell, das bei reiner Codegenerierung Spitzenwerte erzielt, aber bei Agentenaufgaben zusammenbricht, ist das Modell, das du nach der ersten „Lies diese Datei, ändere diese Funktion, führe den Test aus“-Schleife deinstallieren wirst. Beurteile einen lokalen Coder anhand der Agenten-Spalte, nicht anhand der Codegen-Spalte.

Wenn das lokale Ausführen die falsche Entscheidung ist.

Local-first ist die richtige Standardwahl für Datenschutz, Offline-Arbeit, null marginale Token-Kosten und Autovervollständigung, bei der Latenz wichtiger ist als maximale Qualität. Es ist die falsche Entscheidung in bestimmten, erkennbaren Situationen – und das ist der Abschnitt, den man auf Seite eins überspringt:

• Die schwierigste agentische Arbeit schlägt dich immer noch.EPAMs Feldtest 2026 an einer 15.000 Zeilen umfassenden Flutter-App ergab, dass Cloud-Frontier-Modelle (GPT-5.3-codex) lokale Modelle bei den komplexesten mehrstufigen Refactorings weiterhin übertreffen. Wenn dein Tag aus achtstündigen Refactorings von Legacy-Code besteht, ist lokal noch nicht bereit.

• Deine Kontextanforderungen übersteigen deine Grafikkarte. Ein Coding-Agent, der ein ganzes Repository lädt, sprengt den KV-Cache, den eine 16-GB-Karte aufnehmen kann. Dank seines 256K-Kontexts gewinnt Qwen3-Coder-30B die 24-GB-Klasse — kleinere Karten verlieren dieses Spiel früh.

• Man kann nicht ständig auf die Hardware aufpassen. Die Hardware kostet echtes Geld: Eine 24-GB-Karte liegt in der Preisklasse von 700–1.600 Dollar, plus Strom und Wartung. Bei geringer Auslastung sind API-Aufrufe günstiger als der Stromverbrauch.

• DeepSeek V4 Flash ist der Beweis. Bei insgesamt 284B Parametern machen allein die 4-Bit-Gewichte von DeepSeek V4 Flash etwa 140GB aus – kein Modell für Consumer-Grafikkarten, Punkt. Genau das Design mit 13B aktiven Parametern ist der Grund, warum die API schnell und günstig ist: $0,15 / $0,29 pro 1M Tokens (MIT, 1M Kontext). Bei diesem Modell ist „lokal ausführen“ die falsche Frage; die API ist der Punkt.

• Teams brauchen Konsistenz.Wenn vier Ingenieure jeweils eine andere Quantisierung eines anderen Modells ausführen, wird „funktioniert auf meinem Rechner“ zu einem Build-Risiko. Gemeinsame API-Endpunkte geben Ihnen ein deterministisches Ziel.

Wenn Sie die Antwort von der API-Seite auf dieselbe Frage wünschen – welches Cloud-Coding-Modell das Standardmodell ist, wenn lokale Modelle nicht der richtige Kompromiss sind – haben wir dies separat in unserem Ratgeber zum besten LLM fürs Codieren behandelt, und unser Artikel über KI-Coding-Agenten deckt Hilfsmittel wie Cline und OpenCode ab, die mit diesen lokalen Modellen arbeiten.

So testen Sie die Karte, bevor Sie sie kaufen

Der günstigste Weg, sich zu entscheiden, ist, eigene Prompts auszuprobieren, bevor man sich auf Hardware festlegt. Mit Ollama oder LM Studio läuft jede der drei Optionen in Minuten, und der Test, der zählt, sind die echten Dateien in deinem Repository, kein Benchmark. Ein Router verdient seinen Platz bei der damit verbundenen Entscheidung: Wenn man ein lokales Modell mit gehosteten Frontier-Modellen vergleicht, lässt ein einziger Endpoint denselben Prompt durch beide laufen, ohne mehrere Schlüssel verwalten zu müssen. Auf OrcaRouter wird DeepSeek V4 Flash zum Listenpreis des Anbieters unverändert durchgereicht – $0.15 / $0.29 pro 1M Tokens, 0% Aufschlag – mit automatischem Failover, was es zu einem günstigen und ehrlichen Maßstab für die Frage macht: „Ist mein lokales Modell tatsächlich besser als die $0.15-API?“

Ein ehrlicher Vorbehalt: OrcaRouter hostet weder Qwen3-Coder-30B-A3B-Instruct noch gpt-oss-20b. Wenn Ihr Ziel strikt offline ist, ist ein Router für Sie irrelevant – hosten Sie selbst, und Sie sind fertig. Wenn Ihr Ziel darin besteht, dasselbe Open-Weight-Modell im A/B-Vergleich gegen die Frontier-Modelle zu testen, bevor Sie für eine Grafikkarte ausgeben, besteht die Aufgabe des Routers im Vergleich, nicht im Hosting.

Das Fazit

Dein VRAM entscheidet zuerst, die Modellqualität erst an zweiter Stelle. Mit 24 GB nutze Qwen3-Coder-30B-A3B-Instruct – den stärksten Allround-Lokal-Coder mit dem 256K-Kontext, den agentisches Arbeiten braucht. Mit 16 GB nutze gpt-oss-20b – das seltene Modell, das sowohl schnell als auch vollständig auf der GPU läuft. Mit 8 GB nutze Qwen2.5-Coder-7B und halte deinen Kontext bescheiden. Beurteile jedes davon anhand der Agentic-Spalte, nicht der Codegen-Spalte, und akzeptiere, dass die schwierigsten Multi-Datei-Refactorings weiterhin der Cloud vorbehalten bleiben. Die obigen Zahlen gelten Stand 10. August 2026 – überprüfe die Aufstellung und Listenpreise erneut, bevor du Geld ausgibst, denn dieser Bereich verändert sich wöchentlich.