Melhor LLM local para programar: Devstral, Qwen3-Coder

#Por que usar um LLM local para programar em 2026

Codar com um assistente de IA tornou-se um hábito. Mas enviar código proprietário, segredos, caminhos internos ou simplesmente propriedade intelectual para um serviço na nuvem continua sendo um problema — para freelancers sob NDA, para empresas sujeitas ao RGPD, para desenvolvedores que trabalham sozinhos e querem apenas manter o controle.

A boa notícia: desde 2025, os modelos de código com pesos abertos recuperaram boa parte do atraso. Devstral atinge pontuações no SWE-bench dignas dos melhores modelos na nuvem, Qwen3-Coder compete de igual para igual com Claude em refatoração, e até um Qwen 3.5 9B em uma RTX 3060 faz trabalho útil no dia a dia. O custo inicial do hardware caiu e a qualidade subiu.

O que se entende por "melhor LLM local para programar em 2026"

Estamos falando de modelos com pesos abertos (Apache 2.0 ou MIT), que podem ser executados em GPUs de consumo ou em Macs Apple Silicon, sem enviar um único token a um servidor de terceiros. Nada de “open source, mas disponível apenas por API”, nem de licença não comercial.

#Os bons critérios de escolha

O kit Copiloto Local

Devstral ou Qwen3-Coder: sua escolha está feita. O kit Copiloto Local o coloca para trabalhar em trinta minutos (cap. 2), verifica se é o modelo adequado para sua memória de vídeo (cap. 5) e leva você a medir o desempenho da sua máquina em vez de acreditar na ficha técnica (cap. 18).

Espaço online vitalício
PDF + arquivos
Atualizações vitalícias

O kit Copiloto Local →ou todos os kits vitalícios — 49 € →

Um benchmark de leaderboard não diz tudo. Para uso real, veja o que realmente importa.

Qualidade do código gerado: Capacidade de escrever um patch que compile e passe nos testes, não apenas algo com aparência de código. HumanEval/MBPP dão uma ideia; SWE-bench Verified é mais representativo das tarefas reais.
Suporte ao Fill-in-the-Middle (FIM): Indispensável para o preenchimento automático no IDE. Nem todos os modelos oferecem esse recurso — o Devstral é fraco nesse aspecto, e, para FIM puro, qwen2.5-coder:7b-base continua sendo a referência em 2026.
Janela de contexto: Para compreender um arquivo de 2000 linhas ou um projeto inteiro, considere pelo menos 32k tokens. Qwen3-Coder atinge 256k, Devstral atinge 128k.
Velocidade de inferência: Um modelo denso de 30B gera 15 a 25 tokens/s em uma RTX 4090. Um modelo MoE como Qwen3-Coder 30B-A3B gera 60 a 80 tokens/s com qualidade equivalente — a diferença muda a vida no teclado.
Licença: Apache 2.0 e MIT permitem o uso comercial sem complicações. Cuidado com o Codestral (uso não comercial) ou os antigos Code Llama (licença restritiva da Meta).
Linguagens suportadas: A maioria dos bons modelos cobre Python, JS/TS, Go, Rust, Java, C/C++ corretamente. Para PHP, Ruby ou Swift, verifique os benchmarks por linguagem.

#Devstral, especialista em tarefas com agentes (Mistral AI)

Devstral é o modelo de código da Mistral, especificamente treinado para trabalhar com agentes — ou seja, com um agente como Aider, OpenHands ou SWE-agent que itera sobre o código, executa testes, lê a saída e faz correções. No SWE-bench Verified, o Devstral Small está entre os melhores modelos com pesos abertos, em uma posição que há um ano seria impossível de alcançar.

Variante recomendada: Devstral Small (~24B, denso). Apache 2.0. Disponível no Hugging Face e Ollama.
VRAM em Q4_K_M: Aproximadamente 14 GB. Cabe com folga em uma RTX 4080 de 16 GB ou em um Mac M-series de 24 GB. É possível com 12 GB e contexto reduzido, mas fica no limite.
Janela de contexto: 128k tokens. Mais do que suficiente para processar um repositório de tamanho médio.
Ponto forte: Excelente para workflows agênticos de múltiplas etapas: ler um relatório de bug, navegar no código, escrever um patch e fazer os testes passarem.
Fraqueza: Não foi projetado para FIM (autocompletar linha por linha). Se você quiser usá-lo no Continue.dev para autocompletar código, mude para qwen2.5-coder:7b-base nessa parte.

Instalar o Devstral com Ollama

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

#Qwen3-Coder, a ferramenta multifuncional (Alibaba)

Qwen3-Coder é a geração 2025 da família Coder da Alibaba, com arquitetura Mixture-of-Experts (MoE). É o modelo que muitos consideram o estado da arte entre os modelos com pesos abertos para geração de código em 2026, independentemente do formato. Disponível sob licença Apache 2.0.

Versão para o público em geral: Qwen3-Coder 30B-A3B: 30 bilhões de parâmetros no total, mas apenas 3 bilhões ativados por token. Na prática, isso oferece a qualidade de um modelo denso de 14–22B com a velocidade de um de 3B.
VRAM em Q4_K_M: Aproximadamente 18 GB para a 30B-A3B. Cabe exatamente em uma RTX 4090 de 24 GB, ou em um Mac M-Pro/M-Max de 24-32 GB.
Variante de fronteira: Qwen3-Coder 480B-A35B. No nível de Claude/GPT-5 em programação, mas restrito a Mac Studio Ultra com 256-512 GB ou a configurações com múltiplas GPUs H100.
Contexto: 256k tokens de contexto nativo, com possibilidade de expansão. Você pode literalmente colar um repositório inteiro nele.
Pontos fortes: Excelente em refatoração de múltiplos arquivos, lida bem com linguagens “de nicho” (Elixir, Zig, OCaml), muito bom em tarefas com agentes, e o MoE o torna excepcionalmente rápido.
Fraqueza: O 30B-A3B continua sendo um MoE: se sua VRAM estiver apertada, o consumo adicional de memória em relação a um 9B denso será perceptível. Para 12 GB, fique com um Qwen 3.5 9B (se necessário, em Q8).

Instalar 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."

→

Por que o MoE A3B é tão rápido

Com 3B de parâmetros ativos por token, o cálculo necessário em cada geração é equivalente ao de um modelo de 3B — mas com o "conhecimento" de um modelo de 30B. Em uma RTX 4090, conte com 60 a 80 tokens por segundo, enquanto um modelo denso de 32B atinge no máximo 25–30. No uso diário, é a diferença entre "eu digito com o modelo" e "eu espero o modelo".

#Qwen 3.5, a opção confiável para configurações pequenas

A família Qwen 3.5 (2B, 4B, 9B) em 2026 é a opção mais versátil para configurações modestas. Licença Apache 2.0, contexto amplo (até 256k), multimodal nas versões de tamanho médio e disponível em variantes que cabem em 4 a 12 GB de VRAM. Especificamente para a autocompletação inline (FIM), mantemos à parte o qwen2.5-coder:7b-base, que continua sendo a referência nesse caso específico.

Qwen 3.5 4B: VRAM Q4 ≈ 3,4 GB (ollama run qwen3.5:4b). Ideal para RTX 3060 8 GB, RTX 4060, MacBook Air M-series 16 GB. O novo modelo pequeno padrão, adequado para conversas sobre código.
Qwen 3.5 9B: VRAM Q4 ≈ 6,6 GB (ollama run qwen3.5:9b). A escolha por excelência para 8 GB em 2026: 256k de contexto, visão, qualidade significativamente superior ao 4B. O modelo para uso diário em placas de 8 a 12 GB.
Qwen 3.5 9B em Q8: VRAM ≈ 11 GB (ollama run qwen3.5:9b-q8_0). A melhor qualidade nessa faixa, ideal para 12 GB de VRAM (RTX 3060 12 GB, RTX 4070).
Autocompletação (FIM): Qwen2.5-Coder 7B base continua sendo A referência em FIM em 2026: ollama run qwen2.5-coder:7b-base (≈ 4,7 GB). Manter para o tabAutocomplete do VS Code (Continue.dev, Tabby).

Qwen 3.5 vs Qwen3-Coder

Qwen 3.5 (denso, generalista) é recomendado para configurações pequenas (≤16 GB de VRAM), com qwen2.5-coder:7b-base como complemento para o FIM. Qwen3-Coder (MoE especializado em código) é voltado para máquinas com mais recursos (24 GB+) e para o trabalho com agentes. Os dois coexistem.

#Alternativas notáveis

gpt-oss 20B (OpenAI): Modelo da OpenAI com pesos abertos, quantizado em MXFP4, muito rápido, com 131k de contexto. VRAM ≈ 14 GB (ollama run gpt-oss:20b). Bom equilíbrio em 16 GB se você quiser um modelo generalista voltado para código e com respostas rápidas.
GLM 4.7 Flash (Zhipu AI): MoE 30B-A3B, licença MIT, ≈ 19 GB em Q4 (ollama run glm-4.7-flash). Muito sólido em conversas técnicas, em depuração e em agentes. Pertinente se você misturar francês e código — as explicações saem naturalmente em francês.
Mistral Small 24B: Modelo generalista denso, ≈ 14 GB em Q4 (ollama run mistral-small). Bom em francês, útil como complemento para documentação e explicações em uma configuração de 16 GB.
Codestral 22B (Mistral): Tecnicamente correto, mas com licença Mistral para uso não produtivo: proibido em ambiente de trabalho. Descartar se o uso não for estritamente pessoal ou para pesquisa.
DeepSeek-Coder V2, Code Llama, StarCoder 2: Essas bases de 2023-2024 são superadas em qualidade por tudo o que foi apresentado acima. Pode ignorá-las: um Qwen 3.5 9B ou um Granite 4.2 8B oferece resultados melhores usando menos VRAM.

#Qual escolher de acordo com sua GPU

Recomendação pragmática com base na VRAM disponível. Os modelos citados estão em quantização Q4_K_M, o melhor equilíbrio entre qualidade e memória para código.

8 GB (RTX 3060 8 GB, 4060, 5050, 5060): Qwen 3.5 9B (256k ctx, visão). Já é muito útil para autocompletar e para conversas técnicas. Para o FIM puro, adicione qwen2.5-coder:7b-base. Contexto 16-32k.
12 GB (RTX 3060 12 GB, 4070, 5070): Qwen 3.5 9B em Q8 (11 GB) em uso diário, ou Gemma 4 12B (7,6 GB, multimodal). Devstral em Q4 funciona com contexto reduzido.
16 GB (RTX 4080, 4070 Ti Super, 5070 Ti, 5080): Devstral 24B para tarefas com agentes, gpt-oss 20B ou Mistral Small 24B como modelos generalistas, e qwen2.5-coder:7b-base para o FIM. É a primeira configuração em que você realmente tem escolha.
24 GB (RTX 3090, 4090, RX 7900 XTX): Qwen3-Coder 30B-A3B (código) ou Qwen 3.8 27B (generalista, o mais próximo de um Copilot) como modelo principal para uso diário. Devstral como alternativa para tarefas com agentes, GLM 4.7 Flash para os agentes. É a configuração em que os modelos locais rivalizam com os da nuvem no dia a dia.
32 GB (RTX 5090) ou Mac M-series 36-48 GB: Qwen3-Coder 30B-A3B em Q8 (32 GB), ou Qwen 3.6 35B-A3B (23 GB, MoE rápido, a opção confiável dessa faixa). Excelente conforto de uso, contexto 128k+. O objetivo é alcançar o topo sem concessões.
Mac Studio Ultra 128 GB+: Qwen3-Coder 30B-A3B em Q8 com qualidade plena e a janela de contexto completa de 256k, ou as variantes frontier do Qwen3-Coder (480B-A35B) se você busca o nível das APIs. É o único meio acessível (fora de um data center) de rodar um modelo de código frontier localmente.

#Conectar tudo isso no VS Code

A solução mais simples: Ollama escuta em http://localhost:11434, e o Continue.dev (extensão do VS Code) sabe se comunicar com esse endpoint nativamente. Aqui está uma configuração mínima que combina qwen2.5-coder:7b-base para autocompletar (rápido, FIM) e Qwen3-Coder para o chat (poderoso).

Recuperar os modelos

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

~/.continue/config.json (trecho)

{
  "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"
  }
}

Para fluxos de trabalho com agentes (refatoração de múltiplos arquivos, resolução de bugs), o Aider na linha de comando destaca-se especialmente com Devstral:

Aider + Devstral

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

#Dicas e armadilhas comuns

Contexto muito curto por padrão no Ollama: Ollama limita o contexto a 2048 tokens por padrão. Para código, isso é ridículo. Configure num_ctx via um Modelfile ou pelos parâmetros do Continue.dev e aumente para 16k ou 32k, no mínimo.
FIM vs chat — não misture: Devstral e Qwen3-Coder não são otimizados para FIM. Se você os usar na autocompletação, obterá resultados estranhos (respostas em estilo de chat no meio de uma função). Sempre use um modelo adequado para FIM (qwen2.5-coder:7b-base) para o tabAutocomplete.
Quantização excessivamente agressiva: Para código, Q3 e abaixo degradam claramente a qualidade (sintaxe errada, identificadores inventados). Mantenha pelo menos Q4_K_M. Q5_K_M se tiver VRAM.
Desempenho que despenca após alguns minutos: O Ollama descarrega modelos inativos após 5 minutos. Se você programa de forma intermitente, inicie o Ollama com OLLAMA_KEEP_ALIVE=1h para manter o modelo carregado e pronto para uso.
Modelo que sempre responde em inglês: Adicione um prompt de sistema no Continue.dev ou no Modelfile: “Responda sempre em francês, com código e comentários em inglês.” Qwen 3.5 / 3.8 e Devstral seguem essa instrução sem dificuldade.
Qwen 3.8 27B que reflete excessivamente: Com sua configuração padrão de raciocínio, o Qwen 3.8 27B tende a refletir demais em tarefas simples e a aumentar a latência. Para programar no dia a dia, defina o esforço de raciocínio como low (ou desative o thinking): você obtém respostas mais rápidas sem perda significativa nas tarefas comuns.

#Para se aprofundar

Você escolheu seu modelo de código e ele está rodando. Algumas dicas para avançar ainda mais:

Copilot local com Continue.dev: O guia detalhado para configurar o Continue.dev no VS Code com Ollama, modelos separados para preenchimento automático e chat, e atalhos.
Usar Ollama em Claude Code e Cursor: Para conectar Devstral ou Qwen3-Coder no Cursor ou no Claude Code via o endpoint compatível com OpenAI do Ollama, e usar esses ambientes de desenvolvimento de alto nível sem necessidade de nuvem.
Escolher sua quantização (Q4, Q5, Q8, FP16): Para entender exatamente o que você perde ou ganha ao passar de um Q4_K_M para um Q5_K_M em um modelo de código, e quando usar uma quantização de maior precisão faz sentido.

Este guia ajudou você?

Um comentário, um erro ou uma observação? Avise-nos; isso ajuda a melhorar o guia para todos.

Os kits QuelLLMO guia de referência por uso

Copiloto Local IA local Agentes Locais RAG Local IA Empresarial IA Sem Filtros Mac Imagens IA

Todos os kits vitalícios — 49 €

Próximo passo lógico

Casos de uso · 20 min