Local AI & Hardware

Mejores LLM Open Source para Ejecución Local (2026): Guía Mac VRAM y RTX

2026-09-02·22 min de lectura min de lectura·LLMPodium Team

Respuesta Rápida: El mejor LLM open source para ejecución local en 2026 depende de su memoria unificada (VRAM): en Macs de 16GB destacan Qwen 2.5 Coder 7B / 14B Q4_K_M (45–65 tps). En 32GB–64GB Macs/RTX, Qwen 2.5 Coder 32B Q4_K_M y Llama 3.3 70B IQ3_XXS ofrecen rendimiento de vanguardia en programación y razonamiento. Con 128GB de memoria unificada, ejecute DeepSeek R1 / V3 y Llama 3.3 70B Q8 sin costes en la nube.

1. Introducción: La revolución de los modelos abiertos locales en 2026

En 2026, ejecutar modelos de lenguaje de última generación en infraestructura propia ha dejado de ser un pasatiempo para ingenieros de sistemas: es una necesidad corporativa. Equipos de desarrollo, analistas financieros y organizaciones con altos estándares de privacidad están migrando desde APIs comerciales cerradas (OpenAI, Anthropic, Google) hacia arquitecturas abiertas autoalojadas.

Tres catalizadores fundamentales impulsan esta transformación:

  1. Soberanía de datos y cumplimiento normativo: Regulaciones exigentes (RGPD, HIPAA, SOC 2 Type II) prohíben compartir código fuente propietario, documentación interna y datos sensibles con servicios de inferencia en la nube de terceros.
  2. Arquitectura de Memoria Unificada de Apple Silicon (UMA): A diferencia de los PC convencionales donde la VRAM está limitada por tarjetas PCIe discretas (con un techo de 24GB en las NVIDIA GeForce RTX 4090 / 5090 de consumo), los chips Apple M (M3/M4 Pro, Max y Ultra) comparten entre 128GB y 192GB de memoria LPDDR5X de alta velocidad, accesible por los núcleos gráficos con anchos de banda de 400 a más de 800 GB/s.
  3. Evolución de la cuantización matricial (GGUF, EXL2, AWQ, MLX): Los algoritmos modernos (k-quants, matriz de importancia imatrix IQ2/IQ3/IQ4) permiten ejecutar modelos de 70 mil millones de parámetros en menos de 38GB de RAM con una degradación imperceptible de perplejidad (<0.15 puntos en Wikitext-2).

Esta guía técnica compara los modelos abiertos más destacados en Apple Silicon (de 16GB a 128GB) y GPUs NVIDIA RTX, proporcionando fórmulas de cálculo de VRAM, velocidades reales de inferencia (tps, TTFT), pruebas en SWE-bench, LiveCodeBench y MMLU-Pro, así como configuraciones óptimas para producción.

2. Comparativa de hardware: Memoria Unificada Apple vs GPUs Dedicadas NVIDIA

Comprender la topología de la memoria es fundamental para seleccionar el tamaño del modelo y el formato de cuantización idóneo. 

+-----------------------------------------------------------------------------------------+
|                                TOPOLOGÍA DE MEMORIA DE HARDWARE                         |
+---------------------------------------------------+-------------------------------------+
| Memoria Unificada Apple Silicon (UMA)             | PC Convencional (x86_64 + NVIDIA)   |
+---------------------------------------------------+-------------------------------------+
| CPU y GPU comparten el mismo espacio LPDDR5X      | RAM del sistema (DDR5) separada     |
| Sin cuello de botella en transferencias PCIe      | Transferencia por bus PCIe Gen 4/5  |
| Límite de memoria: 16GB hasta 192GB (M4 Ultra)    | Límite VRAM: 16GB–24GB (Single RTX) |
| Ancho de banda: 150 GB/s (Base) a 800+ GB/s       | Ancho de banda: 1.008 GB/s (RTX 4090|
| Aceleración Metal Performance Shaders y MLX       | Núcleos CUDA, Tensor y FlashAttn    |
| Máxima capacidad de contexto por dólar invertido  | Máxima velocidad de inferencia (TPS)|
+---------------------------------------------------+-------------------------------------+

Fórmula matemática de cálculo de VRAM para LLMs locales

Para estimar el consumo exacto de memoria y evitar errores de falta de memoria o caídas en swap:

$$\text{VRAM Total (GB)} = \left( \frac{\text{Parámetros (Miles de Millones)} \times \text{Bits por Peso}}{8} \times 1.15 \right) + \text{Caché KV (GB)} + \text{Overhead SO (GB)}$$

Donde:

  • Parámetros (Miles de Millones): Tamaño del modelo (7B, 14B, 32B, 70B).
  • Bits por Peso: 16 para FP16, 8 para Q8_0, 4.5 para Q4_K_M, 3.2 para IQ3_M.
  • Multiplicador 1.15: Margen de seguridad del 15% para activaciones y búferes intermedios.
  • Caché KV: $\text{Caché KV} = 2 \times \text{Capas} \times \text{Cabezas} \times \text{Dimensión de Cabeza} \times \text{Ventana de Contexto} \times \text{Bytes/Elemento}$. En una ventana de 8k tokens para un modelo de 70B, el caché FP16 consume ~2.5GB; la cuantización a 4 bits (--cache-type-k q4_0 --cache-type-v q4_0) lo reduce a 0.7GB.
  • Overhead del Sistema Operativo: macOS reserva entre 4GB y 6GB para la interfaz y procesos del sistema. Linux headless requiere ~1.2GB.

3. Matriz de rendimiento comparativa: Modelos locales en 2026

Evaluamos los modelos abiertos de referencia en generación de código, capacidad de razonamiento, invocación de herramientas y rendimiento por segundo.

Entornos de prueba:

  • Rig A (Apple Silicon Ultra): Mac Studio M3/M4 Ultra, 128GB Memoria Unificada, 800 GB/s de ancho de banda.
  • Rig B (Apple Silicon Max): MacBook Pro M4 Max, 48GB Memoria Unificada, 410 GB/s de ancho de banda.
  • Rig C (Apple Silicon Pro): MacBook Pro M4 Pro, 24GB Memoria Unificada, 273 GB/s de ancho de banda.
  • Rig D (Dual NVIDIA RTX): 2x NVIDIA GeForce RTX 4090 24GB (48GB VRAM total), AMD Ryzen 9 9950X, 64GB DDR5.
Modelo Arquitectura y Parámetros Formato de Cuantización VRAM Mínima Necesaria SWE-bench Verified LiveCodeBench v4 MMLU-Pro Velocidad (Mac Studio 128GB) Velocidad (Dual RTX 4090)
Qwen 2.5 Coder 32B Denso / 32.5B Q4_K_M (19.8 GB) 24 GB UMA / VRAM 43.6% 51.2% 68.4% 38.2 tps 76.4 tps
Llama 3.3 70B Instruct Denso / 70.6B Q4_K_M (42.5 GB) 48 GB UMA / Dual GPU 41.2% 48.7% 73.1% 18.5 tps 42.1 tps
DeepSeek R1 Distill 32B Denso Razonamiento/32B Q4_K_M (20.1 GB) 24 GB UMA / VRAM 42.8% 49.5% 71.8% 37.8 tps 74.2 tps
DeepSeek Coder V2.5 MoE (21B act. / 236B) IQ3_XXS (88.4 GB) 96 GB–128 GB UMA 39.4% 46.8% 66.2% 14.2 tps Cuello de botella PCIe
Qwen 2.5 Coder 14B Denso / 14.7B Q4_K_M (9.2 GB) 16 GB UMA / VRAM 33.8% 40.1% 58.6% 62.4 tps 112.5 tps
Qwen 2.5 Coder 7B Denso / 7.6B Q8_0 (8.1 GB) 12 GB UMA / VRAM 27.4% 34.2% 51.3% 94.1 tps 168.0 tps
GLM-4 9B Chat Denso / 9.2B Q4_K_M (5.8 GB) 10 GB UMA / VRAM 26.8% 32.7% 54.2% 86.5 tps 148.2 tps
Llama 3.2 3B Denso / 3.2B FP16 (6.4 GB) 8 GB UMA / VRAM 16.2% 21.4% 39.8% 145.0 tps 240.0 tps

4. Guía de selección de hardware: ¿Qué modelo ejecutar según su equipo?

Nivel 1: 16GB de memoria unificada (MacBook Air y Pro base con M2/M3/M4)

  • VRAM disponible para modelos: 11GB–12GB (macOS reserva ~4GB).
  • Modelo destacado: Qwen 2.5 Coder 7B (Q8_0 o Q4_K_M) o Qwen 2.5 Coder 14B (Q3_K_M / Q4_K_S).
  • Alternativa: Llama 3.2 3B (Q8_0) para tareas auxiliares ultrarrápidas y generación de mensajes de commit.
  • Rendimiento: 55–90 tokens/seg. Excelente para autocompletado, documentación y refactorización de funciones.

Nivel 2: 24GB a 36GB de memoria unificada (M3/M4 Pro y Max base, RTX 3090/4090 individual)

  • VRAM disponible para modelos: 18GB–28GB.
  • Modelo destacado: Qwen 2.5 Coder 32B Instruct (Q4_K_M) — el punto óptimo para desarrollo de software local.
  • Alternativa: DeepSeek R1 Distill Qwen 32B (Q4_K_M) para razonamiento complejo, resolución de algoritmos y diseño arquitectónico.
  • Rendimiento: 28–38 tokens/seg en Apple Silicon; 70–80 tokens/seg en RTX 4090. Resuelve incidencias complejas en múltiples archivos.

Nivel 3: 48GB a 64GB de memoria unificada (M3/M4 Max 48GB/64GB, Dual RTX 3090/4090)

  • VRAM disponible para modelos: 38GB–52GB.
  • Modelo destacado: Llama 3.3 70B Instruct (Q4_K_M) y Qwen 2.5 Coder 32B (Q8_0).
  • Alternativa: Command R+ (Q3_K_S) para análisis masivo de documentación corporativa con ventana de 128k.
  • Rendimiento: 16–22 tokens/seg en M4 Max; 40–48 tokens/seg en doble RTX 4090. Razonamiento equiparable a modelos comerciales de primer nivel.

Nivel 4: 96GB a 128GB+ de memoria unificada (Mac Studio M2/M3/M4 Ultra, Mac Pro)

  • VRAM disponible para modelos: 80GB–110GB.
  • Modelo destacado: Llama 3.3 70B Instruct (Q8_0), DeepSeek Coder V2.5 MoE (IQ3_M / Q4_K_M) y DeepSeek R1 671B cuantizado (IQ1_S / IQ2_XXS).
  • Rendimiento: 14–20 tokens/seg en arquitecturas MoE complejas. Capacidad de mantener ventanas de más de 64k tokens sin saturar memoria.

5. Análisis detallado de los modelos principales

5.1 Qwen 2.5 Coder 32B: El estándar de oro en programación

Entrenado con 5.5 billones de tokens en 92 lenguajes de programación, este modelo de Alibaba hace innecesarias muchas suscripciones de pago.

  • Ventaja arquitectónica: Frecuencia base de RoPE optimizada a 1M para un análisis fiable de contextos de 32k a 128k.
  • SWE-bench Verified: 43.6% (superando a GPT-4 y Claude 3 Sonnet en sus versiones originales).
  • Capacidad como agente: Excelente cumplimiento de esquemas JSON y llamadas a herramientas en entornos como Cline, Roo Code y OpenCode.

5.2 Llama 3.3 70B Instruct: El modelo insignia abierto de Meta

La actualización de Meta iguala el rendimiento del modelo 405B original con una fracción de los requisitos de hardware.

  • Ventaja arquitectónica: La atención Grouped-Query Attention (GQA) con 8 cabezas KV reduce el consumo de memoria del caché en un 75% frente a MHA clásico.
  • MMLU-Pro: 73.1%, compitiendo directamente con Claude 3.5 Sonnet en ingeniería de sistemas, lógica y derecho.
  • Estabilidad de cuantización: Conserva el 99.1% de la precisión de pesos FP16 en formato Q4_K_M (42.5GB).

5.3 DeepSeek R1 Distill Qwen 32B: Razonamiento de élite en su escritorio

Versión compacta enriquecida con cadenas de pensamiento (...) mediante aprendizaje por refuerzo.

  • Puntos fuertes: Excelente para detectar condiciones de carrera en código asíncrono y verificar pruebas matemáticas complejas.
  • Consideración: Produce un mayor número de tokens debido al monólogo interno; requiere al menos 30 tps para una experiencia fluida.

6. Motores de inferencia: Ollama vs llama.cpp vs vLLM vs MLX

La elección del motor de ejecución influye decisivamente en la velocidad de generación, la latencia y la facilidad de uso. 

+-----------------------------------------------------------------------------------------+
|                                TAXONOMÍA DE MOTORES DE INFERENCIA                       |
+-------------------+-------------------+------------------------+------------------------+
| Motor             | Plataforma        | Ventaja Principal      | Mejor Escenario        |
+-------------------+-------------------+------------------------+------------------------+
| **Ollama**        | macOS, Linux, Win | Sencillez CLI y API    | Entornos locales de dev|
| **llama.cpp**     | Multiplataforma   | Rendimiento C++ y GGUF | Cuantización avanzada  |
| **vLLM**          | Linux / NVIDIA    | PagedAttention y TPS   | Servidores concurrentes|
| **MLX / LM-Studio**| Apple Silicon Mac | Optimización Metal     | Interfaz gráfica y Mac |
+-------------------+-------------------+------------------------+------------------------+

Implementación práctica: Configuración de Qwen 2.5 Coder 32B en Ollama

Puesta en marcha con contexto de 32k tokens y caché KV de 4 bits: 

# 1. Instalar Ollama en macOS / Linux
curl -fsSL https://ollama.com/install.sh | sh

# 2. Descargar Qwen 2.5 Coder 32B Q4_K_M
ollama run qwen2.5-coder:32b-instruct-q4_K_M

# 3. Crear un Modelfile personalizado para contexto de 32k
cat << 'EOF' > Modelfile-Coder
FROM qwen2.5-coder:32b-instruct-q4_K_M
PARAMETER num_ctx 32768
PARAMETER num_predict 4096
PARAMETER stop "<|im_end|>"
PARAMETER temperature 0.2
PARAMETER top_p 0.95
EOF

ollama create local-coder-32k -f Modelfile-Coder
ollama serve

Aceleración nativa en Mac mediante Apple MLX

Para exprimir al máximo el hardware de Apple Silicon con el framework MLX: 

# Instalar MLX-LM
pip install mlx-lm

# Inferencia nativa con Qwen 2.5 Coder 32B 4-bit
python -m mlx_lm.generate   --model mlx-community/Qwen2.5-Coder-32B-Instruct-4bit   --prompt "Escribe un patrón de actores concurrentes en Rust usando Tokio."   --max-tokens 2048   --temp 0.2

7. Análisis de costes y retorno de inversión: Hardware local vs APIs Cloud

¿Resulta rentable invertir en un Mac Studio (3.999 $) o una estación de trabajo con 2x RTX 4090 (3.500 $) frente al pago por tokens en APIs como Claude 3.7 Sonnet u OpenAI o3? 

+-----------------------------------------------------------------------------------------+
|                                COSTE ACUMULADO EN 24 MESES                              |
|                                                                                         |
| 15.000 $ |                                               APIs en la Nube (Uso Intensivo)|
|          |                                               .................../           |
| 10.000 $ |                                 ............./                               |
|          |                   ............./                                             |
|  5.000 $ |     ............/                      Mac Studio M4 Ultra Local (3.999 $)   |
|          | ---/------------------------------------------------------------------------ |
|      0 $ +----------------------------------------------------------------------------- |
|          Mes 0             Mes 6              Mes 12             Mes 18        Mes 24   |
+-----------------------------------------------------------------------------------------+
Perfil de Equipo Consumo Mensual de Tokens Coste APIs Cloud (Sonnet/o3) Coste Mac Studio 128GB Local Periodo de Amortización
Desarrollador Individual 15M tokens/mes 85 $ / mes 3.999 $ inicial + 8 $/mes luz 48 meses
Agencia Tecnológica (5 devs) 120M tokens/mes 680 $ / mes 3.999 $ inicial + 18 $/mes luz 5,8 meses
Departamento TI (20 devs) 850M tokens/mes 4.850 $ / mes Clúster 2x Mac Studio (7.998 $) 1,7 meses

Conclusión económica: Para uso esporádico, las APIs comerciales son convenientes. Sin embargo, para equipos de ingeniería activos que emplean agentes autónomos (Cline, Roo Code o Aider consumiendo entre 500k y 2M de tokens por tarea), el hardware local se amortiza en menos de seis meses garantizando total privacidad.

8. Recomendaciones prácticas para despliegues empresariales

  1. Para portátiles Mac de 16GB: Priorice Qwen 2.5 Coder 14B Q4_K_M o 7B Q8_0. No intente cargar modelos de 32B en 16GB: el uso intensivo de swap desgasta el disco y reduce la velocidad a menos de 2 tps.
  2. Para equipos de 32GB a 48GB: Utilice Qwen 2.5 Coder 32B Instruct (Q4_K_M) como modelo habitual de código y Llama 3.3 70B (IQ3_XXS) para arquitectura.
  3. Optimización de Caché KV: Habilite la compresión de 4 bits (q4_0) en llama.cpp y Ollama para ahorrar de 3GB a 8GB de memoria en contextos largos superiores a 32k.
  4. Integración con Agentes: Conecte el endpoint de Ollama local (http://localhost:11434/v1) como proveedor OpenAI a sus extensiones en VS Code para desarrollar de forma totalmente privada y sin conexión.

9. Preguntas frecuentes (FAQ)

¿Puede un procesador Apple Silicon M4 Pro ejecutar Llama 3.3 70B?

Un M4 Pro con 24GB o 36GB no puede ejecutar Llama 3.3 70B sin una cuantización extrema (IQ2_XXS) y una penalización grave por swap de disco (<1 tps). Para alcanzar una velocidad de 18 a 22 tps con calidad Q4_K_M se requieren al menos 48GB a 64GB de memoria unificada.

¿Por qué la memoria unificada de Apple supera a NVIDIA para modelos de 70B+?

Por capacidad y coste. Ejecutar un modelo 70B en Q8 o modelos MoE voluminosos requiere de 60GB a 120GB de VRAM. En PC esto exige varias tarjetas profesionales NVIDIA (A100/H100) con costes de 6.000 a más de 30.000 $. Un Mac Studio de 128GB ofrece esa capacidad en un equipo de escritorio silencioso por menos de 4.000 $.

¿Cuál es el mejor modelo para agentes de programación autónomos en local?

Qwen 2.5 Coder 32B Instruct es la opción de referencia indiscutible. Logra un 43.6% en SWE-bench Verified, maneja con precisión esquemas de llamadas a herramientas JSON y se ejecuta holgadamente en 24GB de memoria en formato Q4_K_M.

← Todos los Artículos
0 / 4
Comparar ahora →