Os Melhores LLMs Locais para Codificação em Agosto de 2026, por VRAM: Qwen3-Coder 30B, gpt-oss-20b, Qwen 2.5 Coder 7B

O melhor LLM local para programação em agosto de 2026 é decidido pela sua VRAM antes de qualquer outra coisa. Se você tem uma placa de 24GB — uma RTX 3090 ou 4090 — execute Qwen3-Coder-30B-A3B-Instruct: 30B de parâmetros totais com apenas 3.3B ativos por token, uma janela de contexto de 262.144 tokens e os melhores números de programação local que podemos verificar. Em 16GB é gpt-oss-20b, o modelo Mixture-of-Experts Apache-2.0 da OpenAI que cabe inteiramente na GPU com ~14GB e mede cerca de 140 tokens/seg. Em 8GB é Qwen2.5-Coder-7B, o burro de carga confiável com ~4.7GB. O resto desta página é o raciocínio, os números medidos e as situações específicas em que cada uma dessas escolhas está errada.

O que a primeira página acerta — e o que ela deixa de fora

O ranking de "melhor llm local para codificação" atualmente é uma mistura de uma peça genuinamente útil e muita força de domínio. O guia da Tembo (5 de junho de 2026) acerta na estrutura — ele organiza por níveis de 8GB / 12–16GB / 24GB e chega à família Qwen Coder — mas não publica pontuações de benchmark para os modelos locais, nem números de tokens por segundo, nem tamanhos de janela de contexto, nem opções para Apple Silicon por RAM. Um harness de avaliação no GitHub (gauravvij/local-llm-coding-eval) tem números reais, mas não tem veredito e foi executado apenas em CPU. O restante são artigos de opinião de um único autor (XDA, Yahoo Tech) e listículos superficiais (apidog, Security Boulevard, SitePoint) que se classificam pela força de domínio, não por serem úteis.

O que todos ignoram, em ordem de quanto isso custa para você:

• A lacuna agêntica. Geração de código não é a mesma habilidade que conduzir um agente por uma alteração em vários arquivos. A primeira página mal menciona isso; é a diferença entre um modelo que você mantém e um modelo que você desinstala.

• Janelas de contexto. Codificação agêntica queima tokens carregando arquivos e saída de testes. Uma alegação de que "30B cabe em 24GB" não tem sentido até que você pergunte em que contexto isso cabe.

• Matemática de quantização. Ninguém explica que 4 bits precisa aproximadamente da contagem de parâmetros em gigabytes, ou que Q3 compra VRAM ao custo de erros sutis de sintaxe.

• Velocidade medida. Poucos artigos publicam tokens/seg para os modelos que recomendam, e os que o fazem discordam enormemente porque contexto e quantização mudam tudo.

• Quando local é a escolha errada. Um teste de campo de 2026 em um aplicativo Flutter de 15.000 linhas (EPAM) ainda mostra que modelos de fronteira em nuvem vencem as refatorações multi-etapa mais difíceis. Nenhum dos listicles diz quando parar.

A matemática de VRAM que a maioria dos listicles ignora

A regra prática que torna todos os outros números deste artigo legíveis: com quantização de 4 bits, um modelo precisa de aproximadamente o equivalente à sua contagem de parâmetros em gigabytes — 7B ≈ 5GB, 30B ≈ 18GB+, antes da sobrecarga do cache KV. Q4 é o ponto ideal para codificação; Q3 e abaixo economizam VRAM, mas introduzem erros sutis de sintaxe de forma mensurável. E o cache KV cresce com sua janela de contexto, por isso "um 30B cabe em 24GB" só é verdadeiro em um contexto que você precisa especificar.

Mixture-of-Experts muda a matemática de uma forma que importa para as duas grandes escolhas abaixo. Os parâmetros totais definem a pegada; os parâmetros ativos definem a velocidade. É por isso que Qwen3-Coder-30B-A3B (30B total, 3.3B ativos) e gpt-oss-20b (20.9B total, 3.61B ativos) ambos parecem muito mais rápidos do que seu peso em disco sugere, e por que DeepSeek V4 Flash — 284B total, 13B ativos — é uma má opção para uso local, mesmo que sua API seja barata.

24GB de VRAM: Qwen3-Coder 30B

Qwen3-Coder-30B-A3B-Instructé o codificador local versátil mais forte que podemos indicar no momento. Lançado em julho de 2025 pela equipe Qwen da Alibaba sob a licença Apache 2.0, é um modelo Mixture-of-Experts com 30B de parâmetros totais e 3,3B ativos por token, uma janela de contexto de 262.144 tokens e um footprint de 4 bits de aproximadamente 17–20 GB — o que deixa folga real em uma placa de 24 GB para o cache KV que uma longa sessão de codificação exige.

No harness local independente em que mais confiamos (gauravvij/local-llm-coding-eval, quatro modelos executados localmente via Ollama em CPU), qwen3-coder:30b obteve 80% em geração de código, 77% em seleção de ferramentas e 80% em precisão de agente — o resultado mais equilibrado dos quatro, e o único modelo que foi forte nas três tarefas ao mesmo tempo. Rastreadores de terceiros compilam seu SWE-bench Verified em torno de 50,3, Aider Polyglot em 66,2 e LiveCodeBench v6 em 58,9; trate esses números como valores compilados, não como números oficiais da Alibaba, que é tudo o que a Qwen publicou para este modelo.

A velocidade medida varia amplamente com o hardware. Os pontos de dados mais úteis: uma configuração da comunidade TurboQuant roda-o numa RTX 3060 Ti de 8GB a ~29 tokens/seg na geração com um contexto completo de 262K, e o benchmark oMLX mediu a compilação MLX de 4 bits num M4 Pro (48GB) a 73,6 tokens/seg com contexto de 1K, caindo para 13,5 tokens/seg com 64K. Num cartão de 24GB numa configuração normal de Ollama, você deve esperar a faixa de dezenas de tokens por segundo, não as centenas — o preço por rodar um codificador próximo da fronteira em casa.

Uma ressalva honesta: não é o codificador local mais rápido, e existe um Qwen3-Coder-Next mais novo voltado para uso hospedado e via CLI, em vez de instalações locais quantizadas. Mas para trabalho agêntico em escala de repositório em uma única placa, o Qwen3-Coder-30B é a escolha hoje.

16GB de VRAM: gpt-oss-20b

Em uma placa de 16GB, a resposta é gpt-oss-20b — e não é nem de perto. Lançado em 5 de agosto de 2025 pela O​penAI sob a licença Apache 2.0, é um modelo Mixture-of-Experts com 20,9B de parâmetros totais e 3,61B ativos por token, uma janela de contexto de 131.072 tokens, e sua quantização nativa MXFP4 ocupa cerca de 14GB. Esse é o fato decisivo: ele roda 100% na GPU em uma placa de 16GB, sem nada vazar para a RAM do sistema.

Por que a residência na GPU importa mais do que qualquer benchmark: um modelo que cabe na VRAM é de 3 a 11 vezes mais rápido do que um que faz offload. Um benchmark independente registrou 139,93 tokens/seg para o gpt-oss-20b em uma RTX 4080 — aproximadamente 2,8x uma alternativa densa no mesmo footprint — e a pontuação de um testador de 2026 deu a ele um "índice de inteligência" de 52,1, chamando-o de incomparável na classe de 16GB para codificação e depuração profissional. É um ajuste apertado, então rode-o sozinho e mantenha o contexto modesto; a qualidade degrada no topo da janela.

A alternativa agêntica em 16GB é Devstral 24B (devstral-small-2:24b), que apresenta o único número publicado de SWE-bench Verified entre os codificadores locais da classe de 16GB — 46,8% — mas é lento, frequentemente exigindo offload de CPU a ~18 tokens/seg. Se o seu trabalho envolve edições agênticas em múltiplos arquivos e você aguenta a velocidade, o Devstral merece seu lugar; se você quer velocidade e código limpo, o gpt-oss-20b é o melhor padrão. Modelos densos de 14B — Qwen3-Coder 14B ou Qwen2.5-Coder 14B em Q5 — são as alternativas confortáveis e baratas.

8GB VRAM: Qwen 2.5 Coder 7B

Em 8GB, a resposta honesta é Qwen2.5-Coder-7B: 7B parâmetros em ~4,7GB no Q4_K_M, um contexto nativo de 32.768 tokens extensível até 128K, e as pontuações mais fortes de benchmark de conclusão de código na classe 7B. É um modelo mais antigo — lançado em novembro de 2024 — e tudo bem, porque nada mais novo no envelope de 8GB o destronou. Testes da comunidade o colocam em cerca de 50 tokens/seg em uma RTX 4060 ou 3070; um teste independente com RTX 4060 em março de 2026 mediu 28–35 tokens/seg, uma variação impulsionada quase inteiramente pelas configurações de contexto.

Três coisas importam em 8GB e não em outros lugares. Primeiro, limite o contexto a 4–8K: o cache KV é o que estoura a memória de uma placa de 8GB, não os pesos — em um benchmark, a velocidade saltou de ~3,6 para ~37 tokens/seg apenas por limitar o contexto. Segundo, verifique com ollama ps se o modelo está 100% na GPU; qualquer parte na CPU faz a velocidade despencar. Terceiro, Q4_K_M, não Q3 — os erros de sintaxe do Q3 custam mais do que a VRAM economiza.

O desenvolvimento notável de 2026 é que Qwen3-Coder-30B-A3B-Instruct agora pode ser comprimido em 8GB via compressão de cache KV TurboQuant — uma configuração da comunidade mediu ~7.5GB e ~29 tokens/seg em uma RTX 3060 Ti com contexto completo de 256K. Funciona, e é complicado o suficiente para não recomendarmos como padrão. Se você quiser uma opção mais nova pronta para uso, Qwen3 8B (~5.2GB, modo híbrido de raciocínio) é um pequeno passo à frente do Qwen2.5-Coder-7B em raciocínio geral, embora fique um pouco atrás em código puro.

E quanto ao Apple Silicon?

A memória unificada muda o cálculo em uma direção: a capacidade aumenta, a velocidade de geração diminui. Um M4 Pro de 48GB pode carregar modelos que uma placa Windows de 16GB não consegue, mas gera tokens muito mais lentamente em contexto longo. Os números que temos: a versão 4-bit MLX do Qwen3-Coder-30B-A3B-Instruct usou 16,6GB em contexto de 1K e 25,5GB em 64K em um M4 Pro, com a geração caindo de 73,6 tokens/s para 13,5 conforme o contexto crescia (benchmark oMLX). O gpt-oss-20b cabe confortavelmente em 16GB de memória unificada e é uma ótima escolha para Mac. Se você quiser um modelo multimodal no Apple Silicon, Gemma 4 12B roda em aproximadamente 16GB de memória unificada com um contexto de 256K — a opção local mais forte se o seu trabalho de codificação envolve documentos repletos de imagens.

Os números independentes: codegen não é a habilidade que importa

O dado mais claro que encontramos é um único benchmark local que vale a pena citar por completo. gauravvij/local-llm-coding-eval executou quatro modelos localmente via Ollama, em CPU, sem nuvem — geração de código, chamada de funções e uma tarefa de agente em múltiplas etapas — com resultados que contrariam o instinto de que "quanto maior o número de codegen, melhor":

• Qwen3.6 27B (qwen3.6:27b, denso, ~17GB): 80,0% geração de código, 84,6% ferramentas, 100% agente — o mais versátil.

• Qwen3.6 35B A3B (qwen3.6:35b-a3b, MoE, ~18GB): 70,0% geração de código, 84,6% ferramentas, 100% agente.

• Qwen3-Coder-30B-A3B-Instruct (qwen3-coder:30b, MoE, ~17GB): 80.0% geração de código, 76.9% ferramentas, 80% agente — o mais equilibrado.

• DeepSeek-Coder-V2 33B (deepseek-coder:33b, denso, ~18GB): 90,0% geração de código — o melhor dos quatro — mas 10% agente, em último lugar em tarefas de múltiplas etapas.

Essa última linha é toda a lição. Um modelo que domina a geração de código pura, mas desmorona em tarefas de agente, é o modelo que você vai desinstalar após o primeiro ciclo de "leia este arquivo, altere esta função, execute o teste". Julgue um codificador local pela coluna de agente, não pela coluna de codegen.

Quando executar localmente é a decisão errada.

Local-first é o padrão certo para privacidade, trabalho offline, custo marginal zero de tokens e autocomplete onde a latência importa mais do que a qualidade máxima. É a decisão errada em situações específicas e reconhecíveis — e esta é a seção que a página um pula:

• O trabalho agêntico mais difícil ainda te vence. O teste de campo de 2026 da EPAM em um aplicativo Flutter de 15.000 linhas descobriu que os modelos de fronteira em nuvem (GPT-5.3-codex) ainda superam os modelos locais na mais complexa refatoração de múltiplas etapas. Se o seu dia são oito horas de refatoração de código legado, os modelos locais não estão prontos.

• Suas necessidades de contexto excedem sua placa. Um agente de codificação que carrega um repositório inteiro vai estourar o cache KV que uma placa de 16GB pode armazenar. O contexto de 256K do Qwen3-Coder-30B é o motivo pelo qual ele vence na categoria de 24GB — placas menores perdem esse jogo cedo.

• Você não pode ser babá de hardware. O hardware é dinheiro de verdade: uma placa de 24GB está na faixa de US$ 700 a US$ 1.600, mais eletricidade e manutenção. Em baixo volume, chamar uma API é mais barato do que o consumo de energia.

• DeepSeek V4 Flash é a prova. Com 284B de parâmetros totais, apenas os pesos de 4 bits do DeepSeek V4 Flash ocupam cerca de 140GB — não é um modelo para placa de consumo, ponto final. Seu design de 13B ativos é exatamente o motivo pelo qual sua API é rápida e barata a $0.15 / $0.29 por 1M de tokens (MIT, contexto de 1M). Para esse modelo, "rodar localmente" é a pergunta errada; a API é o ponto.

• Equipes precisam de consistência. Se cada um dos quatro engenheiros executa uma quantização diferente de um modelo diferente, "funciona na minha máquina" se torna um risco de build. Endpoints de API compartilhados fornecem um alvo determinístico.

Se você quiser a resposta do lado da API para esta mesma pergunta — qual modelo de codificação em nuvem é o padrão quando o local não é a troca certa — abordamos isso separadamente em nosso guia de melhores LLMs para codificação, e nosso artigo sobre agentes de codificação com IA cobre ferramentas como Cline e OpenCode que funcionam com esses modelos locais.

Como testar antes de comprar o cartão

A maneira mais barata de decidir é rodar seus próprios prompts antes de se comprometer com o hardware. {{1}}Ollama ou LM Studio colocam qualquer uma das três opções para rodar em minutos, e o teste que importa são os arquivos reais do seu repositório, não um benchmark.{{/1}} Um roteador ganha seu lugar na decisão adjacente: {{2}}quando você está comparando um candidato local com modelos de fronteira hospedados, um único endpoint permite executar o mesmo prompt em ambos sem precisar gerenciar várias chaves.{{/2}} No OrcaRouter, o DeepSeek V4 Flash é servido pelo preço de tabela do provedor, repassado sem alterações — US$ 0,15 / US$ 0,29 por 1M de tokens, margem de 0% — com failover automático, o que o torna uma referência barata e honesta para responder à pergunta "meu modelo local é realmente melhor do que a API de US$ 0,15?"

Uma ressalva honesta: a OrcaRouter não hospeda o Qwen3-Coder-30B-A3B-Instruct nem o gpt-oss-20b. Se o seu objetivo é estritamente offline, um roteador é irrelevante para você — faça self-hosting e pronto. Se o seu objetivo é fazer A/B do mesmo modelo de pesos abertos contra os modelos de fronteira antes de gastar com uma placa, a função do roteador é a comparação, não a hospedagem.

O resultado final

Sua VRAM decide primeiro; a qualidade do modelo vem em segundo. Com 24GB, rode o Qwen3-Coder-30B-A3B-Instruct — o codificador local completo mais forte, com o contexto de 256K que o trabalho agêntico exige. Com 16GB, rode o gpt-oss-20b — o raro modelo que é rápido e roda inteiramente na GPU. Com 8GB, rode o Qwen2.5-Coder-7B e mantenha seu contexto modesto. Avalie qualquer um deles pela coluna agêntica, não pela coluna de geração de código, e aceite que a refatoração multi-arquivo mais difícil ainda pertence à nuvem. Os números acima estão atualizados até 10 de agosto de 2026 — reverifique o line-up e os preços de tabela antes de gastar, porque esse espaço muda toda semana.