Mejores modelos de código local en 2026: Qwen3-Coder vs DeepSeek vs Codestral

Datos rápidos

• Opción óptima (mayo 2026): Qwen3-Coder 30B con Q4_K_M en una GPU de 24 GB.
• Opción para portátil / GPU de 8-10 GB: Qwen3-Coder 7B con Q4_K_M (~5 GB).
• Opción para contexto largo: DeepSeek Coder V3 con Q4_K_M en 48 GB o más de VRAM.
• Opción de velocidad: Codestral 22B con Q4_K_M — la más rápida del nivel 22B+.
• Opción enterprise / apta para auditoría: Granite Code 34B (IBM, Apache 2.0).
• Opción para lenguajes de nicho: StarCoder 2 15B (cobertura de Rust, Lua, Haskell, Solidity).
• Cálculo de VRAM con Q4_K_M: aproximadamente (parámetros en B) × 0,6 GB más 2-4 GB de overhead de contexto.
• Las licencias no son iguales. Qwen3-Coder, DeepSeek Coder V3 y Granite Code son Apache 2.0. Codestral tiene la licencia Mistral Non-Production con condiciones comerciales separadas. Llama 3.3 usa la Llama Community Licence (apta para uso comercial con los filtros de política de Meta). StarCoder 2 se distribuye bajo BigCode OpenRAIL-M.

Comparativa de los seis modelos de código local en 2026

Cuál deberías elegir

Qwen3-Coder: la opción de código local por defecto

• Tamaños: 30B (el modelo estrella) y 7B (el modelo para portátiles y GPUs de 8 GB). Ambos son transformers densos (no mixture-of-experts).
• Ventana de contexto: 256K tokens para el 30B; 128K para el 7B. Entre las más grandes del grupo sin recurrir a modelos derivados de MoE.
• Énfasis del entrenamiento: corpus de entrenamiento multilingüe orientado al código, con fuerte cobertura de Python, TypeScript/JavaScript, Java, C++, Go y Rust. Los ejemplos de tool-calling forman parte del mix de post-entrenamiento.
• Licencia: Apache 2.0 — uso comercial permitido sin licencia adicional, con preservación de atribución.
• VRAM con Q4_K_M: el 30B encaja en aproximadamente 17-18 GB, dejando margen en una tarjeta de 24 GB para contexto y herramientas. El 7B encaja en aproximadamente 5 GB.
• Fiabilidad en tool-calling: el más sólido de los modelos de código de pesos abiertos para harnesses con esquemas de herramientas estrictos (Cline, modo agente de Continue.dev). La fiabilidad del formato XML que requiere Cline es alta en el 30B; menos fiable en el 7B.
• Dónde brilla: código de uso general (Python, TypeScript), tareas de gran contexto (refactorizaciones de archivos completos), bucles de agentes con uso de herramientas.
• Dónde flaquea: la variante 7B es buena para su tamaño pero no iguala al 30B en razonamiento multistep. Los lenguajes de nicho (Lua, Haskell, Solidity) tienen menos cobertura que StarCoder 2.

DeepSeek Coder V3: el modelo de peso pesado para contexto largo

• Arquitectura: MoE — parámetros totales muy superiores a los parámetros activos en inferencia. El modelo completo es más pesado en disco y VRAM de lo que sugeriría su recuento activo.
• Ventana de contexto: 128K tokens con técnicas de extensión que amplían el contexto útil dependiendo de la cuantización y el motor de inferencia.
• Énfasis del entrenamiento: código y razonamiento. Sólido en Python, TypeScript, C++ y Go. La planificación multistep y el razonamiento estilo chain-of-thought son puntos fuertes destacados.
• Licencia: Apache 2.0 — uso comercial permitido.
• VRAM con Q4_K_M: el V3 completo necesita 48 GB o más para inferencia cómoda. Existen variantes destiladas y derivadas de MoE más pequeñas orientadas a tarjetas de 24 GB; verifica la variante en la ficha de modelo antes de descargar.
• Fiabilidad en tool-calling: sólido en harnesses que permiten llamadas de herramientas estilo OpenAI; ligeramente más débil que Qwen3-Coder en el esquema XML estricto de Cline en mayo de 2026.
• Dónde brilla: razonamiento a nivel de repositorio completo, tareas de contexto largo, planes de agentes multistep.
• Dónde flaquea: la barra de hardware es la más alta de cualquier modelo de esta guía. En una tarjeta de 24 GB, las variantes derivadas más pequeñas son la única opción viable, y estas quedan por detrás del modelo completo en tareas de contexto largo.

Codestral 22B: la opción de velocidad con camino comercial claro

• Tamaños: 22B (el modelo estrella). Encaja cómodamente con Q4_K_M en una GPU de 16 GB con margen de contexto.
• Ventana de contexto: 32K tokens. Más pequeña que Qwen3-Coder y DeepSeek; suficiente para ediciones de un solo archivo y la mayoría de ediciones multiarchivo, pero limitante para trabajo con repositorios completos.
• Énfasis del entrenamiento: amplia cobertura de código multilenguaje con buen rendimiento en Python, TypeScript, Java, C++ y Bash.
• Licencia: licencia Mistral Non-Production por defecto; el uso comercial requiere la licencia comercial de Mistral (de pago). Esto es inusual en este grupo y es el dato más importante para equipos que van a lanzar un producto comercial con este modelo.
• VRAM con Q4_K_M: ~13 GB — encaja en una GPU de 16 GB con margen de contexto, cómodo en 24 GB.
• Velocidad de inferencia: más rápido que Qwen3-Coder 30B a la misma cuantización, y mucho más rápido que DeepSeek Coder V3. El trade-off calidad-velocidad es el más limpio de los seis.
• Dónde brilla: autocompletado en tiempo real en tarjetas de 16-24 GB, flujos de trabajo de equipos en la UE donde la relación comercial con Mistral importa, iteración rápida en chat.
• Dónde flaquea: el contexto de 32K es el más pequeño del grupo después de StarCoder 2. La historia de licencia es más compleja que Apache 2.0 — lee los términos de Mistral Non-Production antes de integrar.

Llama 3.3 Code: la opción de compatibilidad con el ecosistema

• Tamaños: 70B (de uso general, con capacidad de código), 8B (portátil / GPU de 8 GB). El 70B es el modelo estrella; el 8B es una opción frecuente de autocompletado por su fuerte soporte de herramientas.
• Ventana de contexto: 128K tokens.
• Énfasis del entrenamiento: uso general con fuerte capacidad de código — no está especializado en código de la misma manera que Qwen3-Coder o Codestral. Sus puntos fuertes en código provienen de la amplitud, no de la profundidad.
• Licencia: Llama Community Licence — uso comercial permitido bajo las restricciones de política de Meta, incluyendo un umbral de uso por encima del cual se aplican términos de licencia separados. Lee la licencia antes de integrar en productos comerciales.
• VRAM con Q4_K_M: ~40 GB para el 70B (las tarjetas de 24 GB necesitan la variante más pequeña o cuantización agresiva); ~5 GB para el 8B.
• Fiabilidad en tool-calling: buena para llamadas de herramientas estilo OpenAI; menos fiable que Qwen3-Coder en los esquemas XML estrictos de Cline. La variante 8B tiene dificultades con las llamadas de herramientas en bucles de agentes.
• Dónde brilla: stacks que ya ejecutan Llama (infraestructura existente, recetas de despliegue, fine-tunes), código de uso general con razonamiento no-código ocasional.
• Dónde flaquea: la dirección de código absoluta queda por detrás de los modelos especializados. Si el código es el caso de uso principal y no tienes dependencias de Llama, Qwen3-Coder es el mejor por defecto.

Granite Code: la opción enterprise y apta para auditoría

• Tamaños: 34B (el modelo estrella) y 8B (portátil / GPU de 8 GB). Transformers densos, no MoE.
• Ventana de contexto: 128K tokens.
• Énfasis del entrenamiento: multilenguaje orientado al código con documentación deliberada de los corpus de entrenamiento — una decisión de posicionamiento que importa más en compras que en calidad de código.
• Licencia: Apache 2.0 — la misma postura que Qwen3-Coder y DeepSeek Coder V3.
• VRAM con Q4_K_M: ~20 GB para el 34B, ~5 GB para el 8B.
• Dirección de código: queda por detrás de Qwen3-Coder 30B en la mayoría de benchmarks públicos; competitivo con Codestral en Python y Java, por detrás en TypeScript.
• Dónde brilla: elecciones impulsadas por compras, contextos de auditoría enterprise, despliegues en industrias reguladas donde la documentación de procedencia de datos del modelo es en sí misma un entregable.
• Dónde flaquea: la capacidad de código absoluta está por debajo de los líderes. Si las compras no son una restricción, Qwen3-Coder es la opción más sólida con el mismo presupuesto de hardware.

StarCoder 2: la opción para lenguajes de nicho

• Tamaños: 15B (la opción local práctica), 7B, 3B. Transformers densos.
• Ventana de contexto: 16K tokens — la más pequeña del grupo y la principal restricción.
• Énfasis del entrenamiento: amplitud sobre profundidad — entrenado en cientos de lenguajes de programación con cobertura deliberada de lenguajes menos comunes. El rendimiento en Python y TypeScript queda por detrás de los líderes, pero la cobertura de Rust, Lua, Haskell y Solidity es la mejor de su clase entre los modelos de pesos abiertos.
• Licencia: BigCode OpenRAIL-M — una licencia de IA responsable con restricciones de caso de uso. Lee la licencia antes de la integración comercial; es más permisiva que Mistral Non-Production pero más restrictiva que Apache 2.0.
• VRAM con Q4_K_M: ~9 GB para el 15B — encaja cómodamente en una tarjeta de 12 o 16 GB.
• Dónde brilla: trabajo en lenguajes de nicho (Rust, Lua, Haskell, Solidity, Elm, Julia), bases de código poliglotas, cobertura de lenguajes que otros modelos no ofrecen.
• Dónde flaquea: la ventana de contexto de 16K es la más pequeña del grupo; el rendimiento absoluto en Python y TypeScript está por debajo de Qwen3-Coder y DeepSeek.

Cálculo de VRAM por nivel de cuantización

• Q4_K_M (el estándar): el mejor balance entre tamaño y calidad para la mayoría del trabajo de código. Aproximadamente 0,6 GB por cada mil millones de parámetros. Un modelo de 30B encaja en ~18 GB; un 7B en ~5 GB.
• Q5_K_M: aproximadamente 0,75 GB por cada mil millones de parámetros. Un modelo de 30B necesita ~22 GB. La recuperación de calidad es pequeña pero medible en razonamiento multistep.
• Q6_K: aproximadamente 0,85 GB por cada mil millones de parámetros. Un modelo de 30B necesita ~26 GB. Vale la pena en una tarjeta de 32 GB.
• Q8_0: aproximadamente 1,05 GB por cada mil millones de parámetros. Un modelo de 30B necesita ~32 GB. La calidad más cercana a FP16 con la mitad de la VRAM.
• FP16 (sin cuantización): aproximadamente 2,0 GB por cada mil millones de parámetros. Un modelo de 30B necesita ~60 GB. Solo para fine-tuning o investigación; nunca para inferencia local.
• Coste de VRAM del contexto: escala con la longitud de secuencia. Como regla general, calcula ~1 GB por cada 32K tokens de contexto activo en modelos de código — significativo para el uso de contexto largo de DeepSeek Coder V3 y Qwen3-Coder.
• Overhead de herramientas: Ollama, LM Studio y llama.cpp añaden cada uno ~500 MB a ~1 GB sobre el modelo y el contexto. Reserva 2-4 GB de margen total para las herramientas activas.

Comparativa de ventana de contexto

Comparativa de licencias

Árbol de decisión: cuál deberías elegir

• 1. ¿Cuánta VRAM tienes? Menos de 12 GB: Qwen3-Coder 7B. 12-16 GB: Qwen3-Coder 7B o Codestral 22B. 24 GB: Qwen3-Coder 30B. 48 GB o más: DeepSeek Coder V3 (completo).
• 2. ¿Vas a lanzar dentro de un producto comercial? Sí: prefiere Apache 2.0 (Qwen3-Coder, DeepSeek Coder V3, Granite Code). Evita Codestral a menos que estés pagando la licencia comercial de Mistral.
• 3. ¿Necesitas una ventana de contexto superior a 32K? Sí: descarta Codestral y StarCoder 2. Elige Qwen3-Coder, DeepSeek, Llama Code o Granite Code.
• 4. ¿Programas en lenguajes de nicho (Rust, Lua, Haskell, Solidity)? Sí: StarCoder 2 15B, a pesar del límite de contexto de 16K.
• 5. ¿Estás en una industria regulada donde la licencia y la procedencia de los datos de entrenamiento necesitan defensa en compras? Sí: Granite Code 34B es el caso más fácil de argumentar.
• 6. ¿Todavía no estás seguro? Por defecto usa Qwen3-Coder — 30B si tienes una GPU de 24 GB, 7B en caso contrario. Reevalúa cuando lo superes.

Errores comunes al elegir un modelo de código local

• Error 1: elegir el modelo con el puntaje más alto en el leaderboard independientemente del hardware. Un modelo que no encaja con Q4_K_M y 2-4 GB de margen se desbordará al disco y quedará inutilizable para código interactivo. La VRAM es la restricción principal para la mayoría de los lectores.
• Error 2: confiar en la ventana de contexto declarada como la ventana de trabajo práctica. Los modelos de código pierden calidad de atención a partir de aproximadamente la mitad del contexto declarado. Planifica para la ventana práctica, no para el número del titular.
• Error 3: saltarse la lectura de la licencia. Codestral en un producto comercial sin licencia comercial de Mistral es un fallo de compras. La Llama Community Licence tiene filtros para aplicaciones de alto uso. Lee la licencia antes de integrar.
• Error 4: ignorar la fiabilidad del tool-calling al elegir para un harness de agente. Los esquemas XML estrictos de Cline, el modo agente de Continue.dev y cualquier bucle basado en MCP dependen de que el modelo emita llamadas de herramientas de forma limpia. Los modelos de código de 30B+ son fiables; los de clase 7B fallan con frecuencia.
• Error 5: no combinar un modelo de autocompletado pequeño con el modelo de chat más grande. Un modelo de chat de 30B es excesivo para autocompletado de menos de 200 ms. Ejecuta un modelo de autocompletado de 1,5B-7B junto al modelo de chat — la VRAM total se mantiene manejable y la latencia permanece interactiva.
• Error 6: no revisar la ficha de modelo cada seis meses. Las líneas de modelos de pesos abiertos se actualizan; las recetas de cuantización mejoran; las licencias a veces se endurecen. La opción por defecto de hoy no es necesariamente la de noviembre de 2026.

Fuentes

• Ficha de Qwen3-Coder en Hugging Face — Arquitectura, número de parámetros, ventana de contexto, licencia y dirección de benchmark reportada por el proveedor para Qwen3-Coder 30B.
• Ficha de DeepSeek Coder V3 — Detalles de arquitectura MoE, ventana de contexto, licencia y dirección de benchmark para DeepSeek Coder V3.
• Ficha de Codestral — Arquitectura, ventana de contexto y términos de licencia para Codestral 22B.
• Licencias comerciales de Mistral — Términos requeridos para el uso comercial de Codestral y otros modelos con licencia no-producción de Mistral.
• Fichas de Llama 3.3 — Tamaños, ventanas de contexto y texto de la Llama Community Licence para la familia Llama 3.3.
• Fichas de Granite Code (IBM) — Tamaños, ventanas de contexto, documentación de datos de entrenamiento y licencia Apache 2.0 para Granite Code.
• Fichas de StarCoder 2 (BigCode) — Tamaños, ventanas de contexto, cobertura de lenguajes y licencia BigCode OpenRAIL-M.
• Biblioteca de modelos de Ollama — Variantes de cuantización, tamaños de archivo y comandos de descarga para cada modelo.
• Texto completo de la licencia BigCode OpenRAIL-M — El texto completo de la licencia y las restricciones de caso de uso para los modelos de la línea StarCoder.

Preguntas frecuentes

Lecturas relacionadas

• Reemplazar GitHub Copilot con un LLM local — contexto de aplicación práctica: cálculo de costes, dimensionamiento de hardware y qué modelo encaja en qué flujo de trabajo.
• Continue.dev vs Cline vs Aider: el mejor agente de código local en 2026 — complementa la elección de modelo; la capa de harness bajo el modelo.
• LLM de código local sin internet — contexto de caso de uso de nicho para flujos de trabajo completamente offline.
• Cuantización de LLM explicada — la capa técnica más profunda detrás del cálculo de VRAM utilizado a lo largo de esta guía.
• Mejores LLMs locales en 2026 — autoridad de modelos de uso general para cargas de trabajo fuera del código.
• Power Local LLM Hub — biblioteca completa de guías.