Lokale LLM für Code: Top-Empfehlungen

Lisa Ernst · 06.10.2025 · Technik · 5 min

Dieser Überblick beleuchtet die aktuellen lokalen Code-LLMs, die auf eigener Hardware ohne Cloud-Anbindung betrieben werden können. Entscheidend sind belegbare Benchmarks, Hardware-Anforderungen (VRAM/RAM) und Features wie Code-Infilling. Wir fassen den Stand zusammen und zeigen, welches Modell zu welcher Maschine passt.

Quelle: Eigene Darstellung

Einführung & Grundlagen

Unter „lokal“ verstehen wir den vollständigen Betrieb eines Modells auf eigener Hardware, beispielsweise über Runner wie Ollama oder direkt via llama.cpp/vLLM. Ollama ermöglicht einfaches Pull/Run, auch mit Quantisierungen. Quantisierung (z. B. GGUF Q4_K_M) reduziert den Speicherbedarf deutlich, meist mit moderatem Qualitätsverlust.

Für die praktische Anwendung sind folgende Aspekte wichtig:

• Infilling/FIM: Gezieltes Auffüllen von Lücken im Code, unterstützt von Modellen wie StarCoder2 und CodeGemma.
• Kontextfenster: Die Fähigkeit, längere Dateien oder Projekte einzubeziehen. Qwen2.5-Coder bietet hier bis zu 128K Token.
• Laufzeitbudget: Grobe Faustzahlen für Ollama sind: 7B-Modelle benötigen mindestens 8 GB RAM/VRAM, 13B-Modelle 16 GB und 70B-Modelle 64 GB.

Die Motivation für den lokalen Betrieb liegt in Privatheit, Reproduzierbarkeit, Offline-Arbeit und Kostenkontrolle. Hersteller wie BigCode/Hugging Face, Alibaba/Qwen und DeepSeek erhöhen das Tempo und die Transparenz. Tools wie Ollama senken die Einstiegshürden durch einfaches Pull/Run und Quantisierung (GGUF/4-Bit). Extensions wie Continue integrieren lokale Modelle direkt in VS Code/JetBrains.

Aktueller Stand & Modelle

Seit 2024 gab es signifikante Entwicklungen im Bereich der lokalen Code-LLMs:

• StarCoder2 (3B/7B/15B): Dieses Modell brachte FIM-Training auf The Stack v2 und ein 16K Kontextfenster. Die 15B-Variante übertrifft ähnlich große Modelle auf vielen Benchmarks, wie in dieser Veröffentlichung beschrieben.
• Qwen2.5-Coder (0.5B–32B): Meldet State-of-the-Art (SOTA) Ergebnisse bei offenen Code-Benchmarks. Die 32B-Instruct-Variante zielt explizit auf „open-source SOTA“ bei EvalPlus, LiveCodeBench und BigCodeBench.
• DeepSeek-Coder-V2: Führt ein MoE-Design ein. Die V2-Lite-Version (16B, aktiv 2.4B) bietet 128K Kontext und ist für die lokale Nutzung konzipiert. Die größere V2-Variante (236B, aktiv 21B) führt viele Code-Benchmarks an, ist jedoch nicht für Consumer-Hardware geeignet.
• CodeGemma (2B/7B): Fokussiert auf effizientes Infilling. Die 7B-Variante ist gut dokumentiert, inklusive 4-Bit-Setup und FIM-Tokens.

Für faire Vergleiche etablieren sich contamination-arme Benchmarks wie LiveCodeBench (rollierend) und EvalPlus (HumanEval+/MBPP+). Hugging Face bietet hierzu weitere Informationen.

Quelle: nutstudio.imyfone.com

Eine visuelle Darstellung der besten lokalen LLMs für die Programmierung.

Praktische Anwendung & Integration

Die Auswahl des passenden Modells hängt stark von der verfügbaren Hardware und der geplanten Aufgabe ab:

• Laptop/8–12 GB VRAM: Qwen2.5-Coder-7B oder CodeGemma-7B. Diese Modelle bieten starkes Infilling und geringe Latenz, besonders im 4-Bit-Betrieb.
• 16 GB VRAM: StarCoder2-15B-Instruct oder DeepSeek-Coder-V2-Lite (16B aktiv 2.4B). Eine gute Balance aus Qualität und Geschwindigkeit.
• 24 GB+ VRAM: Qwen2.5-Coder-32B-Instruct. Dieses Modell ist offen, leistungsstark und bietet ein großes Kontextfenster.
• CPU-only/kleine iGPU: Gemma/CodeGemma oder kleinere Qwen-Coder Varianten. Google demonstriert explizit den CPU-Betrieb mit Ollama.

Für die Praxis empfiehlt sich die IDE-Integration mit Continue (VS Code/JetBrains) in Verbindung mit einem Ollama-Server. Es ist ratsam, aktiv Infilling zu nutzen, anstatt nur zu „chatten“, und A/B-Vergleiche mit EvalPlus- oder LiveCodeBench-Problemen für die eigene Domäne durchzuführen.

Analyse & Bewertung

Hersteller betonen oft „open SOTA“ (Qwen) oder „best-in-class“ (StarCoder2), was durch Benchmarks teilweise gestützt wird, aber auch Marketingaspekte beinhaltet. Ein Blick auf mehrere Quellen ist daher ratsam. Die Community berichtet über gemischte Erfahrungen: Während einige lokale Setups feiern, berichten andere von schwankender Qualität bei Edit-Aufgaben, oft bedingt durch Prompting, Kontexte und Editor-Integration, wie hier diskutiert.

Faktencheck: Belege vs. Behauptungen

• Belegt:
  • 7B/13B/70B grobe RAM-Richtwerte bei Ollama sind breit in der Praxis bestätigt.
  • StarCoder2 bietet FIM-Training, 16K Kontext und starke 15B-Ergebnisse im Vergleich zu ähnlich großen Modellen (Quelle).
  • Qwen2.5-Coder 32B-Instruct beansprucht SOTA bei offenen Code-Benchmarks und deckt 0.5B–32B Größen ab, bis 128K Kontext.
  • DeepSeek-Coder-V2-Lite: MoE mit 16B (aktiv 2.4B), 128K Kontext. Die große V2-Variante zeigt sehr hohe Code-Bench-Werte, ist aber nicht für Consumer-Hardware.
  • CodeGemma 7B: FIM-Tokens sind dokumentiert, 4-Bit-Betrieb mit ca. 9 GB möglich.
• Unklar/Nuanciert:
  • „1 GB VRAM pro Milliarde Parameter“ ist ein Community-Daumenwert, der durch Quantisierung, Kontextlänge und Offload stark variiert. Modell-/Runner-Dokumentationen sind hier präziser (Qwen, Ollama).
• Falsch/Irreführend:
  • „Quantisierung macht Modelle unbrauchbar.“ In vielen Coding-Workflows ist 4-Bit ein guter Kompromiss. Qualitätseinbußen hängen von Modell, Aufgabe und Kontextlänge ab (CodeGemma, Qwen).

Quelle: pieces.app

Ein Diagramm, das die Leistung verschiedener LLM-Modelle im Bereich Coding vergleicht.

Fazit & Ausblick

Für die Suche nach dem „besten lokalen LLM für Coding“ gibt es heute echte Auswahlmöglichkeiten. Für 24 GB+ VRAM ist Qwen2.5-Coder-32B-Instruct die erste Adresse unter den offenen Modellen. Auf 16 GB VRAM liefert StarCoder2-15B-Instruct sehr rundes Infilling und stabile Leistung. Im 7B-Segment sind Qwen2.5-Coder-7B und CodeGemma-7B pragmatische Wahlen: schnell, sparsam und gut dokumentiert. DeepSeek-Coder-V2-Lite punktet mit MoE-Effizienz und großem Kontext, sofern es sauber quantisiert und integriert wird.

Nutzwertanalyse

Gewichtung: Performance 60 %, lokale Ressourcenpassung 20 %, IDE-Features/FIM+Kontext 10 %, Lizenz 10 %. Leistungsschätzungen basieren auf zitierten Benchmarks/Modelldokumenten.

• Qwen2.5-Coder-32B-Instruct: 8.4/10 – Höchste offene Performance, großes Kontextfenster; benötigt mehr VRAM, aber stark für komplexe Aufgaben.
• Qwen2.5-Coder-14B-Instruct: 8.4/10 – Sehr gutes Preis-/Leistungsverhältnis, breit einsetzbar, Apache-2.0-Lizenz.
• DeepSeek-Coder-V2-Lite (16B, aktiv 2.4B): 8.0/10 – Effizientes MoE, 128K Kontext; stark quantisiert nutzbar.
• StarCoder2-15B-Instruct: 7.9/10 – FIM-stark, 16K Kontext, transparentes Training; robust für Edit/Completion.
• Qwen2.5-Coder-7B-Instruct: 8.0/10 – Mobil/laptop-tauglich, gute Qualität bei schneller Latenz; ideal für Inline-Edits.
• CodeGemma-7B: 7.5/10 – Schlank, FIM sehr ordentlich, gute Doku/Setups; stark für schnelle Autocompletion.

Wer heute starten möchte, installiert Ollama, zieht Qwen2.5-Coder-7B oder StarCoder2-15B, aktiviert Continue in VS Code und nutzt Infilling bewusst. So profitiert man sofort, ohne sich an einen Cloud-Anbieter zu binden.

Offene Fragen

Die Robustheit der Codequalität über verschiedene Programmiersprachen und Frameworks hinweg bleibt eine offene Frage. Rolling Benchmarks adressieren Datenleckage, sind aber keine vollständige Garantie (LiveCodeBench, Hugging Face). Welche Metriken korrelieren am stärksten mit echter Produktivität im Editor (Edit/Refactor/Repo-Kontext)? Aider publiziert Editing-/Refactor-Benchmarks, doch eine Standardisierung steht noch aus. Für lokale Hardware bleiben Fragen zum optimalen Quant/Offload-Setup, hier helfen die Runner-Guides und eigene Microbenchmarks (Qwen, Ollama).

Quelle: openxcell.com

Eine Darstellung der Integration von LLMs in den Entwicklungsprozess.