Schnelle Fakten — Lokale Coding-LLMs auf einen Blick
- Bestes Gesamtmodell: Qwen3.8 27B (Alibaba) — dicht 27B, Apache 2.0, 18 GB bei Ollama, 256K Kontext, 61,7 SWE-bench Pro, 90,3 LiveCodeBench v6 (laut Qwen).
- Vorherige Qwen-Generation: Qwen 3.6 27B — 77,2 % SWE-bench Verified und 53,5 SWE-bench Pro (laut Qwen); weiterhin eine solide Alternative, von Qwen3.8 27B abgelöst.
- Am besten für agentisches Coding bei 24B: Devstral Small 2 (Mistral AI, Frankreich) — 15 GB, 65,8 % SWE-bench Verified, Apache 2.0, Tool-Aufrufe und Multi-Datei-Änderungen. Benötigt Ollama 0.13.3 oder neuer.
- Am besten für lange agentische Sitzungen: Laguna XS 2.1 (Poolside) — 33B gesamt / 3B aktiv (MoE), 20 GB, 256K Kontext, SWE-bench Verified 70,9 %, SWE-bench Multilingual 63,1 %, OpenMDW-1.1-Lizenz.
- Großes MoE für 64-GB-Rechner: Qwen3-Coder-Next — 80B gesamt / 3B aktiv, 52 GB (Q4), 256K Kontext.
- Am besten für IDE-Autovervollständigung: Codestral 22B (Mistral) — FIM-optimiert, Continue.dev-Integration, 13 GB, 32K Kontext.
- Am besten für 8 GB RAM: Qwen3 8B — nutzt 5 GB VRAM, bestes Qualität-Geschwindigkeit-Verhältnis.
- Offene Gewichte im Frontier-Maßstab: Kimi K2.6 und Kimi K2.7 Code (Moonshot AI) — 1T gesamt / 32B aktiv (MoE), 256K Kontext. Ollama bietet nur `:cloud`-Tags; lokale GGUF-Builds brauchen je nach Quantisierung etwa 310–470 GB.
- Benchmark-Wechsel: SWE-bench Pro und Verified (echte GitHub-Issues) sind die Hauptmetriken für praktisches Coding. HumanEval (einzelne Python-Funktionen) bleibt für den Vergleich kleiner Modelle nützlich.
- Empfohlene Ausstattung: 24-GB-GPU oder 32 GB Unified Memory (Qwen3.8 27B; macOS belegt auf einem Mac etwa 8 GB); 16 GB genügen für Devstral Small 2.
🏆 Beste lokale LLMs für Programmierung (Schnellauswahl)
- Bestes Gesamtmodell: Qwen3.8 27B — dicht 27B, 18 GB, 256K Kontext, 61,7 SWE-bench Pro (laut Qwen). `ollama run qwen3.8`
- Am besten für agentisches Coding bei 24B: Devstral Small 2 — Multi-Datei-Änderungen, Tool-Aufrufe, 15 GB. `ollama run devstral-small-2`
- Am besten für lange agentische Sitzungen: Laguna XS 2.1 — 33B/3B aktiv (MoE), 20 GB, 256K Kontext. `ollama run laguna-xs-2.1`
- Großes MoE (64-GB-Rechner): Qwen3-Coder-Next — 80B/3B aktiv, 52 GB. `ollama run qwen3-coder-next`
- Am besten für repository-bewusste Vervollständigung mit 24 GB: Qwen3-Coder 30B — 30B/3,3B aktiv (MoE), 19 GB, 256K Kontext. `ollama run qwen3-coder:30b`
- Am besten für IDE-Autovervollständigung: Codestral 22B — FIM-optimiert für Continue.dev, 13 GB. `ollama run codestral:22b`
- Am besten für 8 GB RAM: Qwen3 8B — 5 GB VRAM. `ollama run qwen3:8b`
- 👉 Wenn du unsicher bist: Qwen3 8B auf Laptops mit 8–16 GB, Qwen3.8 27B mit einer 24-GB-GPU oder einem 32-GB-Mac.
- 👉 Mit 16 GB: Devstral Small 2 passt am besten für agentisches Coding; Qwen3.8 27B (18 GB) braucht eine 24-GB-Karte oder einen Mac mit 32 GB.
- 👉 Für lange agentische Sitzungen: Laguna XS 2.1 oder Devstral Small 2.
- 👉 Für IDE-Vervollständigung: Codestral 22B mit Continue.dev.
🛠️Praxis-Tipp: Passe die Modellgröße zuerst an deine Hardware an. Mit 8 GB nimm Qwen3 8B, mit 16 GB Devstral Small 2, mit einer 24-GB-GPU oder einem 32-GB-Mac Qwen3.8 27B. Kimi K2.6 und K2.7 Code sind keine praktische lokale Wahl: Ollama bietet sie nur als Cloud-Tags, lokale Builds brauchen 300 GB oder mehr.
In einem Satz
Das beste lokale Coding-LLM 2026 ist Qwen3.8 27B (18 GB, 61,7 SWE-bench Pro laut Qwen), mit Devstral Small 2 für agentisches Coding mit 16 GB, Laguna XS 2.1 für lange Sitzungen, Codestral 22B für IDE-Autovervollständigung und Qwen3 8B für 8 GB RAM.
In einfachen Worten
Ein lokales Programmiermodell zu betreiben ist wie einen AI-Coding-Assistant auf dem Laptop zu installieren — es hält deinen Code privat, funktioniert offline, ist aber langsamer als Cloud-APIs wie GitHub Copilot.
Was macht ein lokales LLM gut für Programmierung?
2026 haben SWE-bench Pro und SWE-bench Verified HumanEval weitgehend als praxisnahe Coding-Benchmarks abgelöst. Sie testen, ob ein Modell echte GitHub-Issues lösen kann — Änderungen über mehrere Dateien, Verständnis von Codebasen, Tests schreiben — nicht nur einzelne Funktionen. Qwen gibt 61,7 auf SWE-bench Pro für Qwen3.8 27B an und 77,2 % auf SWE-bench Verified für das ältere Qwen 3.6 27B.
Code-spezifische Modelle werden auf großen Code-Korpora (GitHub, Stack Overflow, Dokumentation) feinabgestimmt und beinhalten oft Fill-in-the-Middle-Training (FIM) -- die Fähigkeit, Code anhand des Kontexts vor und nach dem Cursor zu vervollständigen, was für IDE-Autovervollständigung erforderlich ist.
Allgemeine Modelle wie Llama 3.1 8B erreichen 72 % bei HumanEval, was konkurrenzfähig ist. Dedizierte Coding-Modelle gleicher Größe liegen aber 5-15 % höher, weil Trainingsdaten und Feinabstimmung auf Code-Genauigkeit statt allgemeine Sprachaufgaben ausgerichtet sind.
📌Hinweis: Von Herstellern gemeldete SWE-bench-Werte nutzen unterschiedliche Agent-Umgebungen, Aufgabensätze und Einstellungen (Qwens 61,7 auf SWE-bench Pro nutzt die Claude-Code-Umgebung mit korrigierten Aufgaben); zwei veröffentlichte Zahlen sind daher Richtwerte, kein direkter Vergleich. HumanEval bleibt für den Vergleich einzelner Funktionen nützlich, aber SWE-bench sagt die Leistung in echten Entwicklungs-Workflows besser voraus.
#1 Qwen3.8 27B -- Bestes lokales Coding-LLM insgesamt
Qwen3.8 27B (Alibaba, veröffentlicht im August 2026) ist das beste lokale Coding-LLM für eine 24-GB-GPU oder einen Mac mit 32 GB. Es ist ein dichtes 27B-Modell (alle Parameter pro Token aktiv) unter Apache 2.0. Qwen gibt 61,7 auf SWE-bench Pro, 73,0 auf Terminal Bench 2.1 und 90,3 auf LiveCodeBench v6 an. Der Ollama-Download umfasst 18 GB bei 256K Kontextfenster.
`ollama run qwen3.8`. Es akzeptiert Text und Bilder, unterstützt Tool-Aufrufe und den Denkmodus und eignet sich für Multi-Datei-Analyse, Debugging und Refactoring. Für das vorherige Qwen 3.6 27B meldete Qwen 53,5 auf SWE-bench Pro (77,2 % auf SWE-bench Verified); `ollama run qwen3.6:27b` bleibt eine gültige Alternative.
Spezifikation | Wert |
|---|---|
| SWE-bench Pro | 61,7 (laut Qwen) |
| LiveCodeBench v6 | 90,3 (laut Qwen) |
| Architektur | Dicht (alle 27B aktiv) |
| Ollama-Größe (Q4_K_M) | 18 GB |
| Kontextfenster | 256K Tokens |
| Lizenz | Apache 2.0 |
| Ollama-Befehl | ollama run qwen3.8 |
🔍Erkenntnis: Qwen führt SWE-bench Pro mit der Claude-Code-Umgebung und einem überarbeiteten Aufgabensatz mit korrigierten Problemaufgaben aus; 61,7 ist daher nicht direkt mit Werten anderer Hersteller vergleichbar. Es ist ein starkes Herstellersignal, kein direkter Vergleichstest.
#2 Devstral Small 2 -- Am besten für agentisches Coding bei 24B
Devstral Small 2 (Mistral AI) ist für agentische Coding-Workflows gebaut — Multi-Datei-Änderungen, Codegenerierung mit Tool-Aufrufen und Debugging-Schleifen. 24B Parameter, 15 GB bei Ollama, 65,8 % auf SWE-bench Verified (laut Mistral), Apache 2.0. `ollama run devstral-small-2` (erfordert Ollama 0.13.3 oder neuer).
Die beste Wahl für Entwickler, die aider, Claude-Code-ähnliche Workflows oder mehrstufige Code-Änderungen auf einem 16-GB-Rechner nutzen. Es liest Fehlermeldungen, ändert Code über mehrere Dateien hinweg und unterstützt Bildeingabe.
Spezifikation | Wert |
|---|---|
| SWE-bench Verified | 65,8 % (laut Mistral) |
| Am besten für | Agentische Workflows, Multi-Datei |
| Ollama-Größe | 15 GB |
| Kontextfenster | 384K Tokens (Ollama) |
| Lizenz | Apache 2.0 |
| Ollama-Befehl | ollama run devstral-small-2 |
💡Tipp: Agentisches Coding = nachdenken → Code schreiben → ausführen → Fehler beobachten → korrigieren → wiederholen. Devstral Small 2 beherrscht diese Schleife mit 15 GB Speicherbedarf und ist damit die praktische agentische Wahl für 16-GB-Rechner, auf denen Qwen3.8 27B (18 GB) nicht passt.
#3 Laguna XS 2.1 und Qwen3-Coder-Next -- Agentisches Coding über lange Sitzungen
Laguna XS 2.1 (Poolside, 2. Juli 2026) zielt auf agentisches Coding über lange Zeiträume. 33B gesamt / 3B aktiv (MoE), 256K Kontext, OpenMDW-1.1-Lizenz, SWE-bench Verified 70,9 % und SWE-bench Multilingual 63,1 %. Der Ollama-Standard umfasst 20 GB (Q4_K_M). `ollama run laguna-xs-2.1`.
Qwen3-Coder-Next (Alibaba, Februar 2026) ist die größere MoE-Option für 64-GB-Rechner: 80B gesamt / 3B aktiv, 52 GB bei Q4_K_M, 256K Kontext. `ollama run qwen3-coder-next`. Als kleinerer repository-bewusster Coder für 24 GB ist `ollama run qwen3-coder:30b` (30B gesamt / 3,3B aktiv, 19 GB, Apache 2.0) die etablierte Alternative.
Wer das größte Kontextfenster für mehrstündige agentische Sitzungen will, wählt Laguna XS 2.1; wer ein europäisches Apache-2.0-Modell mit kleinerem Speicherbedarf will, wählt Devstral Small 2.
Spezifikation | Wert |
|---|---|
| Laguna XS 2.1 Größe | 20 GB (33B gesamt / 3B aktiv) |
| Laguna XS 2.1 SWE-bench | 70,9 % Verified / 63,1 % Multilingual |
| Qwen3-Coder-Next Größe | 52 GB (80B gesamt / 3B aktiv) |
| Kontextfenster | 256K Tokens (beide) |
| Ollama-Befehle | laguna-xs-2.1 / qwen3-coder-next |
🔍Erkenntnis: MoE-Modelle halten alle Parameter im Speicher, rechnen aber pro Token nur mit wenigen Milliarden, daher erzeugen sie für ihre Größe schnell Text, brauchen aber trotzdem RAM für die vollständigen Gewichte (20 GB für Laguna XS 2.1, 52 GB für Qwen3-Coder-Next).
#4 Codestral 22B -- Am besten für IDE-Autovervollständigung
Codestral 22B (Mistral AI) bleibt das dedizierte FIM-Modell für IDE-Autovervollständigung. Gebaut für Fill-in-the-Middle-Vervollständigung mit Continue.dev in VS Code und Cursor. Es ist das älteste Modell auf dieser Seite (der Ollama-Build ist etwa zwei Jahre alt) und bleibt die am stärksten auf FIM ausgerichtete Option.
`ollama run codestral:22b`. Trainiert für IDE-typische Vervollständigung, bei der der Kontext vor und nach dem Cursor liegt. Stark bei Python, JavaScript, TypeScript, Go und Rust. Der Ollama-Build hat ein Kontextfenster von 32K.
Für repository-bewusste Vervollständigung ist `ollama run qwen3-coder:30b` die stärkste offene Alternative (Apache 2.0, 19 GB). Als kleines Coding-Modell mit Reasoning für 16 GB ist `ollama run gpt-oss:20b` (OpenAI Open-Weight, 21B gesamt / 3,6B aktiv, einstellbares Reasoning) ebenfalls eine solide Wahl.
Spezifikation | Wert |
|---|---|
| Am besten für | FIM (IDE-Autovervollständigung) |
| Ollama-Größe | 13 GB |
| Kontextfenster | 32K Tokens |
| FIM-Unterstützung | Ja (Hauptanwendung) |
| IDE-Integration | Continue.dev, Cursor |
| Ollama-Befehl | ollama run codestral:22b |
🔍Erkenntnis: Codestral 22B von Mistral AI ist speziell für FIM-Vervollständigung (Fill-in-the-Middle) gebaut. In Kombination mit Continue.dev bietet es eine lokale Alternative zur GitHub-Copilot-Autovervollständigung.
#5 Qwen3 8B -- Bestes Coding-Modell für 8 GB RAM
Qwen3 8B ist die Empfehlung für 8 GB beim Programmieren. Starke Coding-Leistung, mehrsprachig, nutzt nur 5 GB VRAM. Qwen3.8 gibt es bei Ollama derzeit nur als 27B-Modell, daher bleibt Qwen3 8B die kleinste aktuelle Qwen-Wahl. Details zu VRAM-Anforderungen anderer Coding-Modelle findest du im VRAM-Leitfaden →. `ollama run qwen3:8b`.
🔍Erkenntnis: Qwen3 8B ist der empfohlene Einstieg für 8-GB-Rechner: starke Mehrsprachigkeit, schnelle Inferenz und gute Code-Qualität bei realen Aufgaben.
Warum Kimi K2.6 und K2.7 Code keine praktische lokale Wahl sind
Kimi K2.6 und Kimi K2.7 Code (Moonshot AI) sind die größten offenen Coding-Modelle in dieser Liste, aber keine Wahl für Consumer-Hardware. Beide sind MoE-Modelle mit 1T Parametern, 32B aktiven Parametern und 256K Kontextfenster. Moonshot AI gab für Kimi K2.6 58,6 auf SWE-bench Pro an; Kimi K2.7 Code baut auf K2.6 für lange Coding-Sitzungen auf.
Bei Ollama sind beide nur als Cloud-Tags gelistet (`kimi-k2.6:cloud`, `kimi-k2.7-code:cloud`), die deine Prompts an Ollamas gehosteten Dienst senden. Lokal geht es nur über einen Community-GGUF-Build: Unsloth nennt für K2.7 Code etwa 310 GB bei 1-Bit und 325–350 GB bei 2-Bit-Quantisierung, die Modelle gehören also auf Workstation- oder Server-Hardware, nicht auf Laptops.
⚠️Warnung: Ein `:cloud`-Tag ist keine lokale Inferenz. Wenn Datenschutz der Grund für ein lokales Modell ist, nimm stattdessen Qwen3.8 27B, Devstral Small 2 oder Laguna XS 2.1.
Wie vergleichen sich Coding-Modelle? SWE-bench + HumanEval
Modell | HumanEval | SWE-bench | RAM | FIM |
|---|---|---|---|---|
| Qwen3.8 27B | — | 61,7 (Pro) | 18 GB | — |
| Qwen 3.6 27B | — | 77,2 % (Verified) / 53,5 (Pro) | ~22 GB | — |
| Devstral Small 2 | — | 65,8 % (Verified) | 15 GB | — |
| Laguna XS 2.1 (MoE) | — | 70,9 % (Verified) | 20 GB (3B aktiv) | — |
| Qwen3-Coder-Next (MoE) | — | je nach Umgebung unterschiedlich | 52 GB (3B aktiv) | — |
| Kimi K2.6 (MoE) | — | 58,6 (Pro) | 300+ GB (Cloud bei Ollama) | — |
| Codestral 22B | — | — | 13 GB | Ja (primär) |
| Qwen2.5-Coder 32B | — | — | 20 GB | Ja |
| Qwen3 8B | — | — | 5 GB | Ja |
| DeepSeek-R1 14B | — | — | 10 GB | Nein |
📌Hinweis: HumanEval misst die Generierung einzelner Python-Funktionen. SWE-bench misst reale Code-Änderungen über mehrere Dateien. „Pro" und „Verified" sind verschiedene SWE-bench-Varianten und nicht austauschbar: ein Wert von 77,2 % Verified und ein Wert von 61,7 Pro lassen sich nicht direkt vergleichen. Alle Werte stammen von den Herstellern. Die HumanEval-Werte älterer Modelle (Qwen2.5-Coder 32B, Qwen3 8B) stammen aus früheren Versionen dieser Seite und wurden nicht erneut geprüft.
Welches Modell passt zu welcher Coding-Aufgabe?
- 1Python-Funktions-Debugging und Multi-Datei-Refactoring -- Qwen3.8 27B ist die erste Wahl: Ein dichtes Modell hält pro Token alle 27B Parameter aktiv, was für Reasoning über mehrere Dateien passt. Devstral Small 2 ist die leichtere Alternative, wenn nur 16 GB verfügbar sind. Empfehlung: Qwen3.8 27B.
- 2Agentische Schleifen (planen → bearbeiten → Tests ausführen → korrigieren) -- Devstral Small 2 und Laguna XS 2.1 sind für Tool-Aufrufe und lange Sitzungen gebaut. Laguna XS 2.1 bietet 256K Kontext; Devstral Small 2 braucht weniger Speicher. Empfehlung: Laguna XS 2.1 für lange Sitzungen, Devstral Small 2 für 16-GB-Rechner.
- 3FIM / IDE-Autovervollständigung (VS Code) -- Fill-in-the-Middle erfordert ein dafür trainiertes Modell. Codestral 22B und Qwen3 8B funktionieren über Continue.dev; Kimi-Modelle, Laguna und Devstral sind nicht auf FIM ausgerichtet. Empfehlung: Codestral 22B.
- 4Schnelle Skripte auf 8-GB-Laptops -- Qwen3 8B bewältigt Alltagsskripte, SQL und Boilerplate mit geringer Latenz. Bei großen Typsystemen und Änderungen über mehrere Dateien sind die Ergebnisse schwächer. Empfehlung: Qwen3 8B.
🔍Erkenntnis: Größere Modelle erzielen bei SWE-bench-artigen Aufgaben (Debugging und Refactoring über mehrere Dateien) höhere Werte als 8B-Modelle; bei alltäglichem Scripting schrumpft der Abstand. Wähle das Modell zuerst nach Aufgabe, dann nach deinem Speicherbudget.
Welches Coding-Modell balanciert Geschwindigkeit und Ausgabequalität am besten?
Aufgabe | Qwen3.8 27B | Devstral Small 2 | Qwen3 8B | Codestral 22B |
|---|---|---|---|---|
| Multi-Datei-Refactoring, Debugging | Erste Wahl (dicht, 18 GB) | Gut (15 GB) | Begrenzt bei großen Änderungen | Nicht sein Fokus |
| Agentische Schleifen mit Tools | Stark (Tools, Denkmodus) | Dafür gebaut | Grundlegend | Nicht sein Fokus |
| Boilerplate, REST-APIs, Tests | Stark, langsamer | Stark | Schnell, Validierung prüfen | Schnell, generisch |
| FIM-Autovervollständigung (Cursor) | Nicht sein Fokus | Nicht sein Fokus | Unterstützt | Beste Wahl (FIM) |
💡Tipp: Kernaussage: Die Modelle mit 18 GB und 15 GB sind pro Token langsamer als 8B-Modelle, aber bei Reasoning-lastigen Aufgaben genauer. Für IDE-Autovervollständigung nur FIM-optimierte Modelle nutzen (Codestral 22B, Qwen3 8B). Der Durchsatz hängt von GPU, Quantisierung und Kontextlänge ab, teste daher auf deinem eigenen Rechner.
🛠️Praxis-Tipp: Praktische Empfehlung: Wähle nach Aufgabentyp. Für Batch-Codegenerierung oder Refactoring-Reviews nimm Qwen3.8 27B. Für agentische Schleifen auf 16 GB Devstral Small 2. Für Echtzeit-IDE-Autovervollständigung Codestral 22B oder Qwen3 8B, wo Latenz am wichtigsten ist.
Welches lokale Coding-LLM solltest du verwenden?
Das gewählte Modell ist wichtig, aber wie du es promptest, ist für die Code-Qualität noch wichtiger. Strukturierte Prompt-Techniken — Sprache, Einschränkungen, Testfälle und Ausgabeformat angeben — verbessern die Genauigkeit der Codegenerierung erheblich. Der Prompt-Engineering-Leitfaden behandelt 80 Techniken zu Grundlagen, Frameworks und Evaluierungsmethoden.
Für einen kompletten IDE-Workflow rund um diese Modelle siehe GitHub Copilot durch ein lokales LLM ersetzen — der Open-Source-Stack (Continue.dev + Ollama + Qwen3-Coder) passt gut zu den obigen Empfehlungen.
- 8 GB RAM, Coding-Fokus: `ollama run qwen3:8b` -- 5 GB VRAM, bestes Modell für diese Klasse.
- 16 GB RAM: `ollama run devstral-small-2` -- am besten für agentisches Coding bei 24B (Multi-Datei-Änderungen, Debugging-Schleifen), 15 GB.
- 24-GB-GPU oder Mac mit 32 GB (beste Qualität): `ollama run qwen3.8` -- Qwen3.8 27B, 18 GB, 61,7 SWE-bench Pro (laut Qwen).
- Lange agentische Sitzungen: `ollama run laguna-xs-2.1` -- 20 GB, 256K Kontext, SWE-bench Verified 70,9 %.
- 64-GB-Rechner: `ollama run qwen3-coder-next` -- 80B-MoE mit 3B aktiv, 52 GB.
- IDE-Autovervollständigung in VS Code: `ollama run codestral:22b` über Continue.dev -- FIM-optimiert, beste lokale Copilot-Alternative.
🛠️Praxis-Tipp: Passe die Modellgröße zuerst an deine Hardware an, optimiere dann für deinen Anwendungsfall. Mit 8 GB ist Qwen3 8B die beste Wahl. Mit 16 GB nimm Devstral Small 2. Mit 24 GB oder mehr Qwen3.8 27B. Besser ein Modell, das gut läuft, als das perfekte Modell, das kämpft.
Beste Programmier-LLMs für 8 GB VRAM (RTX 3060 12GB / RTX 3070 8GB / RX 6800 16GB)
Bei Maschinen mit 8 GB RAM ist Qwen3 8B die beste Wahl zum Programmieren — es benötigt nur 5 GB VRAM, wodurch 3 GB für Ihre IDE, Browser und andere Anwendungen bleiben. Qwen3 8B beinhaltet FIM-Unterstützung (Fill-in-the-Middle) für VS Code Autovervollständigung über Continue.dev.
- Qwen3 8B (empfohlen) — 5 GB VRAM, 20–35 Tokens/Sek., FIM-Unterstützung. `ollama run qwen3:8b`
- Phi-4 Mini 3.8B — 68% MMLU (Reasoning), 2,5 GB VRAM, beste für leichte Inferenz. `ollama run phi4-mini`
- Llama 3.2 3B — 40–60 Tokens/Sek., 2,5 GB VRAM, guter Fallback für sehr limitierte Setups. `ollama run llama3.2:3b`
Beste Coding-LLMs für 16 GB VRAM (RTX 4070 Ti 16GB / RTX 5070 Ti 16GB / 24-GB-Karten)
Mit 16 GB passt Devstral Small 2 (15 GB) am besten für agentisches Coding. Qwen3.8 27B (18 GB Download) braucht eine 24-GB-GPU oder einen Mac mit 32 GB Unified Memory; es ist die beste Wahl, wenn du diesen Spielraum hast.
- Devstral Small 2 — am besten für agentisches Coding, Tool-Aufrufe, Multi-Datei-Änderungen, 15 GB. `ollama run devstral-small-2`
- Qwen3.8 27B — bestes Gesamtmodell, dicht 27B, 18 GB, 256K Kontext, passt auf eine 24-GB-Karte. `ollama run qwen3.8`
- Qwen3-Coder 30B — 30B/3,3B aktiv (MoE), 19 GB, repository-bewusste Vervollständigung auf einer 24-GB-Karte. `ollama run qwen3-coder:30b`
Beste Programmier-LLMs für 6 GB VRAM (Budget-GPUs / Integrierte Grafik)
Für Maschinen mit 4–6 GB VRAM (Budget-GPUs, ältere Laptops, Intel iGPU) ist Phi-4 Mini 3.8B die beste Wahl — es erreicht 68% MMLU-Reasoning-Performance bei nur 2,5 GB VRAM. Dies hinterlässt ~3,5 GB für Ihr System.
- Phi-4 Mini 3.8B (empfohlen) — 68% MMLU-Reasoning, 2,5 GB VRAM, ausgezeichnet für Logik und Debugging. `ollama run phi4-mini`
- Qwen3 4B — kleinere Variante, 4 GB VRAM, ausgeglichene Qualität-Geschwindigkeit für Budget-Hardware. `ollama run qwen3:4b`
🧭 Wer sollte was verwenden: Personas und Empfehlungen
- Einsteiger (keine Erfahrung mit lokalen LLMs): LM Studio + Qwen3 8B -- grafische Oberfläche, kein Terminal nötig, FIM für Code-Vervollständigung, 5 GB VRAM.
- Laptop-Entwickler (8–16 GB RAM, Alltags-Coding): Ollama + Qwen3 8B (8-GB-Rechner) oder Devstral Small 2 (16-GB-Rechner) -- ausgewogene Qualität und Leistung, läuft stundenlang stabil.
- Fortgeschrittene Entwickler (Debugging, Refactoring, komplexes Reasoning, ab 24 GB): Ollama + Qwen3.8 27B (dichtes Modell, 18 GB) -- bewältigt Multi-Datei-Kontext und Algorithmus-Design.
- Lange agentische Sitzungen (planen → coden → testen → iterieren): Ollama + Laguna XS 2.1 (256K Kontext, SWE-bench Verified 70,9 %) oder Devstral Small 2 -- für Tool-Aufrufe und mehrstufige Läufe gebaut.
- IDE-orientierter Workflow (VS Code, Cursor, JetBrains): Continue.dev + Codestral 22B -- FIM-optimiert für Vervollständigung an der Cursor-Position, beste lokale Copilot-Alternative.
- Datenschutzkritische Umgebungen (DSGVO, HIPAA, proprietärer Code): Jedes lokale Modell oben über Ollama (kein `:cloud`-Tag) -- keine externen API-Aufrufe bei der Inferenz, der Code bleibt also auf deinem Rechner, solange auch Editor-Plugins und andere Tools keine Netzwerkverbindungen aufbauen.
⚠️Warnung: ❌ Vermeiden: Qwen3.8 27B (18 GB) auf Rechnern ohne 24-GB-GPU oder 32-GB-Mac ausführen. Sobald das Modell in den Arbeitsspeicher ausweicht, bricht die Geschwindigkeit stark ein. Nutze auf kleineren Rechnern Qwen3 8B oder Devstral Small 2.
⚠️Warnung: ❌ Vermeiden: Allgemeine Modelle (Llama 3.1 8B) verwenden, wenn du IDE-Autovervollständigung brauchst. Nur code-spezifische Modelle mit FIM-Unterstützung funktionieren für Vervollständigung im Editor -- Codestral 22B, Qwen3 8B.
🔍Erkenntnis: Einsteiger → Fortgeschrittene ist auch eine Steigerung der Hardware-Anforderungen. Starte mit Qwen3 8B (8 GB), wechsle zu Devstral Small 2 (16 GB), sobald du Tools und Workflows ergänzt, und steige auf Qwen3.8 27B (ab 24 GB) um, wenn du maximale Reasoning-Qualität brauchst.
❌ Wann du lokale LLMs NICHT für Programmierung verwenden solltest
- Du brauchst aktuelles Framework-Wissen (2025+ APIs): Lokale Modelle sind auf feste Cutoff-Daten trainiert und kennen nach dem Training veröffentlichte APIs nicht. Für aktuelle Framework-Versionen stelle die aktuelle Dokumentation im Prompt bereit oder verwende ein Frontier-Cloud-Modell wie GPT-5.6 oder Claude Sonnet 5.
- Du brauchst Multi-File-Reasoning über große Codebases (100k+ Tokens): Lokale Modelle verschlechtern sich bei sehr langen Kontexten. Latenz wird prohibitiv. Cloud-Modelle (GPT-5.6, Claude) handhaben nativ 100k+ Token-Kontexte. Für architektonisches Refactoring ganzer Services verwende Cloud-Modelle.
- Latenz muss <300ms sein (echte interaktive Codierung): Lokale Modelle laufen mit 15-25 Tokens/Sek. auf CPU (typische Laptops), was zu einer 5-10 Sekunden Verzögerung pro Response führt. GitHub Copilot und Claude in IDE ergänzen Vorschläge in <1 Sekunde. Für Tastenanschlag-Level-Autovervollständigung sind lokale Modelle zu langsam.
- Du brauchst beste Debugging-Genauigkeit: Bei komplexen Debugging-Aufgaben (Verfolgung mehrerer Funktionsaufrufe, Identifizierung subtiler Typfehler) liegen Frontier-Cloud-Modelle wie GPT-5.6 und Claude Sonnet 5 bei realen Code-Problemen in der Regel weiter vorn. Lokale Modelle sind stark in der Generierung; Frontier-Modelle meist stärker in der Diagnose.
- Du kannst Halluzination in generiertem Code nicht tolerieren: Kleinere lokale Modelle können bei komplexen Aufgaben syntaktisch valide, aber logisch falschen Code erzeugen; größere Cloud-Modelle sind in der Regel zuverlässiger. Für mission-kritischen Code (Zahlungssysteme, Sicherheit) ist eine menschliche Überprüfung des gesamten generierten Codes erforderlich.
🔍Erkenntnis: 👉 Lokale LLMs sind best für: Datenschutz + Offline-Arbeit + Kostenkontolle — NICHT für Spitzenperformance. Wenn maximale Genauigkeit wichtiger ist als diese drei Faktoren, verwende Cloud-APIs.
📊 Beste lokale LLMs für Programmierung im Vergleich (Entscheidungsmatrix)
Unsicher, welches Coding-Modell du wählen sollst? PromptQuorum sendet einen Prompt gleichzeitig an mehrere Modelle (Qwen3.8, Devstral, GPT-5.6, Claude) und zeigt Ausgaben, echte Antwortzeiten und Genauigkeit für DEINEN Code nebeneinander. Teste PromptQuorum kostenlos — 5 Minuten, ohne Anmeldung.
Modell | Am besten für | VRAM | Tempo | Stärke | Wann wählen |
|---|---|---|---|---|---|
| Qwen3.8 27B | Bestes Gesamtmodell, Multi-Datei-Reasoning | ~18 GB | je nach GPU | 61,7 SWE-bench Pro (laut Qwen), dicht 27B, 256K Kontext, Apache 2.0 | Du hast eine 24-GB-GPU oder einen Mac mit 32 GB und willst die beste lokale Qualität |
| Devstral Small 2 | Agentisches Coding bei 24B | ~15 GB | je nach GPU | 65,8 % SWE-bench Verified (laut Mistral), Tool-Aufrufe, Multi-Datei, Apache 2.0 | Du nutzt aider oder Claude-Code-ähnliche Agenten auf 16 GB |
| Laguna XS 2.1 | Agentisches Coding über lange Sitzungen | ~20 GB (3B aktiv) | je nach GPU | SWE-bench Verified 70,9 %, 256K Kontext, 33B/3B aktiv (MoE), OpenMDW-1.1 | Du fährst mehrstündige Agenten-Sitzungen und brauchst 256K Kontext |
| Qwen3-Coder-Next | Großes MoE auf 64-GB-Rechnern | ~52 GB (3B aktiv) | je nach GPU | 80B gesamt/3B aktiv (MoE), 256K Kontext | Du hast 64 GB Unified Memory und willst einen größeren Coder |
| Codestral 22B | IDE-Autovervollständigung (VS Code, Cursor) | ~13 GB | je nach GPU | FIM-optimiert, beste lokale Copilot-Alternative, Continue.dev nativ | Du willst Autovervollständigung auf Tastendruck-Ebene über Continue.dev |
| Qwen3 8B | Laptop-Coding, am besten für 8 GB RAM | ~5 GB | schnellstes hier | Verbessertes Coding, FIM-Unterstützung, mehrsprachig | Du hast 8 GB RAM und willst das beste lokale Coding-Modell dieser Klasse |
| Kimi K2.6 / K2.7 Code | Offene Gewichte im Frontier-Maßstab | 300+ GB (Cloud-Tag bei Ollama) | Server-Klasse | 1T gesamt/32B aktiv (MoE), 256K Kontext | Du hast Workstation-/Server-Hardware oder akzeptierst einen Cloud-Tag |
| GPT-5.6 (Cloud) | Aktuelle APIs, komplexes Reasoning, Spitzenleistung | k. A. (Cloud) | <1 Sek. | Beste Genauigkeit, aktueller Wissensstand, Multi-Datei-Reasoning | Du brauchst Spitzenleistung, Echtzeit-Latenz oder aktuelles Framework-Wissen |
| Claude Sonnet 5 (Cloud) | Code-Review, Architekturentscheidungen, Debugging | k. A. (Cloud) | <1 Sek. | Stark bei Code-Verständnis, Debugging, Multi-Datei-Kontext | Debugging-Genauigkeit und Code-Review sind wichtiger als Kosten oder Datenschutz |
Wie beeinflussen regionale Anforderungen deine Wahl des Programmiermodells?
EU / DSGVO
Für EU-Softwareentwicklungsteams, die an proprietären Codebases arbeiten, bedeutet lokale Codegenerierung, dass der Quellcode niemals die Infrastruktur der Organisation verlässt. DSGVO-Artikel 32 verlangt angemessene technische Sicherheitsmaßnahmen -- die Übertragung von Quellcode an Cloud-AI-APIs schafft eine zusätzliche Datenverarbeiter-Beziehung unter Artikel 28. Lokale Inferenz beseitigt dies.
Qwen3.8 27B (Alibaba, Apache 2.0) und DeepSeek-Coder V2 (DeepSeek, MIT) laufen beide vollständig vor Ort. Für EU-Organisationen, die ein Modell europäischen Ursprungs bevorzugen: Mistrals Code-Modelle (Mistral Small 3.1, Codestral, Devstral Small 2) stammen von Mistral AI (Frankreich); Devstral Small 2 steht unter Apache 2.0, bei Codestral weichen die Lizenzbedingungen ab und sollten geprüft werden. Laguna XS 2.1 nutzt OpenMDW-1.1 (permissiv, kommerzielle Nutzung erlaubt, nicht OSI-zertifiziert) -- bestätige die Lizenzbedingungen vor einem kommerziellen Einsatz immer. Der EU-AI-Act stuft KI-gestützte Codegenerierung für kritische Infrastruktur potenziell als hochriskant ein -- On-Premises-Inferenz hält die Pipeline innerhalb deines bestehenden Sicherheitsperimeters.
Deutschland (BSI-Grundschutz)
Der BSI-Grundschutz-Katalog ist das Sicherheitsstandardwerk für deutsche Organisationen (Mittelstand, öffentlicher Sektor). Lokale LLMs über Ollama erfüllen BSI-Anforderungen für Datensicherheit bei der softwaregestützt Codegenerierung. Qwen3-Coder und DeepSeek-Coder sind beide mit Apache 2.0/MIT-Lizenzen verfügbar und können ohne Abhängigkeiten von externen Cloud-Services betrieben werden, was die IT-Governance vereinfacht.
Japan (METI)
METI-Cybersecurity-Richtlinien behandeln zunehmend die Verwendung von AI-Tools in der Softwareentwicklung. Qwen3-Coder verarbeitet japanische Code-Kommentare und Variablennamen-Konventionen nativ -- nützlich für japanisch entwickelte Codebases mit japanischer Inline-Dokumentation. Für Compliance-Aufzeichnungen bietet das Ollama-Tag (z.B. qwen2.5-coder:32b) die exakte Versions-ID, die METI-AI-Governance-Dokumentation verlangt.
China
Unter Chinas Data Security Law (数据安全法) dürfen Quellcodes für kritische Informationsinfrastruktur nicht von ausländischen Cloud-Services verarbeitet werden. Qwen3.8 27B und Qwen3-Coder (Alibaba, Apache 2.0) sind die natürliche Wahl für chinesische Unternehmens-Programmier-Workflows -- chinesischer Entwickler, Apache-2.0-Lizenz, vollständig lokale Bereitstellung über Ollama. Kimi K2.6 (Moonshot AI) stammt ebenfalls aus China, braucht für den lokalen Betrieb aber Server-Hardware. Das ist keine Rechtsberatung; prüfe die für deinen Fall geltenden Anforderungen.
Was sind häufige Fehler bei lokalen Programmiermodellen?
- Ein General-Purpose-Modell statt eines Code-spezifischen Modells verwenden: Qwen3 8B und Llama 3.1 8B General liegen auf dem HumanEval-Benchmark nah beieinander -- aber Qwen3-Coder beinhaltet FIM (Fill-in-the-Middle)-Unterstützung, die Llama 3.1 8B General nicht hat. Für IDE-Autovervollständigung verwende immer ein Code-spezifisches Modell.
- Kontextlänge für Multi-File-Review nicht einstellen: Ollama runtime default (VRAM-scaled) Tokens. Die meisten Code-Dateien sind 1.000-3.000 Tokens. Setze `PARAMETER num_ctx 32768` für jede Programmier-Aufgabe mit ganzen Dateien oder mehreren Funktionen im Kontext.
- Erwarten, dass Modelle vollständige IDEs ersetzen: Lokale Programmiermodelle zeichnen sich durch Funktions-Level-Generierung, Bug-Erklärung und Refactoring-Vorschläge aus. Sie ersetzen LSP (Language Server Protocol) nicht für Echtzeit-Fehlererkennung oder Typenkontrolle. Verwende Continue.dev oder Cursor, um lokale Modellerzeugung mit vollständiger IDE-Werkzeugausrüstung zu kombinieren.
- Q3_K_S bei Programmiermodellen verwenden, um RAM zu sparen: Quantisierung unter Q4_K_M beeinträchtigt merklich die Code-Generierungsgenauigkeit -- logische Fehler und Syntaxfehler nehmen zu. Für Programmier-Aufgaben verwende Q4_K_M-Minimum. Wenn RAM knapp ist, wähle ein kleineres Modell bei Q4_K_M anstelle eines größeren Modells bei Q3_K_S.
- qwen2.5-coder ohne Größenangabe abrufen: `ollama pull qwen2.5-coder` defaults zur kleinsten verfügbaren Variante. Gib explizit an: `ollama pull qwen2.5-coder:7b` für 8-GB-Maschinen, `ollama pull qwen2.5-coder:32b` für 24+ GB. Der Standard-Pull kann dir ein Modell geben, das nicht zu deiner Hardware passt.
- Prompt Engineering bestimmt die Ausgabequalität unabhängig vom Modell: Programmiersprache, Einschränkungen, Testfälle und Fehlerbehandlung im Prompt anzugeben reduziert halluzinierten Code erheblich. Siehe KI-gestütztes Code-Schreiben verbessern für praxiserprobte Muster.
⚠️Warnung: Verwende niemals Quantisierung unter Q4_K_M für Programmiermodelle. Q3_K_S spart RAM, führt aber zu Syntaxfehlern und logischen Bugs ein. Dies ist kein würdiger Kompromiss für Code-Generierung -- verwende entweder Q4_K_M oder wähle ein kleineres Modell bei voller Präzision.
Häufig gestellte Fragen
Welches lokale LLM ist am besten für Programmierung?
Qwen3.8 27B (Alibaba, Apache 2.0) — dicht 27B, 18 GB, 256K Kontext, 61,7 SWE-bench Pro laut Qwen. `ollama run qwen3.8`. Für agentisches Coding mit 16 GB: Devstral Small 2. Für lange Sitzungen: Laguna XS 2.1. Für IDE-Autovervollständigung: Codestral 22B. Für 8-GB-Rechner: Qwen3 8B.
Welches Qwen-Modell ist am besten für Programmierung?
Qwen3.8 27B ist die beste allgemeine Qwen-Wahl für Programmierung auf einer 24-GB-GPU oder einem Mac mit 32 GB (18 GB, 61,7 SWE-bench Pro laut Qwen). Qwen3-Coder-Next (80B gesamt / 3B aktiv, 52 GB) passt zu 64-GB-Rechnern, Qwen3-Coder 30B (19 GB) zu repository-bewusster Vervollständigung, und Qwen3 8B (5 GB) ist die Wahl für 8 GB RAM.
Ist Qwen das beste lokale LLM für Programmierung?
Auf den meisten Consumer-Rechnern hat Qwen3.8 27B derzeit die stärksten gemeldeten Coding-Werte unter den lokal lauffähigen Modellen, aber kein Modell gewinnt jede Aufgabe. Devstral Small 2 passt auf 16-GB-Rechner und ist für agentische Schleifen gebaut, Laguna XS 2.1 zielt auf lange Sitzungen, und Codestral 22B ist stärker auf IDE-Autovervollständigung spezialisiert. Die Werte stammen von den Herstellern und nutzen unterschiedliche Testumgebungen, teste daher mit deinem eigenen Code.
Kann ich Kimi K2.6 oder Kimi K2.7 Code lokal ausführen?
Nur auf Server-Hardware. Beide sind MoE-Modelle mit 1T Parametern (32B aktiv). Ollama führt sie nur als Cloud-Tags (`kimi-k2.6:cloud`, `kimi-k2.7-code:cloud`), die keine lokale Inferenz sind. Community-GGUF-Builds von K2.7 Code brauchen etwa 310 GB (1-Bit) bis 350 GB (2-Bit). Für lokales Coding auf Consumer-Hardware nimm Qwen3.8 27B, Devstral Small 2 oder Laguna XS 2.1.
Was sind Devstral Small 2 und Laguna XS 2.1?
Beides sind agentische Coding-Modelle. Devstral Small 2 (Mistral AI, Apache 2.0) ist ein 24B-Modell mit 15 GB und 65,8 % auf SWE-bench Verified laut Mistral -- `ollama run devstral-small-2`. Laguna XS 2.1 (Poolside, 2. Juli 2026) ist ein MoE-Modell mit 33B gesamt / 3B aktiv bei 20 GB und 256K Kontextfenster; es erreicht 70,9 % auf SWE-bench Verified und 63,1 % auf SWE-bench Multilingual unter der OpenMDW-1.1-Lizenz -- `ollama run laguna-xs-2.1`.
Was ist HumanEval und warum ist es wichtig?
HumanEval ist ein Benchmark mit 164 Python-Programmieraufgaben. Das Modell muss für jede einen korrekten Funktionskörper erzeugen. Pass@1 (Anteil beim ersten Versuch gelöster Aufgaben) ist die Standardmetrik. Er wird weiterhin zum Vergleich kleiner Coding-Modelle genutzt, testet aber einzelne Funktionen statt echter Projekte.
Was ist Fill-in-the-Middle (FIM) und welche Modelle unterstützen es?
FIM ist die Fähigkeit, Code anhand des Codes vor und nach dem Cursor zu vervollständigen -- das Muster der IDE-Autovervollständigung. Codestral 22B, Qwen3-Coder, DeepSeek-Coder und Starcoder2 unterstützen FIM. Llama 3.1 8B (allgemein) nicht. Nutze für die IDE-Integration ein FIM-fähiges Modell.
Können lokale Coding-Modelle GitHub Copilot ersetzen?
Codestral 22B über Continue.dev kann die meisten Autovervollständigungs-Aufgaben abdecken. Bei komplexem Reasoning über mehrere Dateien haben Cloud-Modelle bei den schwierigsten Aufgaben meist weiter die Nase vorn. Der Kompromiss: Lokale Modelle sind langsamer, aber vollständig privat und laufen auf deiner eigenen Hardware.
Wie viel RAM brauche ich für lokale Coding-LLMs?
Minimum 4 GB (winzige 3B-Modelle), praktisch 8 GB+ für brauchbares Coding. 16 GB führen Devstral Small 2 (15 GB) aus. 24 GB GPU-Speicher oder ein Mac mit 32 GB führen Qwen3.8 27B (18 GB) aus; beim Mac bleiben nach den 8 GB für macOS etwa 6 GB für den Kontext. Faustregel: Q4_K_M-Gewichte brauchen etwa 0,6 GB pro Milliarde Parameter, plus Speicher für das Kontextfenster.
Wie viele Tokens verbraucht eine 500-zeilige Python-Datei?
Ungefähr 2.000-3.000 Tokens für eine 500-zeilige Python-Datei. Ollamas laufzeitabhängiger Standardkontext (nach VRAM skaliert) kann zu klein sein. Setze mindestens `PARAMETER num_ctx 16384` für Code-Review einzelner Dateien. Für Analysen über mehrere Dateien nutze 32768 oder 65536 Kontext.
Sind lokale Coding-Modelle schnell genug für die Entwicklung?
Ja für iterative Workflows. Die Geschwindigkeit hängt von GPU, Quantisierung und Kontextlänge ab. Kleinere Modelle wie Qwen3 8B antworten auf Laptops zügig; größere Modelle sind pro Token langsamer. Mehrere Sekunden Wartezeit pro Antwort sind für Anfrage-und-Review-Nutzung akzeptabel, nicht aber für Autovervollständigung auf Tastendruck-Ebene, wofür du ein kleines FIM-Modell nutzen solltest.
Können lokale LLMs GPT-5.6 für Programmierung ersetzen?
Nicht vollständig. Lokale Modelle (Qwen3.8 27B, Devstral Small 2) liegen bei aktuellem Framework-Wissen (APIs nach dem Trainings-Cutoff), sehr langem Multi-Datei-Reasoning (100k+ Tokens) und Debugging-Genauigkeit hinter Frontier-Cloud-Modellen zurück. Bei alltäglichen Multi-Datei-Aufgaben haben sie aufgeholt und halten deinen Code privat.
Welche Sprache unterstützt Qwen3-Coder am besten?
Python ist die primäre Trainingssprache. JavaScript, TypeScript, Java, C++, Go, Rust und SQL werden alle gut unterstützt. Das Modell beherrscht auch PHP, Ruby, Swift und Kotlin. Bei Nicht-Python-Sprachen sind die HumanEval-Werte niedriger, aber weiterhin konkurrenzfähig.
Ist DeepSeek-Coder sicher für proprietären Code?
Bei lokaler Ausführung über Ollama baut DeepSeek-Coder keine externen Verbindungen auf. Dein Code bleibt auf deiner Hardware. Die Datenschutzbedenken bei DeepSeek betreffen die Cloud-API (api.deepseek.com), nicht die lokale Ollama-Inferenz. Lokale Inferenz sendet keinen Code an DeepSeek-Server.
Kann ich lokale Coding-Modelle für SQL-Generierung nutzen?
Ja -- Qwen3.8 27B und Devstral Small 2 beherrschen SQL-Generierung. Gib das Tabellenschema im Prompt-Kontext an. Für komplexe Multi-Join-Abfragen nutze 32K Kontext, um das vollständige Schema einzubinden. Setze einen System-Prompt: „Du bist ein SQL-Experte. Erzeuge ausschließlich gültiges SQL."
Was ist SWE-bench und warum ersetzt es HumanEval?
SWE-bench testet, ob ein Modell echte GitHub-Issues lösen kann — Codebasen lesen, Änderungen über mehrere Dateien vornehmen und Tests schreiben. Anders als HumanEval (einzelne Python-Funktionen) sagt SWE-bench voraus, wie sich ein Modell in echten Entwicklungs-Workflows schlägt. SWE-bench Verified und SWE-bench Pro sind verschiedene Varianten, ihre Werte sind nicht austauschbar. 2026 ist SWE-bench der wichtigste Benchmark zur Bewertung von Coding-Modellen für den praktischen Einsatz.
Wie verbinde ich ein lokales Coding-Modell mit VS Code?
Installiere die Continue.dev-Erweiterung aus dem VS-Code-Marketplace. Wähle in den Continue-Einstellungen Ollama als Anbieter und gib dein Modell an (z. B. `qwen3:8b`, `qwen3.8`, `codestral:22b`). Die Erweiterung verbindet sich automatisch mit Ollama unter localhost:11434. Mit Cmd+I (macOS) oder Strg+I (Windows) löst du die Inline-Codegenerierung aus.
Quellen
- Qwen-Team. (2026). „Qwen3.8-27B" Model Card. huggingface.co -- Apache 2.0, 256K Kontext, SWE-bench Pro 61,7, LiveCodeBench v6 90,3, Terminal Bench 2.1 73,0.
- Ollama. (2026). „qwen3.8" Bibliotheksseite. ollama.com -- 18-GB-Tag (Q4_K_M), 256K Kontext.
- Mistral AI. (2026). „devstral-small-2" bei Ollama. ollama.com -- 15 GB, SWE-bench Verified 65,8 %, erfordert Ollama 0.13.3 oder neuer.
- Poolside. (2026). „Introducing Laguna XS 2.1." poolside.ai -- agentisches Coding-Modell, 33B/3B aktiv (MoE), SWE-bench Verified 70,9 %, OpenMDW-1.1-Lizenz.
- Ollama. (2026). „laguna-xs-2.1" Bibliotheksseite. ollama.com -- Standard-Tag 20 GB, 256K Kontext.
- Ollama. (2026). „qwen3-coder-next" Bibliotheksseite. ollama.com -- 80B gesamt / 3B aktiv, 52 GB Q4_K_M.
- Ollama. (2026). „kimi-k2.6" Bibliotheksseite. ollama.com -- nur ein `:cloud`-Tag gelistet.
- Unsloth. (2026). Anleitung „Kimi K2.7 Code" lokal ausführen. unsloth.ai -- 1T/32B aktiv (MoE), 310–470 GB Speicherbedarf quantisiert.
- Ollama. (2026). „codestral" Bibliotheksseite. ollama.com -- 22B, 13 GB, 32K Kontext.
- Qwen-Team. (2026). „Qwen3-Coder-Next Technical Report". arxiv.org -- Architektur und Ergebnisse zu agentischem Coding für Qwen3-Coder-Next.
- DeepSeek AI. (2024). „DeepSeek-Coder-V2 Technical Report." arxiv.org/abs/2406.11931 -- MoE-Architektur und Coding-Benchmark-Ergebnisse für DeepSeek-Coder V2 Lite.