En pocas palabras: llama.cpp v0.1.2 es un pre-release de mantenimiento del motor de inferencia local en C/C++ creado por Georgi Gerganov. Actualiza la librería ggml a 0.20.2, suma una optimización CUDA para modelos densos en la NVIDIA DGX Spark y agrega hashing SHA256 en entradas multimodales. No rompe compatibilidad.
La versión llama.cpp v0.1.2 es un pre-release de mantenimiento del motor de inferencia local de código abierto: sube la librería base ggml a la 0.20.2, mete una optimización CUDA puntual para procesamiento denso en la NVIDIA DGX Spark y ajusta el manejo multimodal con hashing SHA256. Nada rompe compatibilidad; es un afinado incremental sobre la v0.1.1.
llama.cpp es una herramienta de código abierto escrita en C/C++, creada por Georgi Gerganov en 2023, que corre modelos de lenguaje (LLM) directo en tu máquina, sin API en la nube. Usa el formato de modelos GGUF y la librería de tensores ggml. Es el motor que está debajo de herramientas más conocidas como Ollama y LM Studio. La v0.1.2 es una de sus builds de la nueva numeración semántica.
En 30 segundos
- Qué es: el motor de inferencia local más usado, base de Ollama y LM Studio, escrito en C/C++.
- Qué trae la v0.1.2: ggml 0.20.2, optimización CUDA para modelos densos en DGX Spark, hashing SHA256 en entradas multimodales y soporte de scores de tokenizer en enteros.
- Estabilidad: es un pre-release. El propio proyecto dice que el versionado semántico “todavía está en progreso”.
- Requisitos: corre en CPU sin GPU; un modelo de 7B cuantizado a 4-bit pesa cerca de 4 GB y se mueve con 8-16 GB de RAM.
- Para producción crítica: mejor esperar y testear. Para aprender y prototipar, va perfecto.
¿Qué es llama.cpp y por qué correr IA en tu propia máquina?
llama.cpp es un proyecto de código abierto que ejecuta modelos de lenguaje en hardware común (tu notebook, un servidor, hasta una Raspberry Pi) sin depender de ninguna nube. Georgi Gerganov lo publicó en 2023 y hoy es el motor de facto para inferencia local. Ollama y LM Studio son, en el fondo, envoltorios más amigables sobre este mismo núcleo.
¿Por qué te importaría correrlo local en vez de pegarle a una API? Privacidad, primero. Tus datos no salen de la máquina. Ponele que trabajás con historias clínicas, contratos o el código propietario de tu empresa: mandar todo eso a un endpoint externo es un dolor de cabeza legal que con inferencia local directamente no existe. En ejecutar IA local con Ollama profundizamos sobre esto.
Después está el costo. Una vez que bajaste el modelo, no pagás por token ni por request. Y el control: elegís el modelo, la cuantización, el largo de contexto, todo. Eso sí, la contra es obvia. Corrés con tu propio fierro, así que la velocidad y el techo de calidad dependen de lo que tengas abajo del teclado.
¿Qué cambios trae llama.cpp v0.1.2?
La llama.cpp v0.1.2 es una actualización de mantenimiento sobre la v0.1.1, sin cambios que rompan compatibilidad. Según el changelog oficial del release, lo central es el salto de la librería ggml a la versión 0.20.2 y varios ajustes finos en CUDA, multimodal y tokenización. Es un pre-release publicado como nightly build.
Lo más concreto del listado:
- ggml 0.20.2: la librería de tensores que hace el trabajo pesado subió de versión, lo que arrastra mejoras y fixes por debajo de todo lo demás.
- Optimización CUDA para modelos densos: ajustaron el kernel MMVQ (nwarps=8 para batch size 1) apuntando a la NVIDIA DGX Spark. Es una mejora puntual, no un salto de rendimiento general.
- SHA256 en entradas multimodales: el módulo mtmd (texto + imágenes) ahora usa SHA256 para hashear las entradas, un cambio de robustez.
- Scores de tokenizer en enteros: el vocabulario ahora soporta puntuaciones de tokenizer como enteros, ampliando qué modelos se pueden cargar bien.
- Refactor de las Built-In Tools: renombraron las herramientas integradas del servidor (Server/Browser) y ordenaron alfabéticamente los enums de la UI.
- Documentación de MCP: sumaron docs sobre servidores MCP por stdio y los defaults de CORS en el README del servidor.
Traducido: si venías bien con la v0.1.1, esta actualización no te obliga a nada. Y si estás en NVIDIA con modelos densos, quizás notes una diferencia. El resto son mejoras de plomería (importantes, pero invisibles para el uso diario).
¿Cuánta RAM, GPU y disco necesito para correrlo?
llama.cpp funciona sin GPU: puede correr solo en CPU, más lento pero funciona. La variable que manda es la RAM, y depende del tamaño del modelo y de la cuantización. Regla práctica: un modelo cuantizado a 4-bit necesita, en RAM o VRAM, más o menos su peso en disco. Un 7B a 4-bit pesa cerca de 4 GB; un 70B se va arriba de los 40 GB.
| Escenario | Modelo típico | RAM orientativa | Disco aprox. |
|---|---|---|---|
| Mínimo (aprender) | Modelo 1-3B (tipo TinyLlama) 4-bit | 4-8 GB | 1-2 GB |
| Estándar (uso diario) | Modelo 7B 4-bit | 8-16 GB | ~4 GB |
| Cómodo | Modelo 13B 4-bit | 16 GB o más | ~8 GB |
| Óptimo (GPU) | NVIDIA con CUDA, o Apple Silicon con Metal | Según VRAM | Según modelo |
Los números son orientativos, no una garantía de fábrica. Influyen el largo de contexto que uses, si descargás capas a la GPU y el nivel de cuantización. Con una GPU NVIDIA (CUDA) o una Mac con Apple Silicon (aceleración Metal), la misma tarea vuela comparada con CPU pura. Tema relacionado: Hermes Desktop gratis para agentes locales.
¿Cómo instalo llama.cpp en Windows, Linux y macOS?
Se instala de tres formas: bajando un binario precompilado, compilando desde el repositorio con CMake, o usando el binding llama-cpp-python si trabajás en Python. La guía de instalación oficial está en el repositorio de ggml-org. Cada sistema operativo tiene su camino más corto.
En Windows
Lo más rápido es bajar el binario precompilado desde la sección de releases de GitHub. Si querés soporte CUDA para tu GPU NVIDIA, ahí conviene compilar con CMake y las herramientas de build de Visual Studio. No es difícil, pero la primera vez lleva su rato configurando dependencias.
En Linux
El camino clásico es clonar el repo y compilar con CMake, activando el soporte que necesites: CUDA para NVIDIA, ROCm/HIP para AMD. Ojo con esto: la v0.1.2 trae un ajuste específico para builds HIP (saltea el override de UMA), así que si estás en AMD, actualizar tiene sentido.
En macOS
Acá es donde más cómodo se siente. En Apple Silicon compilás con aceleración Metal nativa y el rendimiento por watt es excelente. Muchos usuarios de Mac corren modelos de 7B y 13B sin despeinar la máquina.
Si preferís Python, llama-cpp-python te da los mismos motores con una API pythonica, ideal para meterlo en un script o un backend propio.
¿Qué modelos son compatibles con llama.cpp?
Solo funcionan modelos en formato GGUF. Es el formato nativo del proyecto (reemplazó al viejo GGML) y en Hugging Face hay miles listos para bajar. Familias populares que corren sin problema: Llama, Mistral, Phi, Qwen, TinyLlama, OpenChat, entre otras.
Acá aparece la cuantización, que es la palanca clave. Un mismo modelo viene en varias versiones: 4-bit, 5-bit, 8-bit. Cuanto más agresiva la cuantización (menos bits), menos pesa y más rápido corre, pero perdés un poco de precisión. El 4-bit es el punto dulce para la mayoría: entra en máquinas modestas y la calidad aguanta bien. Más contexto en reducir costos en APIs LLM.
Si un modelo viene en el formato original de Hugging Face y no en GGUF, tenés que convertirlo primero con los scripts del propio repositorio. La v0.1.2 sumó soporte para scores de tokenizer en enteros, lo que ayuda a que ciertos modelos carguen mejor.
¿Llama.cpp, Ollama o LM Studio? Cuál te conviene
Depende de qué tan bajo nivel quieras ir. llama.cpp es el motor crudo: máximo control y flexibilidad, pero más laburo de configuración. Ollama es un envoltorio por línea de comandos que simplifica todo. LM Studio te da una interfaz gráfica visual para no tocar la terminal. Los tres, abajo, usan el mismo núcleo.
| Criterio | llama.cpp | Ollama | LM Studio |
|---|---|---|---|
| Interfaz | CLI / servidor | CLI simple | App gráfica |
| Curva de aprendizaje | Alta | Baja | Muy baja |
| Control fino | Máximo | Medio | Bajo-medio |
| Ideal para | Devs, deployment a medida | Prototipar rápido | Probar sin código |
| Motor de fondo | Es el motor | llama.cpp | llama.cpp |
¿Cuál elegir? Si querés armar tu primer chatbot en cinco minutos, Ollama o LM Studio. Si vas a meter inferencia dentro de un producto, controlar cada flag y exprimir el hardware, llama.cpp directo. La comparación completa la desarrolla bien esta guía de OpenXcell.
¿Es la v0.1.2 estable para producción?
Con matices. La v0.1.2 es un pre-release, y el propio proyecto aclara en el release que el versionado semántico “todavía está en progreso”. Se publica como nightly build. Para aprender, prototipar o correr un asistente personal, va bárbaro. Para producción crítica, la recomendación honesta es fijar una versión, testearla a fondo y no actualizar a ciegas.
Qué está confirmado
- El contenido del changelog: ggml 0.20.2, optimización CUDA MMVQ para DGX Spark, SHA256 en mtmd, scores de tokenizer en enteros, refactor de Built-In Tools y docs de MCP stdio + CORS.
- Sin cambios que rompan compatibilidad: es un incremental sobre la v0.1.1.
- Es un pre-release/nightly: lo dice el propio release en GitHub.
Qué no está confirmado
- Una fecha de release estable: el esquema de versiones sigue en definición, sin un calendario fijo publicado.
- Benchmarks de velocidad independientes: el changelog no trae cifras de rendimiento verificadas por terceros para esta build puntual.
- Si esta numeración es la definitiva: el propio proyecto la marca como trabajo en progreso.
Errores comunes al arrancar con llama.cpp
- Bajar un modelo que no es GGUF: te descargás el modelo original de Hugging Face, intentás cargarlo y no arranca. llama.cpp solo come GGUF. Convertilo con los scripts del repo o buscá la versión GGUF ya subida.
- Pedir un modelo más grande que tu RAM: tirás un 13B en una máquina de 8 GB y el sistema se arrastra o directamente crashea. Mirá el peso del archivo antes: si no entra en memoria, bajá de tamaño o de cuantización.
- Compilar sin el soporte de tu GPU: compilás sin activar CUDA o Metal, corrés en CPU sin darte cuenta y te quejás de que “va lento”. Revisá los flags de compilación y confirmá que el binario detecta tu placa.
- Actualizar en producción sin testear: tratás un pre-release como si fuera estable, actualizás el motor un viernes a la tarde y el lunes algo no responde igual. Fijá versiones y probá en un entorno aparte antes.
Preguntas Frecuentes
¿Qué es llama.cpp y para qué sirve?
llama.cpp es una herramienta de código abierto en C/C++ que corre modelos de lenguaje (LLM) directo en tu computadora, sin nube. Sirve para armar chatbots privados, asistentes locales y backends de inferencia donde los datos nunca salen de tu máquina. La creó Georgi Gerganov en 2023. Lo explicamos a fondo en seguridad con Microsoft Intune.
¿Qué cambios trae la versión 0.1.2?
La v0.1.2 sube la librería ggml a 0.20.2, optimiza el kernel CUDA MMVQ para modelos densos en la NVIDIA DGX Spark, agrega hashing SHA256 en entradas multimodales y soporta scores de tokenizer en enteros. Es un pre-release de mantenimiento, sin cambios que rompan compatibilidad con la v0.1.1.
¿Llama.cpp es lo mismo que Ollama?
No. Ollama es un envoltorio más amigable que usa a llama.cpp como motor por debajo. llama.cpp es el núcleo de bajo nivel, con máximo control y más configuración; Ollama simplifica el uso con comandos cortos. LM Studio hace lo mismo pero con interfaz gráfica.
¿Necesito una GPU para usar llama.cpp?
No es obligatoria. llama.cpp corre solo en CPU, más lento pero funcional. Con una GPU NVIDIA (CUDA), AMD (ROCm) o una Mac con Apple Silicon (Metal), la velocidad mejora mucho. Un modelo 7B cuantizado a 4-bit se mueve con 8-16 GB de RAM.
¿La v0.1.2 sirve para producción?
Es un pre-release, así que para producción crítica conviene fijar la versión y testearla antes. El propio proyecto marca el versionado semántico como trabajo en progreso. Para aprender, prototipar o correr asistentes personales, es una opción sólida.
Conclusión
La llama.cpp v0.1.2 no es un salto que te obligue a soltar todo y actualizar. Es un afinado de mantenimiento: ggml 0.20.2 abajo, una optimización CUDA puntual para modelos densos en DGX Spark, más robustez en multimodal y tokenización. Si estás en AMD con builds HIP o en NVIDIA con modelos densos, hay razones concretas para dar el salto. Si venías bien con la v0.1.1, no hay urgencia.
Lo que sí conviene tener claro es el terreno: llama.cpp sigue siendo la base sobre la que se paran Ollama, LM Studio y buena parte del ecosistema de IA local. Elegí la herramienta según tu perfil (motor crudo para control total, envoltorio para arrancar rápido) y, si vas a montar un servidor de inferencia propio con un VPS o cloud, en donweb.com conseguís infraestructura en Argentina para hacerlo. Bajá un modelo GGUF de 7B, probalo en local y decidí con datos, no con hype.
