Mejor LLM local para programar: Devstral, Qwen3-Coder

#¿Por qué un LLM local para programar en 2026?

Programar con un asistente de IA se ha convertido en un hábito. Pero enviar código propietario, secretos, rutas internas o simplemente propiedad intelectual a un servicio en la nube sigue siendo un problema: para profesionales autónomos sujetos a un acuerdo de confidencialidad, para empresas sujetas al RGPD y para desarrolladores que trabajan solos y solo quieren mantener el control.

La buena noticia: desde 2025, los modelos de código con pesos abiertos han reducido buena parte de la brecha. Devstral alcanza puntuaciones en SWE-bench dignas de los mejores modelos en la nube, Qwen3-Coder compite de tú a tú con Claude en refactorización, e incluso un Qwen 3.5 9B en una RTX 3060 hace trabajo útil a diario. El costo de entrada en hardware ha bajado y la calidad ha subido.

Qué se entiende por "mejor LLM local para programar en 2026"

Hablamos de modelos de pesos abiertos (Apache 2.0 o MIT), ejecutables en GPU de consumo o en Mac Apple Silicon, sin enviar un solo token a un servidor de terceros. Nada de "código abierto, pero solo mediante API", ni licencias no comerciales.

#Los criterios adecuados para elegir

El kit Copiloto Local

Devstral o Qwen3-Coder: tu elección está hecha. El kit Copilote Local lo pone en funcionamiento en treinta minutos (cap. 2), verifica que sea el adecuado para tu memoria de vídeo (cap. 5) y te hace medir el rendimiento de tu máquina en lugar de confiar en la ficha técnica (cap. 18).

Espacio en línea de por vida
PDF + archivos
Reembolsado 30 j

El kit Copiloto Local →o todos los kits de por vida — 49 € →

Una prueba de rendimiento de una clasificación no lo dice todo. Para un uso real, esto es lo que importa.

Calidad del código generado: Capacidad para escribir un parche que compile y pase las pruebas, no solo código que 'parezca' correcto. HumanEval/MBPP dan una idea, SWE-bench Verified es más representativo de tareas reales.
Soporte de Fill-in-the-Middle (FIM): Indispensable para la autocompletación en el IDE. No todos los modelos lo tienen — Devstral es débil en este aspecto, y para el FIM puro qwen2.5-coder:7b-base sigue siendo la referencia en 2026.
Ventana de contexto: Para comprender un archivo de 2000 líneas o un proyecto completo, necesitas al menos 32k tokens. Qwen3-Coder llega a 256k, Devstral hasta 128k.
Velocidad de inferencia: Un modelo denso de 30B produce entre 15 y 25 tokens/s en una RTX 4090. Un modelo MoE como Qwen3-Coder 30B-A3B produce entre 60 y 80 tokens/s con una calidad equivalente: la diferencia te cambia la vida al trabajar con el teclado.
Licencia: Apache 2.0 y MIT te permiten el uso comercial sin complicaciones. Cuidado con Codestral (no comercial) o los antiguos Code Llama (licencia restrictiva de Meta).
Lenguajes compatibles: La mayoría de los buenos modelos cubren correctamente Python, JS/TS, Go, Rust, Java, C/C++. Para PHP, Ruby o Swift, revisa los benchmarks por lenguaje.

#Devstral, especialista en agentes (Mistral AI)

Devstral es el modelo de código de Mistral, entrenado específicamente para trabajar con agentes: es decir, con un agente como Aider, OpenHands o SWE-agent que itera sobre el código, ejecuta las pruebas, lee la salida y corrige. En SWE-bench Verified, Devstral Small se sitúa entre los mejores modelos de pesos abiertos, en una posición que habría sido inalcanzable hace un año.

Variante recomendada: Devstral Small (~24B, denso). Apache 2.0. Disponible en Hugging Face y Ollama.
VRAM en Q4_K_M: Aproximadamente 14 GB. Cabe holgadamente en una RTX 4080 de 16 GB o en un Mac de la serie M con 24 GB. Es posible con 12 GB, pero con poco margen y un contexto reducido.
Ventana de contexto: 128k tokens. Ampliamente suficiente para cargar un repositorio de tamaño medio.
Fortaleza: Excelente para flujos de trabajo agénticos de varios pasos: leer un informe de error, navegar por el código, escribir un parche, conseguir que las pruebas pasen.
Debilidad: No está diseñado para FIM (autocompletado línea por línea). Si quieres usarlo en Continue.dev para el autocompletado, cambia a qwen2.5-coder:7b-base para esa parte.

Instalar Devstral con Ollama

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

#Qwen3-Coder, la navaja suiza (Alibaba)

Qwen3-Coder es la generación de 2025 de la familia Coder de Alibaba, con arquitectura Mixture-of-Experts (MoE). Es el modelo que muchos consideran el estado del arte entre los modelos de pesos abiertos para la generación de código en 2026, en todos los formatos. Disponible bajo licencia Apache 2.0.

Versión para el público general: Qwen3-Coder 30B-A3B: 30 mil millones de parámetros en total, pero solo 3 mil millones activados por token. En concreto, eso da la calidad de un modelo denso de 14-22B con la velocidad de uno de 3B.
VRAM en Q4_K_M: Aproximadamente 18 GB para la 30B-A3B. Cabe justo en una RTX 4090 de 24 GB o en un Mac M-Pro/M-Max de 24-32 GB.
Variante de vanguardia: Qwen3-Coder 480B-A35B. Nivel Claude/GPT-5 en código, pero reservado para Mac Studio Ultra 256-512 GB o para configuraciones multi-GPU H100.
Contexto: 256k tokens de forma nativa, ampliable. Puedes literalmente pegar un repositorio entero dentro.
Fortalezas: Excelente en refactorización de varios archivos, maneja bien los lenguajes "de nicho" (Elixir, Zig, OCaml), muy bueno en tareas con agentes, y el MoE lo hace excepcionalmente rápido.
Debilidad: El 30B-A3B sigue siendo un MoE: si vas justo de VRAM, se nota el consumo adicional de memoria frente a un modelo denso de 9B. Con 12 GB, quédate con un Qwen 3.5 9B (en Q8 si hace falta).

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 qué el MoE A3B es tan rápido?

Con 3B de parámetros activos por token, el cálculo necesario en cada generación es el de un modelo de 3B, pero con el "conocimiento" de uno de 30B. En una RTX 4090, puedes esperar entre 60 y 80 tokens/segundo, mientras que un modelo denso de 32B alcanza como máximo 25-30. En el uso diario, es la diferencia entre "escribo con el modelo" y "espero al modelo".

#Qwen 3.5, la apuesta segura para equipos modestos

La familia Qwen 3.5 (2B, 4B, 9B) es en 2026 la opción más versátil para configuraciones modestas. Apache 2.0, gran contexto (hasta 256k), multimodal en tamaños medios, y adaptada para funcionar con entre 4 y 12 GB de VRAM. Exclusivamente para la autocompletación inline (FIM), se mantiene aparte qwen2.5-coder:7b-base, que sigue siendo la referencia en este caso concreto.

Qwen 3.5 4B: VRAM Q4 ≈ 3,4 GB (ollama run qwen3.5:4b). Ideal para RTX 3060 de 8 GB, RTX 4060 y MacBook Air de la serie M con 16 GB. El nuevo modelo pequeño por defecto, competente para conversar sobre código.
Qwen 3.5 9B: VRAM Q4 ≈ 6,6 GB (ollama run qwen3.5:9b). LA opción para 8 GB en 2026: 256k de contexto, visión, calidad notablemente superior a la del 4B. El modelo de uso diario para tarjetas de 8-12 GB.
Qwen 3.5 9B en Q8: VRAM ≈ 11 GB (ollama run qwen3.5:9b-q8_0). La máxima calidad de este segmento, justo para 12 GB de VRAM (RTX 3060 12 GB, RTX 4070).
Autocompletado (FIM): Qwen2.5-Coder 7B base sigue siendo LA referencia FIM en 2026: ollama run qwen2.5-coder:7b-base (≈ 4,7 GB). Conservarlo para el tabAutocomplete de VS Code (Continue.dev, Tabby).

Qwen 3.5 vs Qwen3-Coder

Qwen 3.5 (denso, generalista) se recomienda para configuraciones pequeñas (≤16 GB de VRAM), con qwen2.5-coder:7b-base como apoyo para el FIM. Qwen3-Coder (MoE especializado en código) está orientado a máquinas con más recursos (24 GB+) y al trabajo con agentes. Ambos coexisten.

#Alternativas notables

gpt-oss 20B (OpenAI): Modelo de OpenAI con pesos abiertos, cuantizado en MXFP4, muy rápido, con 131k de contexto. VRAM ≈ 14 GB (ollama run gpt-oss:20b). Buen equilibrio con 16 GB si buscas un modelo generalista orientado al código que responda con rapidez.
GLM 4.7 Flash (Zhipu AI): MoE 30B-A3B, licencia MIT, ≈ 19 GB en Q4 (ollama run glm-4.7-flash). Muy sólido en chat técnico, en depuración y en agentes. Pertinente si mezclas francés y código — las explicaciones salen naturalmente en francés.
Mistral Small 24B: Generalista denso, ≈ 14 GB en Q4 (ollama run mistral-small). Bueno en francés, útil como complemento para la documentación y las explicaciones en un equipo con 16 GB.
Codestral 22B (Mistral): Técnicamente correcto, pero con licencia Mistral non-production: prohibido en un entorno de trabajo. Descartarlo salvo para un uso estrictamente personal o de investigación.
DeepSeek-Coder V2, Code Llama, StarCoder 2: Estos modelos base de 2023-2024 han sido superados en calidad por todos los anteriores. Omitirlos: un Qwen 3.5 9B o un Granite 4.2 8B da mejores resultados con menos VRAM.

#¿Cuál elegir según tu GPU?

Recomendación práctica según la VRAM disponible. Los modelos mencionados están en cuantización Q4_K_M, el mejor equilibrio calidad/memoria para código.

8 GB (RTX 3060 8 GB, 4060, 5050, 5060): Qwen 3.5 9B (256k ctx, visión). Ya es muy útil para autocompletado y chat técnico. Para FIM puro, añade qwen2.5-coder:7b-base. Contexto 16-32k.
12 GB (RTX 3060 12 GB, 4070, 5070): Qwen 3.5 9B en Q8 (11 GB) en uso diario, o Gemma 4 12B (7,6 GB, multimodal). Devstral en Q4 funciona con contexto reducido.
16 GB (RTX 4080, 4070 Ti Super, 5070 Ti, 5080): Devstral 24B para tareas con agentes, gpt-oss 20B o Mistral Small 24B como modelos generalistas, y qwen2.5-coder:7b-base para el FIM. Es la primera configuración en la que realmente tienes opciones.
24 GB (RTX 3090, 4090, RX 7900 XTX): Qwen3-Coder 30B-A3B (código) o Qwen 3.8 27B (generalista, el más parecido a un Copilot) como modelo de uso diario. Devstral como alternativa de respaldo para tareas con agentes, GLM 4.7 Flash para los agentes. Es la configuración con la que los modelos locales rivalizan con los de la nube en el día a día.
32 GB (RTX 5090) o Mac M-series 36-48 GB: Qwen3-Coder 30B-A3B en Q8 (32 GB), o Qwen 3.6 35B-A3B (23 GB, MoE rápido, la opción fiable de este segmento). Gran comodidad de uso, contexto 128k+. Se busca lo mejor sin concesiones.
Mac Studio Ultra 128 GB+: Qwen3-Coder 30B-A3B en Q8 con plena calidad y el contexto completo de 256k, o las variantes de vanguardia de Qwen3-Coder (480B-A35B) si buscas el nivel de una API. Es la única forma accesible (fuera de un centro de datos) de ejecutar en local un modelo de código de vanguardia.

#Conectar todo esto en VS Code

La opción más sencilla: Ollama escucha en http://localhost:11434, y Continue.dev (extensión de VS Code) sabe comunicarse con este endpoint de forma nativa. Aquí tienes una configuración mínima que combina qwen2.5-coder:7b-base para el autocompletado (rápido, FIM) y Qwen3-Coder para el chat (potente).

Obtener los modelos

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

~/.continue/config.json (fragmento)

{
  "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 los flujos de trabajo con agentes (refactorización de múltiples archivos, resolución de errores), Aider en CLI destaca especialmente con Devstral:

Aider + Devstral

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

#Consejos y errores comunes que conviene evitar

Contexto demasiado corto por defecto en Ollama: Ollama limita el contexto a 2048 tokens por defecto. Para programar, eso es ridículo. Configura num_ctx mediante un Modelfile o los parámetros de Continue.dev y aumenta el contexto a 16k o 32k como mínimo.
FIM vs chat — no los mezcles: Devstral y Qwen3-Coder no están optimizados para el FIM. Si los usas en autocompletado, obtendrás resultados extraños (respuestas de chat en medio de una función). Usa siempre un modelo adecuado para el FIM (qwen2.5-coder:7b-base) para el tabAutocomplete.
Cuantización demasiado agresiva: Para código, Q3 y los niveles inferiores empeoran visiblemente la calidad (sintaxis incorrecta, identificadores inventados). Usa como mínimo Q4_K_M. Q5_K_M si tienes suficiente VRAM.
Rendimiento que colapsa después de unos minutos: Ollama libera de la memoria los modelos inactivos al cabo de 5 minutos. Si programas de forma intermitente, ejecuta Ollama con OLLAMA_KEEP_ALIVE=1h para mantener el modelo cargado.
Modelo que siempre responde en inglés: Añade un prompt de sistema en Continue.dev o en el Modelfile: «Responde siempre en francés, con el código y los comentarios en inglés». Qwen 3.5 / 3.8 y Devstral siguen esta instrucción sin problemas.
Qwen 3.8 27B que reflexiona más de lo necesario: Con su configuración predeterminada de razonamiento, Qwen 3.8 27B tiende a razonar demasiado en tareas simples y a aumentar la latencia. Para programar a diario, configura su esfuerzo de razonamiento en low (o desactiva el thinking): ganas capacidad de respuesta sin una pérdida notable en las tareas habituales.

#Para ir más allá

Has elegido tu modelo de código y está funcionando. Algunas ideas para ir más allá:

Copilot local con Continue.dev: La guía detallada para configurar Continue.dev en VS Code con Ollama, modelos separados para autocompletado y chat, y atajos.
Usar Ollama en Claude Code y Cursor: Para conectar Devstral o Qwen3-Coder a Cursor o Claude Code a través del endpoint compatible con OpenAI de Ollama y usar estos IDE de gama alta sin recurrir a la nube.
Elegir tu cuantización (Q4, Q5, Q8, FP16): Para entender exactamente qué pierdes o ganas al pasar de Q4_K_M a Q5_K_M en un modelo de código y cuándo tiene sentido usar una cuantización de mayor precisión.

¿Esta guía te ha ayudado?

¿Un comentario, un error, una precisión? Avísanos, eso mejora la guía para todos.

Los kits de QuelLLMLa guía de referencia según el uso

Copiloto Local IA local Agentes Locales RAG Local IA en la empresa IA Sin Filtros Mac Imágenes IA

Todos los kits de por vida — 49 €

Continuación lógica

Casos de uso · 20 min