Mejor LLM local para programar (2026): modelos Ollama por RAM

Qwen3.6 27B es el mejor modelo de programación local para la mayoría de las máquinas en 2026: una descarga de 17GB cuya ficha del modelo indica 77.2 en SWE-bench Verified. Aquí tienes la lista completa por nivel de RAM, con cada comando verificado en el registro de Ollama, y configuraciones listas para usar con continue.dev, aider y Zed.

Modelos de programación por VRAM / RAM
El mejor modelo de programación local para cada nivel de VRAM o de memoria unificada
Tu memoriaMejor opción para programarDescargaTambién cabe
8GB de RAM o de VRAMQwen2.5-Coder 7B4.7GBQwen2.5-Coder 1.5B para el autocompletado
16GB de RAM / 16GB de VRAMgpt-oss-20b14GBQwen2.5-Coder 7B + 1.5B para el autocompletado
24GB de VRAM / 24GB de RAMDevstral Small 2 (24B)15GBQwen3.6 27B (17GB) en una GPU de 24GB
32GB de RAMQwen3.6 27B17GBQwen3-Coder 30B (MoE), Devstral Small 2
96-128GB de RAMDevstral 2 (123B)75GBgpt-oss-120b (65GB, 96GB+)

El mejor modelo de programación local en 30B

Con unos 27 a 30B de parámetros están los modelos de programación abiertos más potentes que todavía caben en una sola máquina: 32 GB de RAM bastan en Q4, y 48 GB permiten Q8. Las cifras de memoria de abajo vienen directamente del conjunto de datos de ModelFit (sin estimaciones), y cada comando ollama run se verificó en el registro de Ollama (HTTP 200) el 2026-11-14.

ModeloTamañoCuant.RAM necesariaTamaño cargadoComando
Qwen3-Coder 30B MoE30.5B (3B activos)Q4_K_M32 GB18.6 GBollama run qwen3-coder:30b-a3b-q4_K_M
Qwen3-Coder 30B MoE30.5B (3B activos)Q8_048 GB32.5 GBollama run qwen3-coder:30b-a3b-q8_0
Qwen3.6 27B27BQ4_K_M32 GB18 GBollama run qwen3.6:27b
Qwen3.6 27B27BQ8_048 GB30 GBollama run qwen3.6:27b-q8_0
Devstral Small 2 24B24BQ4_K_M24 GB15.2 GBollama run devstral-small-2:24b

Qwen3-Coder 30B es la elección si tu máquina tiene 32 GB: su diseño MoE mantiene activos solo unos 3B de parámetros por token, así que decodifica mucho más rápido que un modelo denso de 27B en el mismo nivel de RAM. Qwen3.6 27B es la alternativa densa, y Devstral Small 2 24B es el único que cabe en máquinas de 24 GB en Q4.

Resumen

Máquina de 32GB: ejecuta qwen3.6:27b (77.2 en SWE-bench Verified según la ficha del modelo de Qwen) o devstral-small-2:24b (68.0% según la ficha de Mistral). 16GB: qwen2.5-coder:7b para el chat + qwen2.5-coder:1.5b para el autocompletado. 128GB: devstral-2:123b (72.2% en SWE-bench Verified). Todos los comandos se verificaron en el registro de Ollama el 2026-06-12.

Contenido
  1. La lista por nivel de RAM
  2. Qué cambió en 2026
  3. Configurar continue.dev + Ollama
  4. Configurar aider + Ollama
  5. Configurar Zed + Ollama
  6. Preguntas frecuentes
Tabla 1

¿Qué LLM local es el mejor para programar? La lista por niveles

Tu RAM (o VRAM) es el techo absoluto, así que la clasificación de abajo está organizada según lo que realmente cabe. Las puntuaciones mostradas son las publicadas en la ficha del modelo de cada fabricante y confirmadas en la fuente original; cuando no existe una cifra confirmada, lo decimos en lugar de inventarla. Cada comando ollama run se verificó en el registro de Ollama (HTTP 200) el 2026-06-12.

ModeloNivel de RAMDescargaContextoPuntuación con fuente
Qwen3.6 27B32GB17GB256K77.2 SWE-bench Verified
Devstral Small 2 (24B)24-32GB15GB384K68.0% SWE-bench Verified
Qwen3-Coder 30B (MoE)32GB19GB256Kn/d
gpt-oss-20b16-24GB14GB128Kn/d
Qwen2.5-Coder 7B8-16GB4.7GB32Kn/d
Qwen2.5-Coder 1.5Bcualquiera con 8GB+986MB32Kn/d
gpt-oss-120b96-128GB65GB128K41.8% aider polyglot
Devstral 2 (123B)128GB75GB256K72.2% SWE-bench Verified
  • Qwen3.6 27B

    32GB

    El modelo de programación local de referencia de 2026: una puntuación de programación agéntica de nivel frontera en una descarga que cabe en un Mac de 32GB o en una GPU de 24GB.

    ollama run qwen3.6:27b
  • Devstral Small 2 (24B)

    24-32GB

    El especialista en programación agéntica de Mistral. Algo más pequeño que Qwen3.6 27B, con la ventana de contexto más grande de este nivel.

    ollama run devstral-small-2:24b
  • Qwen3-Coder 30B (MoE)

    32GB

    Mixture-of-experts con solo 3.3B de parámetros activos: claramente más rápido por token que los modelos densos de 27B en el mismo hardware.

    ollama run qwen3-coder:30b
  • gpt-oss-20b

    16-24GB

    El pequeño MoE de pesos abiertos de OpenAI, la mejor opción de programación por debajo del nivel de 32GB.

    ollama run gpt-oss:20b
  • Qwen2.5-Coder 7B

    8-16GB

    El caballo de batalla para 16GB o menos, para ayuda de programación en modo chat. Combínalo con la variante 1.5B para el autocompletado.

    ollama run qwen2.5-coder:7b
  • Qwen2.5-Coder 1.5B

    cualquiera con 8GB+

    El modelo de autocompletado que recomienda oficialmente continue.dev, lo bastante pequeño para devolver sugerencias en línea al instante.

    ollama run qwen2.5-coder:1.5b
  • gpt-oss-120b

    96-128GB

    Para Mac Studio y máquinas de clase 128GB. Obtiene 41.8% en el benchmark aider polyglot, por encima de cualquier modelo abierto de clase 32B de esa clasificación.

    ollama run gpt-oss:120b
  • Devstral 2 (123B)

    128GB

    El mejor modelo de programación de pesos abiertos que funciona en una sola máquina con mucha memoria.

    ollama run devstral-2:123b

Fuentes: ficha del modelo Qwen3.6-27B (77.2 SWE-bench Verified, 59.3 Terminal-Bench 2.0), ficha del modelo Devstral Small 2 (68.0% SWE-bench Verified; Devstral 2 123B con 72.2%), clasificación aider polyglot (gpt-oss-120b 41.8%). Las cifras de SWE-bench las declaran los propios fabricantes en las fichas de sus modelos; las puntuaciones de aider provienen de ejecuciones independientes.

Qué cambió en 2026: la brecha de la programación local se cerró

Hace un año la respuesta estándar era Qwen2.5-Coder 32B, que solo logra 16.4% en el benchmark aider polyglot. La generación de 2026 lo cambió por completo: Devstral Small 2 obtiene 68.0% en SWE-bench Verified en una descarga de 15GB, y Qwen3.6 27B indica 77.2, cifras que en 2025 eran territorio de la nube de frontera. Si tu idea del "mejor modelo de programación local" viene de la era de Qwen2.5-Coder, todas las recomendaciones que recuerdas están desfasadas.

Dos salvedades mantienen a los modelos en la nube por delante para ciertas tareas: las sesiones agénticas muy largas (las ventanas de contexto locales se llenan más rápido en la práctica) y los mayores modelos de programación de pesos abiertos (DeepSeek, Kimi K2) son modelos de 600B a 1T de parámetros que ninguna máquina de consumo ejecuta. Pesos abiertos no es lo mismo que ejecutable en local. Para una comparación más detallada, consulta nuestro análisis de los modelos insignia locales frente a los de la nube.

¿Cómo uso un LLM local en VS Code? (continue.dev)

continue.dev es la alternativa de código abierto a Copilot más popular para VS Code y JetBrains. La configuración ahora está en ~/.continue/config.yaml (el antiguo config.json está obsoleto). Una configuración local completa: el chat con un modelo potente, el autocompletado con uno rápido:

models:
  - name: Qwen3.6 27B
    provider: ollama
    model: qwen3.6:27b

  - name: Autocomplete
    provider: ollama
    model: qwen2.5-coder:1.5b
    roles:
      - autocomplete

Qwen2.5-Coder 1.5B es el modelo de autocompletado que recomienda oficialmente continue.dev. Su documentación también desaconseja usar modelos de razonamiento para el autocompletado: las sugerencias deben llegar en milisegundos, no después de una cadena de razonamiento.

¿Cómo uso aider con Ollama?

aider es el compañero de programación con IA pensado para la terminal. Apúntalo a tu servidor local de Ollama:

export OLLAMA_API_BASE=http://127.0.0.1:11434
aider --model ollama_chat/qwen3.6:27b

Usa el prefijo ollama_chat/: la documentación de aider lo recomienda frente al simple ollama/. La trampa clave: Ollama usa por defecto una ventana de contexto de 2K y descarta en silencio todo lo que la supere (la propia advertencia de aider). Para programar hace falta mucho más. Aumenta el valor en el servidor:

OLLAMA_CONTEXT_LENGTH=32768 ollama serve

¿Cómo uso un LLM local en Zed?

Zed detecta automáticamente todos los modelos que Ollama ha descargado. Descarga un modelo y elígelo en el menú desplegable de modelos del panel Agent. Hay un ajuste que conviene cambiar: Zed fija por defecto el contexto de los modelos locales en 4096 tokens. En settings.json:

{
  "language_models": {
    "ollama": {
      "api_url": "http://localhost:11434",
      "available_models": [
        {
          "name": "qwen3.6:27b",
          "display_name": "Qwen3.6 27B",
          "max_tokens": 32768,
          "supports_tools": true
        }
      ]
    }
  }
}

Preguntas frecuentes

¿Cuál es el mejor LLM local para programar en 2026?

Qwen3.6 27B para la mayoría de las máquinas: 77.2 en SWE-bench Verified (según su ficha del modelo) en una descarga de 17GB que cabe en un Mac de 32GB o en una GPU de 24GB. Devstral Small 2 es la mejor alternativa para programación agéntica en el mismo nivel, con una ventana de contexto de 384K.

¿Cuánta RAM necesito para ejecutar un LLM de programación en local?

Con 16GB ejecutas modelos de clase 7B más un modelo de autocompletado rápido. 32GB es el punto ideal para los mejores modelos de programación locales actuales (Qwen3.6 27B, Devstral Small 2). De 96 a 128GB permiten ejecutar gpt-oss-120b y Devstral 2 123B.

¿Cuál es el mejor modelo local para el autocompletado de código?

Qwen2.5-Coder 1.5B, la recomendación oficial de continue.dev. Menos de 1GB, lo bastante rápido para sugerencias en línea. No uses nunca un modelo de razonamiento para el autocompletado.

¿Puede un LLM local reemplazar a GitHub Copilot o a Claude?

Para el autocompletado y las ediciones de un solo archivo, sí, totalmente sin conexión. Para sesiones agénticas largas en repositorios grandes, los modelos de nube de frontera siguen liderando, pero los modelos locales de 24 a 27B de 2026 cerraron la mayor parte de la brecha.

Guías relacionadas

¿No sabes qué cabe en tu máquina?Abre el asistente. Clasifica los modelos de programación para tu hardware exacto.
Abrir el asistente