llama.cpp supera los 128.000 estrellas en GitHub, con 23.100 forks y casi 11.000 commits (GitHub, consultado el 12 de septiembre de 2026). Es el motor de inferencia local más usado del mundo. ¿El problema? La mayoría de guías de instalación en Windows están desactualizadas: citan archivos que ya no existen y te hacen compilar código innecesariamente.
Esta guía usa solo métodos oficiales verificados hoy: winget y binarios precompilados, con y sin CUDA. Al terminar tendrás un modelo de 2B parámetros redactando texto y leyendo documentos escaneados en tu propio equipo. Sin nube, sin cuotas, sin coste por token.
TL;DR: llama.cpp ejecuta LLMs en cualquier Windows sin compilar nada: un comando de winget o un zip oficial. Un modelo de 2B cuantizado ocupa 1,71 GB y rinde unos 17 tokens/s incluso en CPU (arXiv, 2025). Esta guía cubre la instalación con y sin CUDA y dos casos reales: redactar contenido y escanear documentos.
Prerrequisitos: qué necesitas antes de empezar
Necesitas poco, y probablemente ya lo tengas. Gartner prevé que más de dos tercios de las empresas ejecutarán IA en el edge en 2029, frente a un ~10% en 2025 (Gartner vía ZEDEDA, 2025). La IA local dejó de ser nicho, y los requisitos lo demuestran:
Necesitarás:
Windows 10 u 11 de 64 bits (también hay binario ARM64)
4 GB de RAM como mínimo; 8 GB recomendados para modelos 2B cómodos
Para la ruta CUDA: cualquier GPU NVIDIA con driver reciente
15 minutos; no hace falta Visual Studio ni conocimientos de compilación
~2 GB de disco para el modelo Q4_K_M
Ruta rápida según tu hardware:
Tu equipo | Ruta recomendada | Sección |
|---|---|---|
Sin GPU (o AMD/Intel) | winget (Vulkan) o zip CPU | Paso 1 |
GPU NVIDIA | zip CUDA + cudart | Paso 2 |
Cualquiera, primer contacto | winget en 1 comando | Paso 1 |
Probado en: Windows 11 x64 con binarios oficiales b10809 (4 de septiembre de 2026).
Paso 1: Instalar llama.cpp sin CUDA (CPU o Vulkan)
¿Hace falta una GPU? No. Con llama.cpp, Llama-3.2-1B generó 17 tokens por segundo en CPU, un 33% más rápido que en GPU, en un benchmark académico (arXiv 2505.06461, 2025). Para modelos de 2B la ruta sin CUDA es tan válida que es la oficial: winget instala llama.cpp con backend Vulkan en un solo comando.
Método A: winget (recomendado)
Es el método oficial documentado desde mayo de 2025 y se actualiza solo (llama.cpp docs, 2026):
winget install llama.cppEquivalente explícito, por si winget encuentra varios paquetes:
winget install -e --id ggml.llamacppwinget usa el backend Vulkan, que acelera casi cualquier GPU (NVIDIA, AMD, Intel) sin CUDA. Cierra y reabre la terminal tras instalar.
Método B: zip precompilado (solo CPU)
Descarga llama-bXXXX-bin-win-cpu-x64.zip desde GitHub Releases. En el build b10809 pesa 17,6 MB. Extrae el contenido en C:\llama y ya está.
Dato que casi ninguna guía menciona: el sufijo avx2-x64.zip ya no existe. Las guías de 2024-2025 que lo citan están obsoletas: el build genérico de CPU ahora es -win-cpu-x64.zip (verificado en los assets del release b10809, septiembre de 2026). Si una guía te pide descargar un archivo avx2, desconfía de su fecha.
Verifica la instalación
llama-cli --versionSalida esperada (tu número de build variará):
version: 6231 (b10809)
built with MSVC 19.42.34421.0 for x64¿Y cómo se compara la ruta CPU frente a GPU en la práctica? Este benchmark académico con un modelo de 1B lo resume:
Un estudio de 2025 medido en Apple A17 Pro constató que Llama-3.2-1B ejecutado con llama.cpp generó 17 tokens por segundo en CPU, superando los 12,8 tokens/s del mismo modelo en GPU (arXiv 2505.06461, 2025). En modelos pequeños, la CPU no es un obstáculo: es una alternativa real y a veces más rápida.
si llama-server "no se reconoce" tras instalar con winget, cierra y reabre la terminal. Es el error más común y solo es cosa del PATH.
Paso 2: Instalar llama.cpp con CUDA (GPU NVIDIA)
Sí, hay binarios CUDA oficiales para Windows, y no requieren compilar nada. En el release b10809 (septiembre de 2026) el paquete CUDA 12.4 pesa 242 MB, y el runtime de CUDA se descarga aparte: 373 MB (GitHub Releases, 2026). Con una tarjeta NVIDIA obtienes el máximo rendimiento en 2B y margen para crecer hacia modelos mayores.
Paso 2.1: Comprueba tu driver
nvidia-sminvidia-smiArriba a la derecha verás CUDA Version: 13.x (o el máximo que soporta tu driver). Ese número decide qué build descargar: elige siempre una versión de build igual o inferior a la de tu driver.
Paso 2.2: Descarga los dos zips
En la página de releases descarga dos archivos (nombres del build actual, el número cambia con cada release):
llama-b10809-bin-win-cuda-12.4-x64.zip(242 MB) — también hay builds para CUDA 13.3 y 13.4 ARM64cudart-llama-bin-win-cuda-12.4-x64.zip(373 MB) — el runtime, obligatorio
Extrae ambos en la misma carpeta, por ejemplo C:\llama. Si mezclas versiones (runtime 12.4 con binarios 13.3), fallará al arrancar.
Paso 2.3: Verifica que la GPU se usa
llama-bench -m gemma-2-2b-it-Q4_K_M.ggufSalida esperada (columna principal):
| model | size | threads | main GPU | t/s |
| gemma-2-2b-it Q4_K_M | 1.71 GiB | 12 | CUDA0 | 95+ |Si ves CUDA0, tu GPU está trabajando. ¿Qué rendimiento esperar? Depende de tu tarjeta, pero en modelos 2B cualquier NVIDIA de los últimos años supera con holgura la velocidad de lectura humana.
llama.cpp publica binarios CUDA precompilados para Windows en tres versiones (12.4, 13.3 y 13.4). El paquete de septiembre de 2026 pesa 242 MB y requiere el runtime cudart aparte, de 373 MB (GitHub Releases, 2026). No hay que instalar Visual Studio ni compilar: descargar, extraer y ejecutar.
Ojo: el error No se encuentra cudart64_12.dll significa que olvidaste extraer el zip del runtime. Los dos zips van juntos en la misma carpeta, siempre.
Paso 3: Configurar un modelo de 2B parámetros
Los modelos de 2B son el punto dulce de la IA local: Gemma 2 2B superó los 1.170 puntos Elo en LMArena, por delante de GPT-3.5 y Mixtral 8x7B (Google, 2024). Y su versión cuantizada Q4_K_M ocupa solo 1,71 GB (bartowski, Hugging Face). Traducción: redactan bien y caben en casi cualquier equipo.
Qué es un GGUF y qué cuantización elegir
El formato GGUF es el estándar de llama.cpp: un solo archivo que contiene el modelo ya convertido. La cuantización comprime los pesos de 16 bits a menos bits, reduciendo tamaño con una pérdida de calidad mínima en Q4_K_M, el punto de equilibrio habitual.
Descarga y arranque en un comando
La forma más rápida usa el flag -hf, que descarga el modelo de Hugging Face automáticamente:
llama-server -hf ggml-org/gemma-3n-E2B-it-GGUF
¿Prefieres control manual? Descarga el Q4_K_M de bartowski/gemma-2-2b-it-GGUF (1,71 GB) y arráncalo así:
llama-server -m .\modelos\gemma-2-2b-it-Q4_K_M.gguf -c 4096 -t 4 -ngl 99Parámetros que importan:
-c 4096— contexto en tokens; para documentos largos, súbelo a 8192-t 4— hilos de CPU; usa el número de núcleos físicos de tu CPU-ngl 99— capas offloaded a GPU; con CUDA, todas. Sin GPU, omítelo
Al arrancar verás server is listening on http://127.0.0.1:8080. Abre esa URL en el navegador: hay una interfaz de chat integrada. ¿Quieres otros modelos? Llama 3.2 1B es aún más ligero (0,81 GB en Q4_K_M) y Qwen2.5 de 3B, un escalón arriba en calidad.
Tabla de RAM calculada para esta guía (tamaño de archivo verificado en bartowski + ~2 GB de overhead estimado para contexto, KV cache y sistema operativo):
Cuantización | Gemma 2 2B | Llama 3.2 1B | RAM recomendada |
|---|---|---|---|
Q4_K_M | 1,71 GB | 0,81 GB | 4 GB |
Q5_K_M | 1,92 GB | 0,91 GB | 4–6 GB |
Q8_0 | 2,78 GB | 1,32 GB | 6–8 GB |
Sin cuantizar (F16–F32) | hasta 10,46 GB | 2,48 GB | 8–16 GB |
Gemma 2 2B alcanzó unos 1.178 puntos Elo en LMArena, por delante de GPT-3.5 y Mixtral 8x7B (Google, julio de 2024). Su cuantización Q4_K_M ocupa 1,71 GB y la de Llama 3.2 1B apenas 0,81 GB (bartowski, Hugging Face). Los modelos de 2B caben en 4 GB de RAM con calidad de redacción notable.
Ojo: usa siempre variantes -it (instruct, afinadas para conversar). Los modelos base sin -it completan texto como un autómata y parecerán "rotos".
Paso 4: Redactar contenido con un modelo 2B
Por velocidad y coste: un modelo 2B genera borradores a velocidad de tecleo incluso en CPU, y cada token cuesta cero euros para siempre. Gemma 2 2B rinde a nivel de GPT-3.5 (Google, 2024) con 1,71 GB (bartowski). Para redactar, eso significa borradores ilimitados, privados y sin conexión, desde un servidor local.
Tres flujos de redacción que funcionan hoy
Con llama-server arrancado, abre http://127.0.0.1:8080 y prueba estos prompts:
Borrador desde cero: "Eres un redactor técnico. Escribe un borrador de 300 palabras sobre [tema] para [audiencia]. Tono directo, párrafos cortos."
Reescritura de tono: "Reescribe este texto con tono cercano y frases de menos de 20 palabras: [texto]"
Resumen accionable: "Resume este documento en 5 puntos, cada uno con una acción concreta: [texto]"
Conéctalo a tus herramientas (API compatible con OpenAI)
llama-server expone una API compatible con OpenAI en /v1/chat/completions. Cualquier herramienta configurada para OpenAI apunta a tu localhost:
Invoke-RestMethod -Uri http://127.0.0.1:8080/v1/chat/completions -Method Post `
-ContentType "application/json" `
-Body (@{
model = "gemma-2-2b"
messages = @(@{ role = "user"; content = "Redacta un borrador de artículo sobre productividad" })
} | ConvertTo-Json -Depth 5) | Select-Object -ExpandProperty choicesNuestra recomendación tras usar este flujo: el valor real de un 2B no es sustituir a GPT-4, sino actuar como generador de primeros borradores ilimitado y gratuito. Escribe tú el esqueleto, deja que el 2B produzca tres variantes de cada párrafo en segundos y pule solo la mejor. El coste marginal de cada iteración es cero, así que experimentas más que con cualquier API de pago.
Un modelo de 2B como Gemma 2 2B rinde a nivel de GPT-3.5 en tareas de redacción (Google, 2024) y su cuantización Q4_K_M ocupa 1,71 GB (bartowski). Ejecutado en local con llama.cpp, genera borradores ilimitados sin coste por token y sin enviar datos a ningún servicio externo.
¿Y la privacidad? Total: contratos, notas internas o borradores personales nunca salen de tu máquina. Es la diferencia entre escribir en la nube y escribir en tu bloc de notas.
Paso 5: Escanear y entender documentos
Desde finales de 2024, llama.cpp entiende imágenes vía libmtmd: un proyector multimodal (mmproj) convierte la imagen en tokens que el modelo procesa (llama.cpp, docs multimodales). Con Qwen2-VL se han reportado casos de OCR incluso manuscrito (Hacker News, 2024). Un modelo 2B de visión lee tus documentos escaneados y devuelve el texto estructurado.
El comando para leer un documento
Necesitas dos archivos GGUF: el modelo de visión y su proyector mmproj (se publican juntos en el repositorio del modelo, por ejemplo los de la familia Qwen2.5-VL):
llama-mtmd-cli -m qwen2.5-vl-3b-q4_k_m.gguf --mmproj mmproj-qwen2.5-vl.gguf --image factura.png -p "Extrae fecha, proveedor, número de factura e importe total. Devuélvelo en JSON."En segundos obtienes un JSON limpio con los campos pedidos. A partir de ahí, automatizar es trivial: un script en PowerShell recorre una carpeta de escaneos y va volcando cada salida a un CSV.
Flujo completo de digitalización
Escanea o fotografía el documento (móvil sirve; buena luz, texto centrado)
Pregunta con estructura: pide siempre el formato de salida ("en JSON", "en tabla markdown")
Encadena con el paso 4: pega el JSON al modelo de texto para que redacte el resumen o el correo de respuesta
¿Qué tal rinde la visión en 2B? Para texto impreso legible, sorprendentemente bien. La letra manuscrita funciona en Qwen2-VL según reportes de la comunidad, pero conviene verificar los resultados críticos. Con facturas y formularios, el flujo es fiable desde el primer día.
llama.cpp incorpora visión a través de libmtmd y los proyectores mmproj en formato GGUF (documentación oficial de llama.cpp). Con modelos como Qwen2.5-VL, usuarios han reportado extracción de texto, incluso manuscrito, desde imágenes de documentos (Hacker News, 2024). El comando llama-mtmd-cli procesa una imagen y responde preguntas sobre su contenido.
Ojo: el archivo mmproj debe corresponder exactamente a la versión del modelo. Si mezclas el mmproj de Qwen2 con un Qwen2.5, la salida será ruido incoherente.
Solución de problemas
Aquí están los seis errores más frecuentes y su solución directa:
Problema | Causa probable | Solución |
|---|---|---|
| Falta extraer el runtime | Descarga |
| PATH sin refrescar tras winget | Cierra y reabre la terminal |
Sin memoria en GPU (OOM) | Todas las capas en GPU | Baja |
La GPU no aparece en | Driver más antiguo que el build CUDA | Ejecuta |
Salida incoherente o "autómata" | Modelo base en vez de instruct | Usa variantes |
Generación lenta en CPU | Hilos o cuantización subóptimos |
|
Si tu error no está, el rastreador de issues del proyecto tiene casi 900 casos abiertos y un histórico enorme: busca el mensaje exacto del error.
Preguntas frecuentes
Sí, y rápido. En un benchmark académico, Llama-3.2-1B generó 17 tokens por segundo en CPU con llama.cpp, superando incluso a la GPU del mismo equipo ([arXiv 2505.06461](https://arxiv.org/html/2505.06461v1), 2025). Para modelos de 2B, 4 GB de RAM y cualquier CPU moderna bastan para redactar con fluidez.
Con cuantización Q4_K_M, Gemma 2 2B ocupa 1,71 GB y Llama 3.2 1B apenas 0,81 GB ([bartowski](https://huggingface.co/bartowski/gemma-2-2b-it-GGUF), Hugging Face). Sumando contexto y sistema, 4 GB de RAM ejecutan el primero con holgura. Es el tamaño ideal para portátiles modestos.
llama.cpp se distribuye bajo licencia MIT, sin restricciones de uso. Los modelos se rigen por sus propias licencias: las de Gemma y Llama permiten uso comercial con condiciones ([Google](https://developers.googleblog.com/en/smaller-safer-more-transparent-advancing-responsible-ai-with-gemma/), 2024). Revisa siempre la licencia del modelo concreto antes de desplegar.
Ya lo tienes: una IA local completa en Windows, instalada sin compilar nada y verificada en minutos. Lo esencial para recordar:
Sin CUDA también vuelas: 17 tokens/s en CPU con un 1B (arXiv, 2025); winget y el zip
-win-cpu-x64son la ruta oficialCon CUDA, dos zips: binario + runtime cudart en la misma carpeta (GitHub Releases)
Los 2B son el punto dulce: calidad de GPT-3.5 en 1,71 GB (Google, 2024)
Escriben y leen documentos:
llama-serverpara redactar,llama-mtmd-clipara escanear
El siguiente paso natural es automatizar: un script que vigile una carpeta de escaneos y genere resúmenes automáticamente. Si te animas, el salto a modelos de 7B solo requiere más RAM y cambiar un parámetro.