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 d'un GPT-4o récent, Qwen3-Coder tient la dragée haute à Claude sur du refactoring, et même un Qwen 2.5 Coder 14B 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, Qwen 2.5 Coder excellent.
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 un Qwen 2.5 Coder pour cette partie.

Installer Devstral avec Ollama

ollama pull devstral
ollama run devstral "É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 14B se sent. Pour 12 Go, restez sur Qwen 2.5 Coder.

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 2.5 Coder, la valeur sûre

La famille Qwen 2.5 Coder (sortie fin 2024) reste en 2026 l'option la plus polyvalente, surtout pour les configurations modestes. Apache 2.0, FIM solide, et déclinée en plusieurs tailles.

Qwen 2.5 Coder 7B: VRAM Q4 ≈ 5 Go. Idéal pour RTX 3060 8 Go, RTX 4060, MacBook Air M-series 16 Go. Très bon en auto-complétion, correct en chat.
Qwen 2.5 Coder 14B: VRAM Q4 ≈ 9 Go. Le sweet spot pour 12 Go de VRAM (RTX 3060 12 Go, RTX 4070). Qualité chat nettement supérieure au 7B.
Qwen 2.5 Coder 32B: VRAM Q4 ≈ 19 Go. Pour 24 Go (RTX 3090, RTX 4090, Mac M-Pro). Concurrence directe de Devstral en qualité brute, sans la spécialisation agentic.
Atout principal: FIM excellent. Si vous voulez de l'autocomplétion dans VS Code (Continue.dev, Tabby), c'est le modèle de référence.

Qwen 2.5 Coder vs Qwen3-Coder

Qwen 2.5 Coder reste recommandé en 2026 pour les petites configurations (≤16 Go VRAM) et pour le FIM. Qwen3-Coder vise les machines plus généreuses (24 Go+) et le travail agentic. Les deux coexistent.

#Alternatives notables

DeepSeek-Coder V2 (Lite 16B): MoE 16B-A2.4B, licence MIT, 128k de contexte. VRAM Q4 ≈ 10 Go. Bon compromis si vous voulez un MoE rapide sur 12-16 Go.
GLM-4.5 / GLM-5 (variantes code): Très solide en chat technique et debug. Licence open-weight. Pertinent si vous codez en équipe avec du français mêlé au code (les commentaires et explications sortent en français bien plus naturellement que chez Qwen).
Codestral 22B (Mistral): Excellent techniquement, mais licence Mistral non-commerciale. À éviter en environnement pro hors usage strictement personnel ou recherche.
StarCoder 2 (3B, 7B, 15B): Daté en 2026, mais reste utile pour du FIM léger et de l'autocomplétion sur très petites configs. Licence BigCode permissive.
Code Llama: Dépassé en qualité par tout ce qui précède. À sauter, sauf cas spécifique de finetuning sur base Llama 2.

#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 2.5 Coder 7B. Pas le choix réel au-dessus, mais c'est déjà très utilisable pour de l'autocomplétion et du chat technique. Contexte 16-32k.
12 Go (RTX 3060 12 Go, 4070, 5070): Qwen 2.5 Coder 14B en daily driver. Vous pouvez aussi tester DeepSeek-Coder V2 Lite 16B. Devstral en Q4 passe avec contexte réduit.
16 Go (RTX 4080, 4070 Ti Super, 5070 Ti, 5080): Devstral Small pour l'agentic, Qwen 2.5 Coder 14B 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 en daily driver. Vitesse + qualité. Devstral en backup pour l'agentic. 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 Q6 ou Q8, ou Qwen 2.5 Coder 32B en Q5. Excellent confort, contexte 128k. On commence à viser le top sans compromis.
Mac Studio Ultra 128 Go+: Qwen3-Coder 480B-A35B. C'est le seul moyen accessible (hors data center) de faire tourner un modèle de code frontier en local. Coûteux, mais tient la comparaison avec les meilleurs API.

#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 Qwen 2.5 Coder 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
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 (autocomplete)",
    "provider": "ollama",
    "model": "qwen2.5-coder:7b",
    "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 (Qwen 2.5 Coder, StarCoder 2) 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 et Devstral suivent cette consigne sans broncher.

#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