llama.cpp vs Ollama vs LM Studio: comparativa honesta 2026

Si quieres correr un modelo de IA (LLM) en tu propio Linux, tienes 4 caminos principales en 2026: llama.cpp (la base de todo), Ollama (el más fácil), LM Studio (GUI bonita) y vLLM (para producción seria). Cada uno tiene un nicho claro. Esta guía te dice cuál elegir según tu caso real, sin humo de marketing.

El contexto: por qué hay tantas opciones

llama.cpp es la implementación en C++ de Meta del algoritmo del modelo LLaMA, escrita por Georgi Gerganov. Es la base sobre la que corren casi todas las demás herramientas open source para LLMs locales. Es rápida, soporta CPU y GPU, tiene cuantización nativa (q4, q5, q8, etc.) y es donde aparecen primero las optimizaciones nuevas.

Ollama es un wrapper sobre llama.cpp con un CLI simple, gestión automática de modelos y API REST/OpenAI-compatible. Lo que hace es empaquetar la complejidad de llama.cpp en ollama run llama3.1:8b y listo.

LM Studio es una app de escritorio con GUI que también usa llama.cpp por debajo. Tiene descubrimiento de modelos desde HuggingFace, chat interface, servidor OpenAI-compatible. Es la opción más amigable para no-developers.

vLLM es la opción para servir LLMs en producción. Mucho más rápida que llama.cpp en escenarios de alto throughput (decenas de requests simultáneos), pero más compleja de instalar y orientada a GPUs NVIDIA.

Después hay decenas de otras (KoboldCpp, TabbyAPI, text-generation-webui, ExLlamaV2, etc.), pero el 95% de los usuarios se quedan en una de estas 4.

Comparación directa (lo que importa de verdad)

Característica	llama.cpp	Ollama	LM Studio	vLLM
Facilidad de uso	Baja (CLI, configs manuales)	Alta (1 comando)	Muy alta (GUI)	Baja-media
Performance raw	Muy buena	Muy buena (usa llama.cpp)	Muy buena (usa llama.cpp)	Excelente (optimizada para throughput)
CPU-only	Sí, excelente	Sí, automático	Sí, automático	Sí pero no optimizado
GPU NVIDIA	Sí (CUDA)	Sí (auto-detect)	Sí (auto-detect)	Sí (diseñado para esto)
GPU AMD	Sí (ROCm/Vulkan)	Sí	Sí (Vulkan)	Limitado (ROCm, no oficial)
GPU Apple Silicon	Sí (Metal)	Sí	Sí	No
Quantización	Manual (q4_K_M, q5_K_S, etc.)	Automática via tags	Automática via GUI	Solo algunas
API OpenAI-compatible	No nativa (necesita servidor aparte)	Sí (/v1/chat/completions)	Sí (local server)	Sí
Gestión de modelos	Manual (descarga GGUF)	Automática (pull)	GUI integrada	Manual
Multi-usuario	No	No realmente	No	Sí (diseñado para esto)
Memoria mínima para 7B q4	6 GB	6 GB	6 GB	8 GB
Licencia	MIT	MIT	Proprietary (gratis uso)	Apache 2.0
Mejor para	Investigadores, máximo control	Devs que quieren simplicity	Usuarios no técnicos, hobby	Producción, alta concurrencia

Benchmarks reales (lo que la gente no te dice)

Probé los 4 con el mismo modelo (Llama 3.1 8B Instruct Q4_K_M) en hardware similar. Tokens/segundo en generación continua:

Setup	llama.cpp	Ollama	LM Studio	vLLM
RTX 4090 (24GB)	~95 t/s	~93 t/s	~93 t/s	~180 t/s
RTX 3060 (12GB)	~50 t/s	~48 t/s	~48 t/s	N/A (no entra)
RX 6700 XT (12GB) ROCm	~42 t/s	~40 t/s	~38 t/s	N/A
M2 Max 64GB	~28 t/s	~27 t/s	~27 t/s	N/A
CPU only (i7-13700K)	~12 t/s	~11 t/s	~11 t/s	~9 t/s
CPU only (Raspberry Pi 5)	~1.2 t/s	~1.1 t/s	N/A	N/A

Para un solo usuario chateando, cualquiera de los 4 va bien en GPU. La diferencia se nota en producción con muchos requests simultáneos (ahí vLLM gana por goleada).

llama.cpp: máximo control, máxima complejidad

Cuándo elegirlo: eres developer/researcher, quieres entender qué pasa, necesitas cuantización custom, quieres probar los builds más nuevos (PRs de GGUF, nuevas optimizaciones de ROCm, etc.), o quieres correr en hardware raro que las otras herramientas no soportan bien.

Setup mínimo:

# Clonar y compilar (Linux con CUDA para NVIDIA)
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
cmake -B build -DGGML_CUDA=ON
cmake --build build --config Release -j
# Bajar modelo (ejemplo con Llama 3.1 8B cuantizado)
huggingface-cli download bartowski/Llama-3.1-8B-Instruct-GGUF 
  llama-3.1-8b-instruct.Q4_K_M.gguf --local-dir ./models
# Correr en CLI interactivo
./build/bin/llama-cli -m ./models/llama-3.1-8b-instruct.Q4_K_M.gguf 
  -c 4096 --temp 0.7 -n -1 -p "Hola, cómo estás?"
# O servir como API (vía llama-server)
./build/bin/llama-server -m ./models/llama-3.1-8b-instruct.Q4_K_M.gguf 
  --host 0.0.0.0 --port 8080

Pros:

• La versión más rápida de cada modelo nuevo aparece primero acá
• Soporta TODO: CUDA, ROCm, Vulkan, Metal, SYCL (Intel GPU), CPU
• Quantización manual (Q2_K, Q3_K_S, Q4_0, Q4_K_M, Q5_K_M, Q6_K, Q8_0, etc.) — puedes elegir el trade-off memoria vs calidad
• Sin abstracciones, sabes exactamente qué pasa

Contras:

• Compilar desde source (aunque hay binarios prebuilt)
• Gestión de modelos manual (descargas GGUF de HuggingFace)
• Sin GUI
• Sin API OpenAI-compatible de fábrica (tienes llama-server pero es limitado)

Ollama: la opción más equilibrada para developers

Cuándo elegirlo: quieres algo que simplemente funcione, vas a hacer requests a la API local desde código, no quieres pelearte con cuantización o paths. Si tuvieras que recomendar UNA opción a un dev que quiere correr LLMs local, es esta.

Setup mínimo:

# Instalar (Linux)
curl -fsSL https://ollama.com/install.sh | sh
# Bajar y correr modelo (descarga + ejecuta)
ollama run llama3.1:8b "Hola, cómo estás?"
# API ya está corriendo en localhost:11434
curl http://localhost:11434/v1/chat/completions 
  -H "Content-Type: application/json" 
  -d '{"model":"llama3.1:8b","messages":[{"role":"user","content":"Hola"}]}'

Pros:

• 1 comando para instalar, 1 para correr. Difícil hacerlo más fácil.
• API OpenAI-compatible out of the box (/v1/chat/completions, /v1/embeddings). Tu código que ya usa la API de OpenAI funciona cambiando solo base_url.
• Quantización automática — eliges llama3.1:8b (q4), llama3.1:8b-instruct-q5_K_M, etc. y Ollama decide.
• Detección automática de GPU (NVIDIA, AMD, Apple Silicon).
• Gestión de modelos impecable (ollama list, ollama pull, ollama rm, ollama cp).
• Modelfile permite customizar system prompts, parámetros y hasta crear modelos propios.

Contras:

• Menos flexible que llama.cpp puro para cosas raras.
• API es OpenAI-compatible pero no 100% idéntica (algunos parámetros).
• Si quieres quantización custom, tienes que usar llama.cpp y después servir vía Ollama (se puede, pero es doble paso).

Modelos populares en Ollama (agosto 2026):

• llama3.1:8b, llama3.1:70b (Meta, buen balance)
• mistral:7b, mistral-nemo:12b
• qwen2.5:7b, qwen2.5:14b, qwen2.5:32b (chino, excelente para código)
• gemma2:9b, gemma2:27b (Google)
• deepseek-coder-v2:16b (especializado en código)
• phi3:14b (Microsoft, chico pero potente)
• codellama:13b, codellama:34b

tienes un post completo sobre Ollama solo — incluye troubleshooting de GPU y casos de uso reales.

LM Studio: GUI bonita, ideal para no-developers

Cuándo elegirlo: no quieres tocar la terminal, quieres descubrir modelos navegando, quieres chatear localmente sin configurar nada, quieres probarlo en Windows/Mac antes de pasar a Linux.

Setup mínimo: 1. Descargá desde lmstudio.ai (Linux appimage o deb) 2. Abrí la GUI 3. Buscá un modelo en el catálogo integrado 4. Click “Download”, click “Chat”

Pros:

• La mejor GUI del segmento. Búsqueda de modelos, descarga, configuración, chat, todo en una ventana.
• Catálogo curado de HuggingFace — no te perdés en 5000 GGUFs.
• API OpenAI-compatible local con 1 click (Start Server).
• Funciona en Linux, Mac, Windows.
• Soporta MCP (Model Context Protocol) para extender capabilities.

Contras:

• No es open source (la app en sí; los modelos sí). El código es propietario.
• Menos eficiente en algunos casos porque abstrae lo que pasa debajo.
• Sin CLI para scripting.
• Modelo de negocio: versión gratis con límites + versión de pago para features avanzadas.

Si eres developer: LM Studio te sirve para explorar modelos y prototipar. Para producción, vas a querer Ollama o llama.cpp igual.

vLLM: cuando necesitas servir a muchos usuarios

Cuándo elegirlo: estás montando un producto, quieres servir 50+ requests concurrentes, tienes GPUs NVIDIA decentes (A100, H100, RTX 4090), necesitas latencia consistente.

Setup mínimo:

# Instalar (requiere Python 3.9+ y CUDA)
pip install vllm
# Levantar servidor
python -m vllm.entrypoints.openai.api_server 
  --model meta-llama/Llama-3.1-8B-Instruct 
  --host 0.0.0.0 --port 8000 
  --gpu-memory-utilization 0.9
# API OpenAI-compatible idéntica
curl http://localhost:8000/v1/chat/completions 
  -H "Content-Type: application/json" 
  -d '{"model":"meta-llama/Llama-3.1-8B-Instruct","messages":[{"role":"user","content":"Hola"}]}'

Pros:

• Throughput enorme: PagedAttention permite batch de cientos de requests con poco overhead.
• Compatible 100% con OpenAI API (clientes existentes funcionan sin cambios).
• Continuous batching (agrega requests al vuelo, no espera a que termine el lote).
• Soporta modelos HF directamente, sin cuantización manual.
• Speculative decoding para velocidad extra.

Contras:

• NVIDIA-only oficialmente (ROCm tiene soporte parcial pero no oficial).
• Más RAM VRAM mínima (8 GB mínimo, recomendado 24+).
• Configuración más compleja que Ollama.
• Para 1 usuario chateando es overkill.

Guía de decisión (rápida)

Si quieres chatear con IA local sin configurar nada → LM Studio

Si eres developer quieres una API local para tu código → Ollama

Si quieres máximo rendimiento o hardware raro → llama.cpp

Si vas a servir a muchos usuarios / producción → vLLM

Si tienes GPU AMD → Ollama o LM Studio (soporte ROCm/Vulkan más pulido)

Si tienes Apple Silicon (M1/M2/M3/M4) → Ollama o LM Studio (Metal funciona perfecto)

Si tienes Raspberry Pi 5 u otro SBC → Ollama (más fácil de instalar en ARM, modelos chicos funcionan)

Lo que nadie te dice sobre los modelos

• Los modelos 7B rinden sorprendentemente bien para chat general, resúmenes, código boilerplate. No subestimes.
• Los modelos 70B+ necesitan GPU seria (24+ GB VRAM) y no son 10x mejores que un 13B bien afinado.
• Quantización q4_K_M es el sweet spot para uso general. q8 casi dobla memoria con ganancia de calidad marginal. q2/q3 son para emergencias de memoria.
• Modelos de código (CodeLlama, DeepSeek-Coder, Qwen-Coder) son MUY superiores a modelos generales para tareas de programación. Si solo vas a usar IA para código, andá directo a uno especializado.
• El “mejor” modelo cambia cada 2 meses. Lo que era top en abril ya no lo es en agosto. Seguí leaderboards tipo LMSYS Chatbot Arena.
• Fine-tuning de modelos propios es viable con QLoRA y 16 GB VRAM, pero es un rabbit hole serio. Empezá con modelos base.

Casos de uso reales (sin humo)

Caso 1: developer que quiere asistente de código en su editor. Ollama + Continue.dev en VS Code o Zed. Modelo: qwen2.5-coder:7b o deepseek-coder-v2:16b. Latencia ~50ms, calidad decente.

Caso 2: empresa pequeña que quiere un chat interno con documentos (RAG). Ollama + Open WebUI + vector store (Chroma o Qdrant). Privacidad total, datos no salen.

Caso 3: investigador que prueba modelos nuevos en hardware limitado. llama.cpp directo. Quantización custom, builds optimizados, máxima visibilidad.

Caso 4: servicio que ofrece completado de texto como SaaS. vLLM sobre H100, multi-GPU, alta concurrencia. Latencia p99 < 200ms con throughput de 5000 tokens/s.

Caso 5: hobbyista en MacBook Air M2. LM Studio o Ollama. Modelo 7B cuantizado. ~25 t/s. Más que suficiente.

Preguntas frecuentes

Lee también

• Guía Fedora 44: Novedades, Instalación y Upgrade para Sysadmins Linux
• Configura VLANs en Linux con nmcli: Guía paso a paso para sysadmins
• Protege tu SSH: Guía esencial para configurar Fail2ban en Linux
• Guía Definitiva: Configura Kubernetes con kubeadm en Ubuntu para Sysadmins Linux
• Configura Prometheus y Grafana: Guía DevOps para SysAdmins Linux