Meilleur LLM local pour coder en 2026 : Devstral, Qwen3-Coder et alternatives

#Pourquoi un LLM local pour coder en 2026

Coder avec un assistant IA est devenu un réflexe. Mais envoyer du code propriétaire, des secrets, des chemins internes ou simplement de la propriété intellectuelle à un service cloud reste un problème — pour les freelances sous NDA, pour les boîtes soumises au RGPD, pour les solo dev qui veulent juste garder le contrôle.

La bonne nouvelle : depuis 2025, les modèles open-weight de code ont rattrapé une bonne partie du retard. Devstral atteint des scores SWE-bench dignes des meilleurs modèles cloud, Qwen3-Coder tient la dragée haute à Claude sur du refactoring, et même un Qwen 3.5 9B sur une RTX 3060 fait du travail utile au quotidien. Le ticket d'entrée matériel a baissé, la qualité a monté.

Ce qu'on entend par "meilleur LLM local pour coder en 2026"

On parle de modèles à poids ouverts (Apache 2.0 ou MIT), exécutables sur du GPU grand public ou Mac Apple Silicon, sans envoyer un seul token à un serveur tiers. Pas de "open source mais API-only", pas de licence non-commerciale.

#Les bons critères de choix

Un benchmark de leaderboard ne dit pas tout. Pour un usage réel, voici ce qui compte.

Qualité du code généré: Capacité à écrire un patch qui compile et passe les tests, pas juste du code "qui ressemble". HumanEval/MBPP donnent une idée, SWE-bench Verified est plus représentatif des tâches réelles.
Support du Fill-in-the-Middle (FIM): Indispensable pour l'auto-complétion dans l'IDE. Tous les modèles ne l'ont pas — Devstral est faible là-dessus, et pour le FIM pur qwen2.5-coder:7b-base reste la référence 2026.
Fenêtre de contexte: Pour comprendre un fichier de 2000 lignes ou un projet entier, comptez 32k tokens minimum. Qwen3-Coder monte à 256k, Devstral à 128k.
Vitesse d'inférence: Un modèle dense 30B sort 15-25 tokens/s sur une RTX 4090. Un MoE comme Qwen3-Coder 30B-A3B sort 60-80 tokens/s avec une qualité équivalente — la différence change la vie au clavier.
Licence: Apache 2.0 et MIT vous laissent tranquille en commercial. Méfiance avec Codestral (non-commercial) ou les anciens Code Llama (licence Meta restrictive).
Langues supportées: La plupart des bons modèles couvrent Python, JS/TS, Go, Rust, Java, C/C++ correctement. Pour du PHP, du Ruby ou du Swift, vérifiez les benchmarks par langage.

#Devstral, le spécialiste agentic (Mistral AI)

Devstral est le modèle de code de Mistral, spécifiquement entraîné pour le travail agentic — c'est-à-dire avec un agent comme Aider, OpenHands ou SWE-agent qui itère sur le code, lance les tests, lit la sortie et corrige. Sur SWE-bench Verified, Devstral Small se classe dans les meilleurs modèles open-weight, à un rang qui aurait été inatteignable il y a un an.

Variante recommandée: Devstral Small (~24B, dense). Apache 2.0. Disponible sur Hugging Face et Ollama.
VRAM en Q4_K_M: Environ 14 Go. Tient à l'aise sur une RTX 4080 16 Go ou un Mac M-series 24 Go. Possible mais juste sur 12 Go avec contexte réduit.
Fenêtre de contexte: 128k tokens. Largement suffisant pour ingérer un repo de taille moyenne.
Force: Excellent pour les workflows agentic multi-étapes : lire un bug report, naviguer dans le code, écrire un patch, faire passer les tests.
Faiblesse: Pas conçu pour le FIM (auto-complétion ligne par ligne). Si vous voulez l'utiliser dans Continue.dev pour la complétion, basculez sur qwen2.5-coder:7b-base pour cette partie.

Installer Devstral avec Ollama

ollama pull devstral:24b
ollama run devstral:24b "Écris un parseur CSV en Rust qui gère les guillemets échappés."

#Qwen3-Coder, le couteau suisse (Alibaba)

Qwen3-Coder est la génération 2025 de la famille Coder d'Alibaba, en architecture Mixture-of-Experts (MoE). C'est le modèle que beaucoup considèrent comme l'état de l'art open-weight pour la génération de code en 2026, tous formats confondus. Disponible sous licence Apache 2.0.

Variante grand public: Qwen3-Coder 30B-A3B : 30 milliards de paramètres au total, mais seulement 3 milliards activés par token. Concrètement, ça donne la qualité d'un dense 14-22B avec la vitesse d'un 3B.
VRAM en Q4_K_M: Environ 18 Go pour la 30B-A3B. Tient pile sur une RTX 4090 24 Go, ou sur un Mac M-Pro/M-Max 24-32 Go.
Variante frontier: Qwen3-Coder 480B-A35B. Niveau Claude/GPT-5 sur le code, mais réservé aux Mac Studio Ultra 256-512 Go ou aux setups multi-GPU H100.
Contexte: 256k tokens en natif, extensible. Vous pouvez littéralement coller un repo entier dedans.
Forces: Excellent en refactoring multi-fichier, gère bien les langages "de niche" (Elixir, Zig, OCaml), très bon en agentic, et le MoE le rend exceptionnellement rapide.
Faiblesse: Le 30B-A3B reste un MoE : si votre VRAM est tendue, le surcoût mémoire face à un dense 9B se sent. Pour 12 Go, restez sur un Qwen 3.5 9B (au besoin en Q8).

Installer Qwen3-Coder 30B-A3B

ollama pull qwen3-coder:30b
ollama run qwen3-coder:30b "Refactor cette fonction pour utiliser async/await sans changer le comportement."

→

Pourquoi le MoE A3B est si rapide

Avec 3B de paramètres actifs par token, le calcul nécessaire à chaque génération est celui d'un 3B — mais avec la "connaissance" d'un 30B. Sur une RTX 4090, comptez 60 à 80 tokens/seconde, là où un dense 32B plafonne à 25-30. À l'usage quotidien, c'est la différence entre "je tape avec le modèle" et "j'attends le modèle".

#Qwen 3.5, la valeur sûre des petites configs

La famille Qwen 3.5 (2B, 4B, 9B) est en 2026 l'option la plus polyvalente pour les configurations modestes. Apache 2.0, gros contexte (jusqu'à 256k), multimodale sur les tailles moyennes, et déclinée pour tenir de 4 à 12 Go de VRAM. Pour la seule autocomplétion inline (FIM), on garde à part qwen2.5-coder:7b-base, resté la référence sur ce cas précis.

Qwen 3.5 4B: VRAM Q4 ≈ 3,4 Go (ollama run qwen3.5:4b). Idéal pour RTX 3060 8 Go, RTX 4060, MacBook Air M-series 16 Go. Le nouveau petit modèle par défaut, correct en chat de code.
Qwen 3.5 9B: VRAM Q4 ≈ 6,6 Go (ollama run qwen3.5:9b). LE choix 8 Go de 2026 : 256k de contexte, vision, qualité nettement supérieure au 4B. Le daily driver des cartes 8-12 Go.
Qwen 3.5 9B en Q8: VRAM ≈ 11 Go (ollama run qwen3.5:9b-q8_0). La qualité max de la tranche, pile pour 12 Go de VRAM (RTX 3060 12 Go, RTX 4070).
Autocomplétion (FIM): Qwen2.5-Coder 7B base reste LA référence FIM en 2026 : ollama run qwen2.5-coder:7b-base (≈ 4,7 Go). À conserver pour le tabAutocomplete de VS Code (Continue.dev, Tabby).

Qwen 3.5 vs Qwen3-Coder

Qwen 3.5 (dense, généraliste) est recommandé pour les petites configurations (≤16 Go VRAM), avec qwen2.5-coder:7b-base en renfort pour le FIM. Qwen3-Coder (MoE spécialiste code) vise les machines plus généreuses (24 Go+) et le travail agentic. Les deux coexistent.

#Alternatives notables

gpt-oss 20B (OpenAI): Modèle open-weight OpenAI, quantifié MXFP4, très rapide, 131k de contexte. VRAM ≈ 14 Go (ollama run gpt-oss:20b). Bon compromis sur 16 Go si vous voulez un généraliste orienté code réactif.
GLM 4.7 Flash (Zhipu AI): MoE 30B-A3B, licence MIT, ≈ 19 Go en Q4 (ollama run glm-4.7-flash). Très solide en chat technique, en debug et en agents. Pertinent si vous mêlez français et code — les explications sortent naturellement en français.
Mistral Small 24B: Généraliste dense, ≈ 14 Go en Q4 (ollama run mistral-small). Bon en français, utile en appoint pour la doc et les explications sur une config 16 Go.
Codestral 22B (Mistral): Techniquement correct, mais licence Mistral non-production : interdit en environnement de travail. À écarter hors usage strictement personnel ou recherche.
DeepSeek-Coder V2, Code Llama, StarCoder 2: Ces bases 2023-2024 sont dépassées en qualité par tout ce qui précède. À sauter : un Qwen 3.5 9B ou un Granite 4.2 8B fait mieux pour moins de VRAM.

#Lequel choisir selon votre GPU

Recommandation pragmatique en fonction de la VRAM disponible. Les modèles cités sont en quantization Q4_K_M, le meilleur compromis qualité/mémoire pour du code.

8 Go (RTX 3060 8 Go, 4060, 5050, 5060): Qwen 3.5 9B (256k ctx, vision). Déjà très utilisable pour l'autocomplétion et le chat technique. Pour le FIM pur, ajoutez qwen2.5-coder:7b-base. Contexte 16-32k.
12 Go (RTX 3060 12 Go, 4070, 5070): Qwen 3.5 9B en Q8 (11 Go) en daily driver, ou Gemma 4 12B (7,6 Go, multimodal). Devstral en Q4 passe avec contexte réduit.
16 Go (RTX 4080, 4070 Ti Super, 5070 Ti, 5080): Devstral 24B pour l'agentic, gpt-oss 20B ou Mistral Small 24B en généraliste, et qwen2.5-coder:7b-base pour le FIM. C'est la première config où vous avez vraiment le choix.
24 Go (RTX 3090, 4090, RX 7900 XTX): Qwen3-Coder 30B-A3B (code) ou Qwen 3.8 27B (généraliste, le plus proche d'un Copilot) en daily driver. Devstral en backup agentic, GLM 4.7 Flash pour les agents. C'est la config où le local rivalise avec le cloud au quotidien.
32 Go (RTX 5090) ou Mac M-series 36-48 Go: Qwen3-Coder 30B-A3B en Q8 (32 Go), ou Qwen 3.6 35B-A3B (23 Go, MoE rapide, la valeur sûre de la tranche). Excellent confort, contexte 128k+. On vise le top sans compromis.
Mac Studio Ultra 128 Go+: Qwen3-Coder 30B-A3B en Q8 pleine qualité avec le contexte 256k complet, ou les variantes frontier de Qwen3-Coder (480B-A35B) si vous visez le niveau API. C'est le seul moyen accessible (hors data center) de faire tourner un modèle de code frontier en local.

#Brancher tout ça dans VS Code

Le plus simple : Ollama écoute sur http://localhost:11434, et Continue.dev (extension VS Code) sait parler à cet endpoint nativement. Voici une configuration minimale qui combine qwen2.5-coder:7b-base pour l'autocomplétion (rapide, FIM) et Qwen3-Coder pour le chat (puissant).

Récupérer les modèles

ollama pull qwen2.5-coder:7b-base
ollama pull qwen3-coder:30b

~/.continue/config.json (extrait)

{
  "models": [
    {
      "title": "Qwen3-Coder 30B (chat)",
      "provider": "ollama",
      "model": "qwen3-coder:30b",
      "apiBase": "http://localhost:11434"
    }
  ],
  "tabAutocompleteModel": {
    "title": "Qwen2.5-Coder 7B base (autocomplete)",
    "provider": "ollama",
    "model": "qwen2.5-coder:7b-base",
    "apiBase": "http://localhost:11434"
  }
}

Pour les workflows agentic (refactoring multi-fichier, résolution de bugs), Aider en CLI brille particulièrement avec Devstral :

Aider + Devstral

pip install aider-chat
export OLLAMA_API_BASE=http://localhost:11434
aider --model ollama/devstral

#Astuces et pièges courants

Contexte trop court par défaut sur Ollama: Ollama plafonne à 2048 tokens de contexte par défaut. Pour du code, c'est ridicule. Configurez num_ctx via un Modelfile ou via les paramètres Continue.dev, et montez à 16k ou 32k minimum.
FIM vs chat — ne mélangez pas: Devstral et Qwen3-Coder ne sont pas optimisés pour le FIM. Si vous les mettez en autocomplétion, vous aurez des résultats bizarres (réponses style chat dans le milieu d'une fonction). Utilisez toujours un modèle FIM-friendly (qwen2.5-coder:7b-base) pour le tabAutocomplete.
Quantification trop agressive: Pour du code, Q3 et inférieur dégradent visiblement la qualité (syntaxe foireuse, identifiants inventés). Restez à Q4_K_M minimum. Q5_K_M si vous avez la VRAM.
Performance qui s'effondre après quelques minutes: Ollama décharge les modèles inactifs au bout de 5 min. Si vous codez par à-coups, lancez Ollama avec OLLAMA_KEEP_ALIVE=1h pour garder le modèle chaud.
Modèle qui répond toujours en anglais: Ajoutez un system prompt dans Continue.dev ou dans le Modelfile : « Réponds toujours en français, code et commentaires en anglais. » Qwen 3.5 / 3.8 et Devstral suivent cette consigne sans broncher.
Qwen 3.8 27B qui sur-réfléchit: Avec son réglage de raisonnement par défaut, Qwen 3.8 27B a tendance à sur-réfléchir sur des tâches simples et à rallonger la latence. Pour du code au quotidien, passez son effort de raisonnement en low (ou coupez le thinking) : vous gagnez en réactivité sans perte notable sur les tâches courantes.

#Pour aller plus loin

Vous avez choisi votre modèle de code et il tourne. Quelques pistes pour pousser plus loin :

Copilot local avec Continue.dev: Le guide détaillé pour configurer Continue.dev dans VS Code avec Ollama, modèles d'autocomplétion et de chat séparés, raccourcis.
Utiliser Ollama dans Claude Code et Cursor: Pour brancher Devstral ou Qwen3-Coder dans Cursor ou Claude Code via l'endpoint OpenAI-compatible d'Ollama, et utiliser ces IDE haut de gamme sans cloud.
Choisir sa quantification (Q4, Q5, Q8, FP16): Pour comprendre exactement ce que vous perdez ou gagnez en passant d'un Q4_K_M à un Q5_K_M sur un modèle de code, et quand monter en quantization a du sens.

Ce guide vous a aidé ?

Un retour, une erreur, une précision ? Faites-nous signe, ça améliore le guide pour tout le monde.

Suite logique

Cas d'usage · 20 min