El mejor LLM local para programación en agosto de 2026, por VRAM: Qwen3-Coder 30B, gpt-oss-20b, Qwen 2.5 Coder 7B

El mejor LLM local para programación en agosto de 2026 se decide por tu VRAM antes que cualquier otra cosa. Si tienes una tarjeta de 24GB — una RTX 3090 o 4090 — ejecuta Qwen3-Coder-30B-A3B-Instruct: 30B de parámetros totales con solo 3.3B activos por token, una ventana de contexto de 262,144 tokens, y los mejores números de programación local en general que podemos verificar. En 16GB es gpt-oss-20b, el modelo Mixture-of-Experts de OpenAI con licencia Apache-2.0 que cabe completamente en GPU con ~14GB y alcanza unos 140 tokens/seg. En 8GB es Qwen2.5-Coder-7B, el caballo de batalla fiable con ~4.7GB. El resto de esta página es el razonamiento, los números medidos y las situaciones específicas en las que cada una de esas opciones es incorrecta.

Lo que la primera página hace bien — y lo que omite

El ranking del "mejor LLM local para codificar" en este momento es una mezcla de una pieza genuinamente útil y mucha autoridad de dominio. La guía de Tembo (5 de junio de 2026) da la forma correcta: organiza por niveles de 8GB / 12–16GB / 24GB y se decanta por la familia Qwen Coder, pero no publica puntuaciones de benchmark para los modelos locales, ni cifras de tokens por segundo, ni tamaños de ventana de contexto, ni opciones para Apple Silicon según la RAM. Un harness de evaluación de GitHub (gauravvij/local-llm-coding-eval) tiene números reales pero sin veredicto y solo se ejecutó en CPU. El resto son artículos de opinión de un solo autor (XDA, Yahoo Tech) y listículos superficiales (apidog, Security Boulevard, SitePoint) que se clasifican por autoridad de dominio, no por ser útiles.

Lo que todos omiten, en orden de cuánto te cuesta:

• La brecha agéntica. La generación de código no es la misma habilidad que conducir un agente a través de un cambio en varios archivos. La primera página apenas lo menciona; es la diferencia entre un modelo que conservas y un modelo que desinstalas.

• Ventanas de contexto.La codificación agéntica quema tokens cargando archivos y salida de pruebas. Una afirmación de que «30B cabe en 24GB» no significa nada hasta que preguntas en qué contexto cabe.

• Matemáticas de cuantización. Nadie explica que el 4-bit necesita aproximadamente el número de parámetros en gigabytes, o que Q3 consigue VRAM a costa de sutiles errores de sintaxis.

• Velocidad medida. Pocos artículos publican tokens/seg para los modelos que recomiendan, y los que lo hacen discrepan enormemente porque el contexto y la cuantización lo cambian todo.

• Cuando lo local es la decisión equivocada. Una prueba de campo de 2026 sobre una aplicación Flutter de 15.000 líneas (EPAM) sigue mostrando que los modelos de frontera en la nube ganan en las refactorizaciones de varios pasos más difíciles. Ninguno de los listicles te dice cuándo parar.

El cálculo de VRAM que la mayoría de los listicles se saltan

La regla general que hace comprensibles todos los demás números de este artículo: con cuantización de 4 bits, un modelo necesita aproximadamente su número de parámetros en gigabytes — 7B ≈ 5GB, 30B ≈ 18GB+, antes de la sobrecarga de la caché KV. Q4 es el punto óptimo para codificar; Q3 e inferiores ahorran VRAM, pero introducen errores de sintaxis sutiles y medibles. Y la caché KV crece con la ventana de contexto, por lo que «un 30B cabe en 24GB» solo es cierto en un contexto que de hecho tengas que especificar.

Mixture-of-Experts cambia las matemáticas de una manera que importa para las dos grandes selecciones a continuación. Los parámetros totales definen el tamaño; los parámetros activos definen la velocidad. Por eso Qwen3-Coder-30B-A3B (30B totales, 3.3B activos) y gpt-oss-20b (20.9B totales, 3.61B activos) se sienten mucho más rápidos de lo que su peso en disco sugiere, y por eso DeepSeek V4 Flash — 284B totales, 13B activos — no es una buena opción para uso local, aunque su API sea económica.

24GB VRAM: Qwen3-Coder 30B

Qwen3-Coder-30B-A3B-Instruct es el codificador local polivalente más potente al que podemos apuntar ahora mismo. Publicado en julio de 2025 por el equipo Qwen de Alibaba bajo Apache 2.0, es un modelo de mezcla de expertos con 30B de parámetros totales y 3.3B activos por token, una ventana de contexto de 262,144 tokens y una huella de 4 bits de aproximadamente 17–20GB, lo que deja margen real en una tarjeta de 24GB para la caché KV que necesita una sesión de codificación larga.

En el harness local independiente en el que más confiamos (gauravvij/local-llm-coding-eval, cuatro modelos ejecutados localmente vía Ollama en CPU), qwen3-coder:30b obtuvo un 80 % en generación de código, un 77 % en selección de herramientas y un 80 % en precisión de agente: el resultado más equilibrado de los cuatro y el único modelo que fue sólido en las tres tareas a la vez. Los rastreadores de terceros compilan su SWE-bench Verified en torno a 50.3, Aider Polyglot en 66.2 y LiveCodeBench v6 en 58.9; trátalos como cifras recopiladas, no como números oficiales de Alibaba, que es todo lo que Qwen ha publicado para este modelo.

La velocidad medida varía ampliamente según el hardware. Los puntos de datos más útiles: una configuración comunitaria de TurboQuant lo ejecuta en una RTX 3060 Ti de 8 GB a ~29 tokens/seg en generación con un contexto completo de 262K, y el benchmark oMLX midió la versión MLX de 4 bits en un M4 Pro (48 GB) a 73.6 tokens/seg con contexto de 1K, bajando a 13.5 tokens/seg a 64K. En una tarjeta de 24 GB en una configuración normal de Ollama, deberías esperar el rango de decenas de tokens por segundo, no los cientos — el precio a pagar por ejecutar un codificador casi de vanguardia en casa.

La advertencia honesta: no es el codificador local más rápido, y existe un Qwen3-Coder-Next más nuevo orientado al uso alojado y de CLI en lugar de instalaciones locales cuantizadas. Pero para trabajo agéntico a escala de repositorio en una sola tarjeta, Qwen3-Coder-30B es la elección hoy.

16GB VRAM: gpt-oss-20b

En una tarjeta de 16GB, la respuesta es gpt-oss-20b — y no hay ni comparación. Publicado el 5 de agosto de 2025 por OpenAI bajo Apache 2.0, es un modelo de mezcla de expertos con 20.9B de parámetros totales y 3.61B activos por token, una ventana de contexto de 131,072 tokens, y su cuantización nativa MXFP4 ocupa aproximadamente 14GB. Ese es el hecho decisivo: corre 100% en GPU en una tarjeta de 16GB, sin que nada se derrame a la RAM del sistema.

Por qué la residencia en la GPU importa más que cualquier punto de referencia: un modelo que cabe en la VRAM es 3–11 veces más rápido que uno que descarga. Un punto de referencia independiente registró 139.93 tokens/seg para gpt-oss-20b en una RTX 4080 — aproximadamente 2.8 veces una alternativa densa con la misma huella — y la puntuación de un evaluador de 2026 le otorgó un "índice de inteligencia" de 52.1, calificándolo como inigualable en la clase de 16 GB para codificación y depuración profesionales. Es un ajuste muy justo, así que ejecútalo solo y mantén el contexto moderado; la calidad se degrada en el extremo superior de la ventana.

La alternativa agéntica en 16GB es Devstral 24B (devstral-small-2:24b), que publica el único número de SWE-bench Verified entre los codificadores locales de clase 16GB — 46.8% — pero es lento, a menudo necesitando descarga de CPU a ~18 tokens/seg. Si tu trabajo son ediciones agénticas de múltiples archivos y puedes tolerar la velocidad, Devstral merece su lugar; si quieres velocidad además de código limpio, gpt-oss-20b es el predeterminado mejor. Los modelos densos de 14B — Qwen3-Coder 14B o Qwen2.5-Coder 14B en Q5 — son las alternativas cómodas y económicas.

8GB de VRAM: Qwen 2.5 Coder 7B

Con 8GB, la respuesta honesta es Qwen2.5-Coder-7B: parámetros de 7B con ~4,7GB en Q4_K_M, un contexto nativo de 32.768 tokens ampliable hasta 128K, y las mejores puntuaciones en benchmarks de autocompletado de código dentro de la clase de 7B. Es un modelo más antiguo — lanzado en noviembre de 2024 — y eso está bien, porque nada más reciente en el rango de 8GB lo ha destronado. Las pruebas de la comunidad lo sitúan en torno a 50 tokens/seg en una RTX 4060 o 3070; una prueba independiente con una RTX 4060 en marzo de 2026 midió 28–35 tokens/seg, una variación impulsada casi por completo por los ajustes de contexto.

Hay tres cosas que importan en una GPU de 8GB y no en otros lados. Primero, limita el contexto a 4–8K: la caché KV es lo que provoca OOM en una tarjeta de 8GB, no los pesos — un benchmark vio la velocidad saltar de ~3.6 a ~37 tokens/seg únicamente por limitar el contexto. Segundo, verifica con ollama ps que el modelo esté 100% en GPU; cualquier parte en CPU hace que la velocidad se desplome. Tercero, Q4_K_M, no Q3 — los errores de sintaxis de Q3 te cuestan más que el ahorro de VRAM.

El notable desarrollo de 2026 es que Qwen3-Coder-30B-A3B-Instruct ahora se puede comprimir en 8GB mediante la compresión de caché KV TurboQuant — una configuración comunitaria midió ~7.5GB y ~29 tokens/segundo en una RTX 3060 Ti con contexto completo de 256K. Funciona, pero es tan delicado que no lo recomendamos como opción predeterminada. Si quieres una opción más nueva lista para usar, Qwen3 8B (~5.2GB, modo de pensamiento híbrido) es un pequeño paso adelante respecto a Qwen2.5-Coder-7B en razonamiento general, aunque se queda ligeramente atrás en código puro.

¿Qué hay de Apple Silicon?

La memoria unificada cambia la ecuación en una dirección: la capacidad aumenta, la velocidad de generación baja. Una M4 Pro de 48GB puede alojar modelos que una tarjeta Windows de 16GB no puede, pero genera tokens mucho más lentamente en contextos largos. Los números que tenemos: la versión MLX de 4 bits de Qwen3-Coder-30B-A3B-Instruct usó 16.6GB en un contexto de 1K y 25.5GB en 64K en una M4 Pro, con una generación que cayó de 73.6 tokens/seg a 13.5 a medida que el contexto crecía (benchmark oMLX). gpt-oss-20b cabe cómodamente en 16GB de memoria unificada y es una excelente opción para Mac. Si quieres multimodal en Apple Silicon, Gemma 4 12B se ejecuta en aproximadamente 16GB de memoria unificada con un contexto de 256K — la opción local más potente si tu trabajo de programación está junto a documentos con muchas imágenes.

Los números independientes: codegen no es la habilidad que importa

Los datos más claros que encontramos son un único benchmark local que vale la pena citar completo. gauravvij/local-llm-coding-eval ejecutó cuatro modelos localmente mediante Ollama, en CPU, sin nube — generación de código, llamada a funciones y una tarea de agente multi-paso — con resultados que van en contra del instinto de que "un número mayor de generación de código gana":

• Qwen3.6 27B (qwen3.6:27b, denso, ~17GB): 80.0% generación de código, 84.6% herramientas, 100% agente — el mejor todoterreno.

• Qwen3.6 35B A3B (qwen3.6:35b-a3b, MoE, ~18GB): 70,0% generación de código, 84,6% herramientas, 100% agente.

• Qwen3-Coder-30B-A3B-Instruct (qwen3-coder:30b, MoE, ~17GB): 80.0% generación de código, 76.9% herramientas, 80% agente — el más equilibrado.

• DeepSeek-Coder-V2 33B (deepseek-coder:33b, dense, ~18GB): 90.0% en codegen — el mejor de los cuatro — pero 10% en agent, el último en trabajo de múltiples pasos.

Esa última línea es toda la lección. Un modelo que sobresale en la generación pura de código pero fracasa en tareas de agente es el modelo que desinstalarás después del primer bucle de "lee este archivo, cambia esta función, ejecuta la prueba". Juzga a un codificador local por la columna agéntica, no por la columna de generación de código.

Cuando ejecutar localmente es la decisión equivocada.

Local-first es la opción correcta por defecto para la privacidad, el trabajo sin conexión, el costo marginal de tokens nulo y el autocompletado donde la latencia importa más que la calidad máxima. Es la decisión equivocada en situaciones específicas y reconocibles — y esta es la sección que se salta en la primera página:

• El trabajo agéntico más difícil todavía te supera. La prueba de campo de EPAM de 2026 en una aplicación Flutter de 15 000 líneas descubrió que los modelos de frontera en la nube (GPT-5.3-codex) siguen superando a los modelos locales en la refactorización multipaso más compleja. Si tu día consiste en refactorizaciones de ocho horas de código heredado, lo local no está listo.

• Tus necesidades de contexto superan tu tarjeta. Un agente de codificación que carga un repositorio completo superará la caché KV que una tarjeta de 16GB puede contener. El contexto de 256K de Qwen3-Coder-30B es la razón por la que gana en el nivel de 24GB: las tarjetas más pequeñas pierden esta partida desde el principio.

• No puedes estar pendiente del hardware. El hardware es dinero real: una tarjeta de 24GB está en la gama de $700–1,600, más electricidad y mantenimiento. A bajo volumen, llamar a una API es más barato que el consumo de energía.

• DeepSeek V4 Flash es la prueba. Con 284B de parámetros en total, los pesos de 4 bits de DeepSeek V4 Flash por sí solos son aproximadamente 140GB — no es un modelo para tarjetas de consumo, sin más. Su diseño de 13B activos es exactamente la razón por la que su API es rápida y barata a $0.15 / $0.29 por 1M de tokens (MIT, contexto de 1M). Para ese modelo, "ejecutarlo localmente" es la pregunta equivocada; la API es el punto.

• Los equipos necesitan consistencia. Si cuatro ingenieros ejecutan cada uno una cuantización diferente de un modelo distinto, "funciona en mi máquina" se convierte en un peligro de compilación. Los endpoints de API compartidos te dan un objetivo determinista.

Si quieres la respuesta del lado de la API a esta misma pregunta — qué modelo de codificación en la nube es el predeterminado cuando lo local no es el equilibrio adecuado — lo cubrimos por separado en nuestra guía best-LLM-for-coding, y nuestro artículo sobre AI-coding-agents cubre herramientas como Cline y OpenCode que funcionan con estos modelos locales.

Cómo probar antes de comprar la tarjeta

La forma más barata de decidir es ejecutar tus propios prompts antes de comprometerte con el hardware. Ollama o LM Studio ponen en marcha cualquiera de las tres opciones en minutos, y la prueba que importa son los archivos reales de tu repositorio, no un benchmark. Un router se gana su lugar en la decisión complementaria: cuando comparas un candidato local con modelos frontera alojados, un único endpoint te permite ejecutar el mismo prompt en ambos sin tener que lidiar con múltiples claves. En OrcaRouter, DeepSeek V4 Flash se ofrece al precio de lista de su proveedor, trasladado sin cambios — $0.15 / $0.29 por cada 1M de tokens, 0% de margen — con conmutación automática por error, lo que lo convierte en una referencia barata y honesta para saber si tu modelo local es realmente mejor que la API de $0.15.

Una advertencia honesta: OrcaRouter no aloja Qwen3-Coder-30B-A3B-Instruct ni gpt-oss-20b. Si tu objetivo es estrictamente offline, un router es irrelevante para ti — autoalójalo y listo. Si tu objetivo es comparar en A/B el mismo modelo de peso abierto contra los modelos de frontera antes de gastar en una tarjeta, el trabajo del router es la comparación, no el alojamiento.

El resultado final

Tu VRAM decide primero; la calidad del modelo, segundo. Con 24GB, ejecuta Qwen3-Coder-30B-A3B-Instruct — el codificador local polivalente más potente, con el contexto de 256K que el trabajo agéntico necesita. Con 16GB, ejecuta gpt-oss-20b — un modelo poco común que es a la vez rápido y totalmente en GPU. Con 8GB, ejecuta Qwen2.5-Coder-7B y mantén tu contexto modesto. Evalúa cualquiera de ellos por la columna agéntica, no por la columna de generación de código, y acepta que la refactorización multiarchivo más difícil sigue perteneciendo a la nube. Las cifras anteriores están actualizadas al 10 de agosto de 2026 — vuelve a verificar la oferta de modelos y los precios de lista antes de gastar, porque este espacio cambia semanalmente.