GGUF on KnightLi Blog

Actualización llama.cpp b9196: los binarios precompilados para Windows soportan CUDA 13.1, Vulkan, HIP y SYCL

Mon, 18 May 2026 23:20:00 +0800

La versión reciente de llama.cpp para Windows es más amigable para usuarios de LLM locales. Antes, ejecutar modelos GGUF en Windows solía atascarse por problemas de entorno: versiones de CUDA incompatibles, DLL faltantes, drivers no compatibles, fallos de compilación con CMake, variables de entorno incorrectas o configuración complicada de Vulkan / HIP / SYCL.

Ahora la página oficial de Release ofrece varios paquetes precompilados para Windows. En muchos casos ya no hace falta compilar desde código fuente. Descargas la versión correcta, la descomprimes, colocas el archivo del modelo y puedes arrancar directamente un servicio local de inferencia.

Para qué sirve llama.cpp

llama.cpp es uno de los frameworks más usados para inferencia local con modelos GGUF. Es ligero, multiplataforma, puede usar CPU o GPU, y alrededor de GGUF ya existe un ecosistema amplio de modelos.

Familias de modelos comunes:

Qwen
Llama
DeepSeek
Gemma
Mistral
Mixtral
Hermes

A medida que los modelos cuantizados en GGUF se popularizan, muchos modelos open source publican versiones GGUF aptas para despliegue local. Para usuarios normales, el valor de llama.cpp está en que no necesitas montar un stack de inferencia complejo para correr un servicio de chat usable en tu propia máquina.

Cómo elegir una versión precompilada para Windows

Los usuarios de Windows pueden elegir distintos builds según su hardware:

Windows x64 CPU
Windows x64 CUDA 12.4
Windows x64 CUDA 13.1
Windows x64 Vulkan
Windows x64 HIP Radeon
Windows x64 SYCL
Windows ARM64 CPU

Si usas una GPU NVIDIA, normalmente conviene priorizar la versión CUDA. Tarjetas como RTX 3060, 4060, 4070, 4080 y 4090 encajan mejor con la ruta CUDA.

Si usas una GPU AMD, puedes probar HIP o Vulkan. En la práctica, Vulkan a veces resulta más sencillo que HIP, sobre todo si no quieres montar un entorno ROCm completo.

Si usas gráficos integrados Intel o una GPU Arc, puedes probar SYCL o Vulkan. El rendimiento suele quedar por detrás de NVIDIA CUDA, pero ya basta para probar muchos modelos GGUF pequeños y medianos.

La versión CPU sirve para usuarios sin GPU dedicada o para quienes solo quieren verificar un modelo o correr modelos pequeños. No será rápida, pero es la ruta más simple.

Arrancar un modelo GGUF normal

Supongamos que ya descargaste el paquete precompilado de llama.cpp para Windows y colocaste el modelo en el directorio models. Entra en la carpeta descomprimida de llama.cpp y ejecuta:

`1`	`llama-server.exe -m models\your-model.gguf -ngl 999`

Aquí -m apunta al archivo GGUF, y -ngl 999 intenta cargar la mayor cantidad posible de capas en la GPU. Cuántas se cargan realmente depende de la VRAM, el tamaño del modelo y el formato de cuantización.

Cuando arranque correctamente, abre en el navegador:

`1`	`http://127.0.0.1:8080`

Entrarás en la interfaz web local de chat.

Si la VRAM no alcanza, cambia a un modelo más pequeño o a una cuantización más baja, como archivos GGUF Q4 o Q5. No mires solo el número de parámetros; revisa también el formato de cuantización y la longitud de contexto.

Arrancar un modelo visual multimodal

Los modelos visuales multimodales normalmente necesitan algo más que el archivo principal. También necesitan un archivo de proyección visual mmproj. Al arrancar, especifica ambos:

`1`	`llama-server.exe -m "models\main-model.gguf" --mmproj "models\mmproj-model.gguf" -ngl 999`

Usos comunes:

Reconocimiento OCR
Comprensión de capturas de pantalla
Análisis de capturas de páginas web
Preguntas y respuestas sobre imágenes
Juicio simple de contenido visual

Por ejemplo, modelos como Qwen2-VL / Qwen2.5-VL son útiles para entender capturas en chino, OCR y preguntas sobre imágenes. Asegúrate de que el modelo principal y el archivo mmproj correspondan entre sí; una versión no compatible puede causar fallos de carga o resultados extraños.

Gestionar varios modelos con un script bat

Si tienes varios modelos locales, puedes escribir un .bat sencillo para alternarlos con un menú. Este ejemplo requiere cambiar ruta y nombres de modelos por los tuyos:

@echo off
chcp 65001 >nul
cd /d C:\path\to\llama-b9196-bin-win-cuda-13.1-x64

echo 请选择模型：
echo 1. Gemma
echo 2. Qwen VL 多模态
echo 3. DeepSeek

set /p choice=输入数字：

if "%choice%"=="1" llama-server.exe -m "models\gemma.gguf" -ngl 999
if "%choice%"=="2" llama-server.exe -m "models\qwen-vl.gguf" --mmproj "models\mmproj.gguf" -ngl 999
if "%choice%"=="3" llama-server.exe -m "models\deepseek.gguf" -ngl 999

pause

Guárdalo en UTF-8 y luego cambia la extensión a .bat. Al hacer doble clic, podrás elegir distintos modelos por número.

Tres cosas que mirar al elegir modelos

Primero, el hardware. Cuanta más VRAM tengas, modelos más grandes podrás correr. Si la VRAM es limitada, no fuerces un modelo grande; empieza con 7B, 8B o una cuantización más baja.

Segundo, el uso. Para preguntas diarias, resúmenes y reescritura, un modelo pequeño o una cuantización media suele bastar. Para código, análisis de documentos largos o comprensión multimodal, necesitas modelos más fuertes y más VRAM.

Tercero, licencias y límites de seguridad. En internet hay muchos modelos modificados por la comunidad, con capacidades, restricciones y licencias distintas. Antes de descargar, confirma origen, licencia, escenario de uso y riesgos. No conviene entregar tareas de producción directamente a modelos de origen poco claro.

Problemas comunes

Si al arrancar aparece un error de DLL faltante, primero confirma que el paquete descargado corresponde a tu ruta de GPU. Los usuarios de NVIDIA no deberían descargar por error la versión HIP, y los usuarios de AMD no deberían descargar la versión CUDA.

Si el modelo carga muy lento, puede ser demasiado grande, el disco puede ser lento, o parte de las capas puede estar cayendo a CPU por falta de VRAM.

Si la página web no abre, revisa primero si el servicio arrancó correctamente en la consola y confirma que el puerto sea 8080. Si el puerto está ocupado, consulta los parámetros de llama-server para cambiarlo.

Si un modelo multimodal da resultados raros, revisa primero si el archivo mmproj corresponde al modelo principal, antes de limitarte a cambiar prompts.

Resumen

El valor de estos paquetes precompilados para Windows está en bajar la barrera de entrada a la IA local. Antes muchos usuarios se quedaban atrapados en compilación y dependencias; ahora pueden llegar más rápido a descargar modelos, arrancar un servicio y probar resultados.

Para usuarios de Windows, la ruta puede resumirse así:

NVIDIA: prioriza CUDA.
AMD: prueba primero Vulkan, luego HIP.
Intel: prueba SYCL o Vulkan.
Sin GPU dedicada: usa la versión CPU para modelos pequeños.

Antes de usarlo en serio, confirma origen del modelo, licencia, requisitos de VRAM y resultados reales. La IA local ofrece control, uso offline y baja latencia, pero no significa coste cero: gestión de modelos, recursos de hardware y calidad de salida siguen siendo responsabilidad tuya.

Fuente: https://www.freedidi.com/24211.html

Modelos LLM locales recomendados para una GPU RTX 3060

Fri, 08 May 2026 09:25:24 +0800

La versión más común de la RTX 3060 tiene 12GB de VRAM. No es una GPU de IA de gama alta, pero funciona muy bien para LLM locales, especialmente modelos de 7B, 8B, 9B y 12B.

Si solo quieres una regla rápida:

En una RTX 3060 12GB, prioriza modelos de alrededor de 8B en cuantización Q4_K_M o Q5_K_M. Elige Q4 para más estabilidad y prueba Q5 si quieres mejor calidad.

No empieces persiguiendo modelos de 32B o 70B. Aunque puedan ejecutarse con cuantización muy baja y CPU offload, la velocidad y la experiencia normalmente no son adecuadas para uso diario.

Primero mira el límite de VRAM

Al ejecutar LLM locales en una RTX 3060 12GB, el límite real es la VRAM.

Tamaño del modelo	Cuantización recomendada	Experiencia en RTX 3060 12GB
3B / 4B	Q4, Q5, Q8	Muy fácil, rápido
7B / 8B / 9B	Q4_K_M, Q5_K_M	Lo más recomendado; buen equilibrio
12B / 14B	Q4_K_M	Se puede probar, cuidado con contexto grande
30B+	Q2 / Q3 o offload parcial	Se puede experimentar, no diario
70B+	Cuantización extrema o mucha CPU/RAM	Más bien experimental

Un LLM local no solo consume VRAM por el archivo del modelo. También consumen contexto, KV cache, batch size, framework de inferencia y drivers.

Por eso 12GB de VRAM no significa cargar sin más un archivo de modelo de 12GB. Es mejor dejar margen para el sistema y el contexto.

Recomendación 1: Qwen3 8B

Si usas principalmente chino, Qwen3 8B es uno de los primeros modelos que vale la pena probar en una RTX 3060.

Sirve para:

Preguntas y respuestas en chino.
Resumen y reescritura.
Asistente diario de conocimiento.
Explicación simple de código.
RAG local.
Flujos Agent ligeros.

Elección recomendada:

1
2
3

Qwen3 8B GGUF
Q4_K_M: primera opción
Q5_K_M: mejor calidad, más presión de VRAM

La familia Qwen suele funcionar bien con chino. Para escritura diaria, organización de información y comprensión de instrucciones en chino, Qwen3 8B es un buen punto de partida.

Recomendación 2: Llama 3.1 8B Instruct

Llama 3.1 8B Instruct es un modelo general estable, con buena capacidad en inglés y ecosistema maduro.

Sirve para:

Preguntas en inglés.
Ayuda ligera con código.
Chat general.
Resumen de documentos.
Pruebas de prompts.
Comparar herramientas de inferencia.

Elección recomendada:

1
2
3

Llama 3.1 8B Instruct GGUF
Q4_K_M: mejor velocidad y estabilidad de VRAM
Q5_K_M: mejor calidad de respuesta

Si procesas sobre todo material en inglés, o quieres un modelo con muchos tutoriales y buena compatibilidad, Llama 3.1 8B sigue siendo una buena base.

Recomendación 3: Gemma 3 12B

Gemma 3 12B está más cerca del límite práctico de una RTX 3060 12GB.

Consume más VRAM que los modelos 8B, pero con cuantización Q4 todavía puede funcionar en una tarjeta de 12GB. Es una opción para quien quiera probar un modelo algo mayor en una sola GPU.

Sirve para:

Preguntas generales de mayor calidad.
Procesamiento de contenido en inglés.
Resúmenes y análisis algo más complejos.
Probar una mejora sobre modelos 8B.

Elección recomendada:

1
2
3

Gemma 3 12B GGUF
Q4_K_M u oficial QAT Q4
No abras demasiado el contexto

Si falta VRAM, reduce primero la longitud de contexto o vuelve a un modelo 8B. Para una 3060, 12B es “probable”, no una recomendación automática.

Recomendación 4: DeepSeek R1 Distill Qwen 8B

Si quieres probar modelos locales con estilo de razonamiento, puedes usar modelos como DeepSeek R1 Distill Qwen 8B.

Sirve para:

Problemas simples de razonamiento.
Análisis por pasos.
Aprender el estilo de salida de modelos de razonamiento.
Experimentos locales de bajo costo.

Elección recomendada:

1
2

DeepSeek R1 Distill Qwen 8B GGUF
Q4_K_M

Estos modelos a veces generan procesos de razonamiento más largos, así que la velocidad y el uso de contexto pueden sentirse más pesados que en modelos instruct normales. Para chat diario no siempre son más cómodos que Qwen3 8B, pero sirven bien para experimentar.

Recomendación 5: Phi / MiniCPM / modelos pequeños

Si tu 3060 es de 8GB, o tu RAM también es limitada, considera primero modelos de 3B o 4B.

Sirven para:

Preguntas rápidas.
Resúmenes simples.
Integración en pequeñas herramientas locales.
Chat de baja latencia.
Pruebas en equipos antiguos.

No siempre igualan la calidad de 8B o 12B, pero son ligeros, rápidos y fáciles de desplegar.

Cómo elegir cuantización

El formato local común es GGUF, con cuantizaciones como Q4, Q5, Q6 y Q8.

Cuantización	Características	Mejor para
Q4_K_M	Pequeña, rápida, calidad suficiente	Primera opción en 3060
Q5_K_M	Mejor calidad, más consumo	Probar con modelos 8B
Q6 / Q8	Más cerca de calidad original, más grande	Modelos pequeños o más VRAM
Q2 / Q3	Ahorra VRAM, baja calidad notable	Experimentar con modelos grandes

Para RTX 3060 12GB, lo más práctico es:

1
2
3

Modelos 8B: Q4_K_M o Q5_K_M
Modelos 12B: primero Q4_K_M
Modelos mayores: no recomendados como uso diario

Qué herramienta usar

Los principiantes pueden empezar con Ollama, porque instalar y ejecutar modelos es sencillo.

Comandos comunes:

1
2

ollama run qwen3:8b
ollama run llama3.1:8b

Si quieres controlar mejor archivos GGUF, GPU layers y longitud de contexto, usa llama.cpp o herramientas gráficas basadas en llama.cpp.

Opciones comunes:

Ollama: lo más simple, ideal para empezar.
LM Studio: interfaz gráfica amigable, útil para descargar y cambiar modelos.
llama.cpp: control más fino, bueno para ajustar rendimiento.
text-generation-webui: muchas funciones, útil para probar backends.

Para chat local y preguntas simples, Ollama o LM Studio bastan.

No abras demasiado el contexto

Muchos modelos anuncian soporte de contexto largo, pero en una RTX 3060 no conviene usar siempre el máximo.

Cuanto más largo el contexto, más KV cache se usa y mayor presión de VRAM. Incluso si el modelo carga, un contexto largo puede reducir la velocidad.

Sugerencia:

1
2
3

Chat normal: 4K a 8K
Resumen de documentos: 8K a 16K
RAG de documentos largos: divide primero; no pegues todo de una vez

La 3060 funciona mejor con “contexto medio + buen modelo + buena recuperación” que intentando meter cientos de miles de tokens.

Elegir según uso

Si escribes principalmente en chino:

1
2

Primero: Qwen3 8B Q4_K_M
Alternativa: DeepSeek R1 Distill Qwen 8B

Si escribes principalmente en inglés:

1
2

Primero: Llama 3.1 8B Instruct Q4_K_M
Alternativa: Gemma 3 12B Q4_K_M

Si quieres velocidad:

1
2
3

Modelos 3B / 4B
8B Q4_K_M
Contexto entre 4K y 8K

Si quieres más calidad:

1
2
3

8B Q5_K_M
12B Q4_K_M
Acepta menor velocidad

Si quieres ayuda con código:

1
2

Modelos de código 8B sirven para explicar y pequeños cambios
Para ingeniería compleja, usa modelos cloud más fuertes

Los modelos locales en 3060 son útiles para explicar código, completar funciones, generar scripts pequeños y ayudar sin conexión. Para grandes refactors, bugs complejos y tareas Agent entre archivos, no esperes rendimiento al nivel de Claude Sonnet o GPT-5.

Expectativas razonables

La RTX 3060 12GB puede convertir los LLM locales de “juguete” en herramienta diaria, pero no replica modelos cloud de primera línea en casa.

Ventajas:

Bajo costo.
Más VRAM que tarjetas de 8GB.
Buena experiencia con modelos 8B.
Uso offline.
Procesamiento local de datos sensibles.

Límites:

Modelos grandes no van fluidos.
Contexto largo consume VRAM.
Menor velocidad que tarjetas de gama alta.
Modelos locales pequeños tienen razonamiento complejo limitado.
Multimodalidad y flujos Agent consumen más recursos.

La ruta estable es: usar 8B como asistente local diario, probar 12B para mejor calidad y dejar tareas complejas a modelos cloud.

Resumen

Modelos locales recomendados para RTX 3060 12GB:

Chino general: Qwen3 8B Q4_K_M
Inglés general: Llama 3.1 8B Instruct Q4_K_M
Prueba de más calidad: Gemma 3 12B Q4_K_M
Experimento de razonamiento: DeepSeek R1 Distill Qwen 8B Q4_K_M
Experiencia rápida con poca VRAM: modelos pequeños 3B / 4B

Elige primero Q4_K_M; en modelos 8B puedes probar Q5_K_M. Empieza con Ollama o LM Studio.

No trates la 3060 como un servidor de grandes modelos. Úsala como asistente local de conocimiento, procesador privado de documentos, ayuda ligera de código y tarjeta de experimentación, y encajará mejor con sus capacidades reales.

Referencias

Qwen3 8B GGUF: https://huggingface.co/Qwen/Qwen3-8B-GGUF
Llama 3.1 8B GGUF: https://huggingface.co/macandchiz/Llama-3.1-8B-Instruct-GGUF
Gemma 3 12B GGUF: https://huggingface.co/unsloth/gemma-3-12b-it-GGUF
llama.cpp: https://github.com/ggml-org/llama.cpp
Ollama: https://ollama.com

Ejecutar Qwen3.6 en local: requisitos de VRAM para modelos cuantizados 27B y 35B-A3B

Fri, 01 May 2026 12:02:00 +0800

Los modelos open-weight de Qwen3.6 más relevantes para despliegue local son:

Qwen3.6-27B: modelo denso de 27B.
Qwen3.6-35B-A3B: modelo MoE de 35B totales / 3B activos.

También existen nombres de producto o API como Qwen3.6-Plus y Qwen3.6-Max. Si un modelo no tiene pesos completos públicos y archivos cuantizados estables, no sirve para una tabla local de VRAM.

Como en la tabla de Gemma 4 de /05/10, hay que separar dos conceptos:

Tamaño del archivo GGUF: cuánto ocupa el archivo de pesos.
Uso real de VRAM: depende de pesos, KV cache, contexto, backend, módulos multimodales y batch.

Qwen3.6 tiene contexto por defecto muy largo. La model card indica soporte nativo de 262,144 tokens y extensión a 1,010,000 tokens. La columna de VRAM mínima solo aplica a contexto corto o medio.

Resumen rápido

VRAM	Buena opción	Evitar
8GB	Pruebas extremas de 2 bits para 27B / 35B-A3B	Q4 y superior
12GB	27B Q2/Q3, 35B-A3B Q2/Q3 con contexto corto	27B Q4 con contexto largo
16GB	27B Q3/Q4, 35B-A3B Q3/IQ4_XS	35B-A3B Q4 con contexto largo
24GB	27B Q4/Q5/Q6, 35B-A3B Q4	35B-A3B Q8, BF16
32GB	27B Q8, 35B-A3B Q5/Q6	BF16
48GB	35B-A3B Q8, 27B con más contexto	35B-A3B BF16
80GB+	27B / 35B-A3B BF16	No hace falta BF16 para chat local común

Con una GPU de 24GB, los puntos principales son Qwen3.6-27B Q4_K_M, Qwen3.6-27B Q5_K_M y Qwen3.6-35B-A3B UD-Q4_K_M.

Tamaños oficiales de pesos

Model	Architecture	Official BF16 Weight Size	Official Context
`Qwen3.6-27B`	27B dense	55.56GB	Native 262K, extendable to 1,010K
`Qwen3.6-35B-A3B`	35B total / 3B active MoE	71.90GB	Native 262K, extendable to 1,010K

Aunque 35B-A3B active unos 3B parámetros por paso, todavía debe cargar los pesos MoE completos. No debe estimarse como un modelo pequeño de 3B.

Tabla de VRAM de Qwen3.6-27B

Qwen3.6-27B es un modelo denso. Su ventaja es comportamiento estable; su coste se parece al de un 27B tradicional.

Quantization	GGUF File Size	Minimum VRAM	Safer VRAM	Best For
`UD-IQ2_XXS`	9.39GB	12GB	16GB	Extreme low-VRAM tests
`UD-IQ2_M`	10.85GB	12GB	16GB	Low-VRAM usability
`UD-Q2_K_XL`	11.85GB	14GB	18GB	Low-bit compromise
`UD-IQ3_XXS`	11.99GB	14GB	18GB	VRAM-saving 3-bit
`Q3_K_S`	12.36GB	16GB	20GB	3-bit entry point
`Q3_K_M`	13.59GB	16GB	20GB	Common 3-bit compromise
`IQ4_XS`	15.44GB	20GB	24GB	Near-Q4, more VRAM efficient
`IQ4_NL`	16.07GB	20GB	24GB	Quality/size balance
`Q4_K_M`	16.82GB	20GB	24GB	Recommended 27B default
`Q5_K_M`	19.51GB	24GB	32GB	Higher-quality quantization
`Q6_K`	22.52GB	28GB	32GB	Quality first
`Q8_0`	28.60GB	32GB	40GB	Near-original precision
`BF16`	53.80GB	64GB	80GB	Research, evaluation, precision comparison

Para chat y código local, Q4_K_M es el punto de partida más fácil de recomendar. Una GPU de 24GB puede correrlo bastante bien, pero para contexto largo conviene reducir tamaño o contexto.

Tabla de VRAM de Qwen3.6-35B-A3B

Qwen3.6-35B-A3B es un MoE de 35B totales y unos 3B activos por paso. Equilibra velocidad y capacidad, especialmente para agentes, herramientas y código.

Quantization	GGUF File Size	Minimum VRAM	Safer VRAM	Best For
`UD-IQ2_XXS`	10.76GB	12GB	16GB	Extreme low-VRAM tests
`UD-IQ2_M`	11.52GB	14GB	16GB	Low-VRAM usability
`UD-Q2_K_XL`	12.29GB	14GB	18GB	Low-bit compromise
`UD-IQ3_XXS`	13.21GB	16GB	20GB	VRAM-saving 3-bit
`UD-Q3_K_S`	15.36GB	18GB	24GB	3-bit entry point
`UD-Q3_K_M`	16.60GB	20GB	24GB	Common 3-bit compromise
`UD-IQ4_XS`	17.73GB	20GB	24GB	Quality/size balance
`UD-IQ4_NL`	18.04GB	20GB	24GB	Near-Q4 recommended option
`UD-Q4_K_M`	22.13GB	24GB	32GB	Recommended 35B-A3B default
`UD-Q5_K_M`	26.46GB	32GB	40GB	Higher-quality quantization
`UD-Q6_K`	29.31GB	32GB	48GB	Quality first
`Q8_0`	36.90GB	48GB	64GB	Near-original precision
`BF16`	69.37GB	80GB	96GB	Research, evaluation, precision comparison

Con 24GB, UD-Q4_K_M es una opción clave, pero no conviene fijar contexto muy alto. Para 128K+ contexto, versiones UD-IQ4_XS, UD-IQ4_NL o 3-bit son más realistas.

27B vs 35B-A3B

Necesidad	Mejor opción
Comportamiento denso estable	`Qwen3.6-27B`
Respuesta más rápida, agentes y herramientas	`Qwen3.6-35B-A3B`
Uso diario en 24GB	`35B-A3B UD-Q4_K_M` o `27B Q4_K_M`
Pruebas en 16GB	Usar 2-bit/3-bit y evitar contexto largo
Prioridad a contexto largo	Cuantización más baja y más margen para KV cache
Calidad con 32GB+	`27B Q5/Q6` o `35B-A3B Q5/Q6`

Si escribes código, usas agentes o herramientas, 35B-A3B merece probarse primero. Si quieres estabilidad de un modelo denso, 27B es más directo.

Por qué el contexto largo consume tanta VRAM

La model card de Qwen3.6 recomienda contexto largo para tareas complejas, e incluso señala que 128K+ puede ayudar al razonamiento. Pero en local, contexto largo significa una KV cache mucho más grande.

El uso real depende de:

KV cache;
si se usa entrada de visión;
si se usa --language-model-only;
batch y concurrencia;
cuantización de KV cache;
diferencias entre llama.cpp, vLLM, SGLang, KTransformers y LM Studio.

No mires solo el tamaño GGUF. Si el archivo ya está cerca del límite de VRAM, puede cargar pero fallar al generar salidas largas.

Cómo elegir

12GB: 27B UD-IQ2_M o 35B-A3B UD-IQ2_M, con contexto corto.
16GB: 27B Q3_K_M o 35B-A3B UD-IQ3_XXS.
24GB: 27B Q4_K_M, 35B-A3B UD-IQ4_NL o 35B-A3B UD-Q4_K_M.
32GB: 27B Q5/Q6 o 35B-A3B Q5/Q6.
48GB+: Q8_0 o más margen para contexto largo.

La mayoría no necesita BF16. El objetivo es equilibrar VRAM, contexto, velocidad y calidad.

Referencias

Ejecutar Gemma 4 en local: requisitos de VRAM para modelos cuantizados E2B, E4B, 26B y 31B

Fri, 01 May 2026 11:42:34 +0800

Gemma 4 tiene cuatro tamaños principales para despliegue local: E2B, E4B, 26B A4B y 31B. E2B y E4B apuntan a dispositivos ligeros y edge, 26B A4B usa arquitectura MoE, y 31B es el modelo denso más grande.

El error más común al hacer inferencia local es confundir dos números:

Tamaño del archivo GGUF: cuánto ocupa el archivo de pesos.
Uso real de VRAM: depende de pesos, KV cache, sobrecarga del runtime, longitud de contexto y módulos multimodales.

Las tablas siguientes estiman VRAM a partir del tamaño GGUF. La suposición base es inferencia local de texto con llama.cpp, LM Studio, Ollama o runtimes similares, usando contexto corto o medio. Para contexto largo, entrada de imagen/audio o concurrencia, deja más margen.

Resumen rápido

VRAM	Buena opción	Evitar
4GB	Cuantizaciones E2B de bajo bit	E4B y superiores
6GB	E2B Q4/Q5, E4B de bajo bit	26B, 31B
8GB	E2B Q8, E4B Q4/Q5	26B Q4, 31B Q4
12GB	E4B Q8, pruebas 26B/31B de 2-3 bits	26B Q4 con contexto largo
16GB	26B y 31B de bajo bit	31B Q4 con contexto largo
24GB	26B Q4/Q5, 31B Q4	31B Q8, BF16
32GB	26B Q6/Q8, 31B Q5/Q6	BF16
48GB	31B Q8 más cómodo	31B BF16
80GB+	26B/31B BF16	GPU de consumo única

Para algo usable en local, empieza con E4B Q4_K_M o E2B Q4_K_M. Con 24GB de VRAM, 26B A4B Q4_K_M y 31B Q4_K_M empiezan a ser opciones realistas.

Tabla de VRAM de Gemma 4 E2B

E2B es la versión más ligera, adecuada para portátiles, mini PC, móviles y pruebas con poca VRAM.

Quantization	GGUF File Size	Minimum VRAM	Safer VRAM	Best For
`UD-IQ2_M`	2.29GB	4GB	6GB	Extreme low-VRAM tests
`UD-Q2_K_XL`	2.40GB	4GB	6GB	Low-VRAM usability
`Q3_K_M`	2.54GB	4GB	6GB	Lightweight chat and summaries
`IQ4_XS`	2.98GB	6GB	8GB	Balance of quality and size
`Q4_K_M`	3.11GB	6GB	8GB	Recommended E2B default
`Q5_K_M`	3.36GB	6GB	8GB	Slightly steadier than Q4
`Q6_K`	4.50GB	8GB	10GB	Higher-quality small model
`Q8_0`	5.05GB	8GB	10GB	Near-original precision
`BF16`	9.31GB	12GB	16GB	Debugging, comparison, research

Para uso diario, E2B Q4_K_M suele bastar. Con solo 4GB de VRAM, variantes de 2 o 3 bits pueden arrancar, pero la calidad será menos estable.

Tabla de VRAM de Gemma 4 E4B

E4B es el modelo ligero más práctico. Sirve mejor para escritura diaria, resúmenes, ayuda ligera de código y asistentes locales.

Quantization	GGUF File Size	Minimum VRAM	Safer VRAM	Best For
`UD-IQ2_M`	3.53GB	6GB	8GB	Low-VRAM tests
`UD-Q2_K_XL`	3.74GB	6GB	8GB	Low-VRAM usability
`Q3_K_M`	4.06GB	6GB	10GB	Lightweight local assistant
`IQ4_XS`	4.72GB	8GB	12GB	Balance of quality and speed
`Q4_K_M`	4.98GB	8GB	12GB	Recommended E4B default
`Q5_K_M`	5.48GB	8GB	12GB	Steadier everyday use
`Q6_K`	7.07GB	10GB	16GB	Quality first
`Q8_0`	8.19GB	12GB	16GB	Near-original precision
`BF16`	15.05GB	20GB	24GB	Research, evaluation, precision comparison

Con 8GB de VRAM, E4B Q4_K_M es un punto de partida realista. Con 12GB o 16GB, E4B Q8_0 también merece consideración.

Tabla de VRAM de Gemma 4 26B A4B

26B A4B es la versión MoE. Tiene más parámetros totales, pero activa solo parte de los expertos por paso de inferencia. Es más adecuada para preguntas complejas, código, uso de herramientas y agentes.

Quantization	GGUF File Size	Minimum VRAM	Safer VRAM	Best For
`UD-IQ2_M`	9.97GB	14GB	16GB	Extreme 16GB GPU tests
`UD-Q2_K_XL`	10.55GB	14GB	16GB	Running 26B with low VRAM
`UD-Q3_K_M`	12.53GB	16GB	20GB	Better quality while still VRAM-conscious
`UD-IQ4_XS`	13.42GB	16GB	24GB	Balance of quality and size
`UD-Q4_K_M`	16.87GB	20GB	24GB	Recommended 26B default
`UD-Q5_K_M`	21.15GB	24GB	32GB	Higher-quality quantization
`UD-Q6_K`	23.17GB	28GB	32GB	Quality first
`Q8_0`	26.86GB	32GB	40GB	Near-original precision
`BF16`	50.51GB	64GB	80GB	Not realistic for most single consumer GPUs

24GB de VRAM es la línea cómoda para 26B A4B. Una GPU de 16GB puede probar versiones de bajo bit, pero conviene mantener contexto y concurrencia moderados.

Tabla de VRAM de Gemma 4 31B

31B es el modelo denso más grande. Tiene más capacidad general, pero la presión de VRAM es directa.

Quantization	GGUF File Size	Minimum VRAM	Safer VRAM	Best For
`UD-IQ2_XXS`	8.53GB	12GB	16GB	Extreme low-VRAM tests with clear quality loss
`UD-IQ2_M`	10.75GB	14GB	18GB	Low-VRAM tests
`UD-Q2_K_XL`	11.77GB	16GB	20GB	16GB GPU experiments
`Q3_K_S`	13.21GB	16GB	24GB	More VRAM-efficient 3-bit
`Q3_K_M`	14.74GB	20GB	24GB	Common 3-bit compromise
`IQ4_XS`	16.37GB	20GB	24GB	Near-Q4 compromise
`Q4_K_M`	18.32GB	24GB	32GB	Recommended 31B default
`Q5_K_M`	21.66GB	28GB	32GB	Higher-quality quantization
`Q6_K`	25.20GB	32GB	40GB	Quality first
`Q8_0`	32.64GB	40GB	48GB	Near-original precision
`BF16`	61.41GB	80GB	96GB	Server or large-VRAM workstation

Se puede probar 31B de bajo bit en 16GB, pero para uso diario 24GB es mejor. Q4_K_M es el equilibrio; Q5_K_M y superiores tienen más sentido con 32GB+.

Por qué el uso real supera el tamaño del archivo

El tamaño GGUF solo representa los pesos. En ejecución también cuentan:

KV cache: más contexto implica más memoria.
Batch y concurrencia: más tokens o usuarios consumen más VRAM.
Componentes multimodales: imagen, audio o vídeo añaden módulos como mmproj.
Backend: CUDA, Metal, ROCm y split CPU/GPU no consumen igual.
Cuantización de KV cache: q8_0, q4_0 y modos similares ahorran VRAM, con posibles efectos en detalle.

La columna de VRAM mínima debe leerse como umbral para arrancar e inferir con contexto corto. Para 32K, 64K, 128K o 256K, los requisitos suben bastante.

Cómo elegir

4GB a 6GB: E2B Q3_K_M o E2B Q4_K_M.
8GB: E4B Q4_K_M; E2B Q8_0 también va bien.
12GB: E4B Q8_0, o pruebas de bajo bit de 26B/31B.
16GB: 26B A4B UD-Q3_K_M o 31B Q3_K_S, sin esperar contexto largo cómodo.
24GB: 26B A4B UD-Q4_K_M y 31B Q4_K_M.
32GB+: considerar Q5_K_M, Q6_K o más contexto.

La mayoría de usuarios no necesita BF16. El despliegue local consiste en equilibrar VRAM, velocidad, contexto y calidad, no en elegir el archivo más grande.

Referencias

Cómo usar llama-quantize para modelos GGUF

Sun, 12 Apr 2026 09:42:36 +0800

llama-quantize es la herramienta de cuantización de llama.cpp. Se usa para convertir modelos GGUF de alta precisión en versiones cuantizadas más pequeñas.

Su uso más común es convertir formatos como F32, BF16 o FP16 en versiones como Q4_K_M, Q5_K_M o Q8_0, que son más fáciles de ejecutar localmente. Después de la cuantización, los modelos suelen ser mucho más pequeños y a menudo más rápidos en inferencia, aunque se espera cierta pérdida de calidad.

Flujo básico

Un flujo típico consiste en preparar el modelo original, convertirlo a GGUF y luego ejecutar la cuantización.

# install Python dependencies
python3 -m pip install -r requirements.txt

# convert the model to ggml FP16 format
python3 convert_hf_to_gguf.py ./models/mymodel/

# quantize the model to 4-bits (using Q4_K_M method)
./llama-quantize ./models/mymodel/ggml-model-f16.gguf ./models/mymodel/ggml-model-Q4_K_M.gguf Q4_K_M

Después, puedes ejecutar el modelo cuantizado con llama-cli:

1
2

# start inference on a gguf model
./llama-cli -m ./models/mymodel/ggml-model-Q4_K_M.gguf -cnv -p "You are a helpful assistant"

Opciones comunes

--allow-requantize: permite volver a cuantizar un modelo ya cuantizado, algo que normalmente no es ideal para la calidad
--leave-output-tensor: deja la capa de salida sin cuantizar; aumenta el tamaño, pero a veces ayuda a la calidad
--pure: desactiva la cuantización mixta y usa un tipo de cuantización más uniforme
--imatrix: usa una matriz de importancia para mejorar la calidad de cuantización
--keep-split: conserva el diseño original por fragmentos en lugar de producir un único archivo combinado

Si solo quieres un punto de partida práctico, esto suele bastar:

`1`	`./llama-quantize ./models/mymodel/ggml-model-f16.gguf ./models/mymodel/ggml-model-Q4_K_M.gguf Q4_K_M`

Cómo elegir una cuantización

Puedes pensar en los niveles de cuantización como un compromiso entre tamaño, velocidad y calidad:

Q8_0: más grande, pero normalmente más seguro para la calidad
Q6_K / Q5_K_M: opciones equilibradas habituales
Q4_K_M: valor predeterminado muy común, con buen equilibrio entre tamaño y calidad
Q3 / Q2: útiles cuando el hardware es muy limitado, pero la pérdida de calidad es más visible

El objetivo práctico normalmente no es elegir la cuantización más grande que quepa, sino la que se ejecute de forma fiable en tu hardware manteniendo una calidad aceptable.

Conclusión práctica

empieza con Q4_K_M o Q5_K_M
sube a Q6_K o Q8_0 si la calidad importa más
baja a Q3 o Q2 si la memoria está ajustada
compara versiones con el mismo conjunto de prompts

En resumen, llama-quantize es útil porque hace que los modelos GGUF sean más fáciles de ejecutar en hardware local, no solo porque reduce el tamaño de los archivos.

Cómo obtener modelos GGUF desde Hugging Face con llama.cpp

Sun, 12 Apr 2026 09:31:38 +0800

llama.cpp puede trabajar directamente con modelos GGUF alojados en Hugging Face, así que no siempre necesitas descargar manualmente los archivos del modelo primero.

Si un repositorio de modelo ya ofrece archivos GGUF, puedes usar el argumento -hf en la CLI, por ejemplo:

`1`	`llama-cli -hf ggml-org/gemma-3-1b-it-GGUF`

De forma predeterminada, esto descarga desde Hugging Face.
Si usas otro servicio que expone una API compatible con Hugging Face, puedes cambiar el endpoint de descarga con la variable de entorno MODEL_ENDPOINT.

Un detalle importante es que llama.cpp solo puede usar directamente el formato GGUF.
Si tu modelo está en otro formato, primero necesitas convertirlo con los scripts convert_*.py incluidos en el repositorio.

Hugging Face también ofrece varias herramientas online relacionadas con llama.cpp, entre ellas:

convertir modelos a GGUF
cuantizar pesos para reducir tamaño
convertir adaptadores LoRA
editar metadatos GGUF en el navegador
alojar endpoints de inferencia llama.cpp

Si solo quieres la conclusión práctica, empieza por repositorios que ya ofrezcan GGUF y luego usa llama-cli -hf <user>/<model>. En la mayoría de casos, ese es el camino más simple.

Elegir cuantización GGUF de Llama en Hugging Face: consejos prácticos de Q8 a Q2

Sat, 11 Apr 2026 20:07:29 +0800

Al elegir un modelo Llama GGUF en Hugging Face, puedes pensar en los niveles de cuantización como si fueran resolución: los niveles más bajos usan menos VRAM/RAM, pero la calidad cae gradualmente.

Entiende primero 32, 16 y los niveles Q

32: lo más cercano a la calidad original o sin comprimir, pero con requisitos de hardware extremos.
16: todavía muy cerca de la calidad original, con alrededor de la mitad del tamaño de 32.
Q8: punto de entrada común para modelos cuantizados, escrito normalmente como Q8_0 o Q8.
Q6, Q5, Q4, Q3, Q2: cuanto menor es el número, menor es el uso de recursos y mayor el riesgo de pérdida de calidad.

Qué significa `K_M` / `K_S`

K_M y K_S son variantes de cuantización mixta:

la mayoría de pesos se mantienen en el nivel de cuantización objetivo
algunas partes importantes conservan mayor precisión

Por eso, al mismo nivel, Qx_K_M o Qx_K_S suele ser ligeramente mejor que Qx puro.

Estrategia práctica de selección

Si el hardware lo permite, empieza con Q8.
Si la memoria está justa, baja progresivamente a Q6 / Q5 / Q4.
Intenta no bajar de Q4; Q4_K_M es un límite inferior habitual.
Por debajo de Q4, la degradación de calidad se vuelve cada vez más visible.

Orden de calidad, de mejor a peor

32
16

– Por encima de este punto, la calidad es prácticamente igual, pero los requisitos de hardware son extremos –

Q8
Q6_K_M
Q6_K_S
Q6
Q5_K_M
Q5_K_S
Q5

– Este es el punto dulce típico –

Q4_K_M
Q4_K_S
Q4

– Por debajo de este punto, la pérdida de calidad empieza a verse –

Q3_K_M
Q3_K_S
Q3
Q2_K_M
Q2_K_S
Q2

Si quieres una regla corta: empieza con Q8 o Q6_K_M; baja a Q5 o Q4_K_M solo cuando sea necesario.

Descargar modelos GGUF desde Hugging Face e importarlos en Ollama

Thu, 09 Apr 2026 11:00:07 +0800

Si cierto modelo no tiene una versión preparada en la biblioteca oficial de Ollama, o si quieres usar un archivo GGUF específico de Hugging Face, puedes descargarlo manualmente e importarlo después en Ollama.

Paso 1: descargar el archivo GGUF desde Hugging Face

Primero busca en Hugging Face el archivo GGUF correspondiente al modelo objetivo. Normalmente verás varias versiones cuantizadas, por ejemplo:

Q4_K_M
Q5_K_M
Q8_0

Qué versión elegir depende de tu VRAM, memoria y del equilibrio que quieras entre velocidad y calidad. Después de descargarlo, coloca el archivo .gguf en un directorio fijo para referenciarlo directamente en el Modelfile.

Paso 2: escribir el Modelfile

Crea un archivo Modelfile en el mismo directorio que el modelo. La forma mínima es:

`1`	`FROM ./model.gguf`

Si el nombre del archivo es distinto, cámbialo por el nombre real, por ejemplo:

`1`	`FROM ./gemma-3-12b-it-q4_k_m.gguf`

Si solo quieres ponerlo en marcha primero, normalmente esta línea FROM basta.

Paso 3: importar a Ollama

Después ejecuta:

`1`	`ollama create myModelName -f Modelfile`

myModelName es el nombre local del modelo que quieres usar dentro de Ollama
-f Modelfile indica que se crea el modelo desde este archivo de configuración

Cuando la creación termine correctamente, ese archivo GGUF se convertirá en un modelo local que puede llamarse directamente.

Paso 4: ejecutar el modelo

Después de crearlo, ejecútalo directamente:

`1`	`ollama run myModelName`

A partir de ahí, su uso es básicamente igual al de un modelo descargado con ollama pull.

Cómo ver el Modelfile de un modelo existente

Si no estás seguro de cómo escribir el Modelfile, puedes mirar directamente la configuración de un modelo existente:

`1`	`ollama show --modelfile llama3.2`

Este comando imprimirá el contenido del Modelfile de llama3.2, útil como referencia:

Cómo debería escribirse FROM
Cómo se organizan la plantilla y el system prompt
Cómo se declaran los parámetros

Cuándo conviene esta ruta

Estos escenarios son adecuados para importar manualmente desde Hugging Face:

La biblioteca oficial de Ollama todavía no tiene el modelo que necesitas
Quieres usar una versión cuantizada concreta
Ya descargaste manualmente el archivo GGUF
Quieres controlar con más detalle la forma de empaquetar el modelo

Si ya existe una versión oficial lista, usar pull suele ser más sencillo; pero cuando necesitas una cuantización específica o empaquetado personalizado, GGUF + Modelfile es más flexible.

Precauciones habituales

La ruta después de FROM debe coincidir con la ubicación real del archivo .gguf.
Si el nombre de archivo contiene espacios o caracteres especiales, se recomienda renombrarlo a algo más simple.
Las distintas cuantizaciones GGUF influyen mucho en memoria y velocidad; importarlo con éxito no significa que vaya a ejecutarse con fluidez.
Si el modelo es de chat, normalmente tendrás que ajustar después la plantilla de prompt según su formato para obtener resultados más estables.

Conclusión

Descargar un archivo GGUF desde Hugging Face e importarlo en Ollama no es complicado. Prepara el archivo del modelo, escribe un Modelfile mínimo y ejecuta ollama create; con eso puedes conectar modelos GGUF de terceros a Ollama.

GGUF on KnightLi Blog

Actualización llama.cpp b9196: los binarios precompilados para Windows soportan CUDA 13.1, Vulkan, HIP y SYCL

Para qué sirve llama.cpp

Cómo elegir una versión precompilada para Windows

Arrancar un modelo GGUF normal

Arrancar un modelo visual multimodal

Gestionar varios modelos con un script bat

Tres cosas que mirar al elegir modelos

Problemas comunes

Resumen

Modelos LLM locales recomendados para una GPU RTX 3060

Primero mira el límite de VRAM

Recomendación 1: Qwen3 8B

Recomendación 2: Llama 3.1 8B Instruct

Recomendación 3: Gemma 3 12B

Recomendación 4: DeepSeek R1 Distill Qwen 8B

Recomendación 5: Phi / MiniCPM / modelos pequeños

Cómo elegir cuantización

Qué herramienta usar

No abras demasiado el contexto

Elegir según uso

Expectativas razonables

Resumen

Referencias

Ejecutar Qwen3.6 en local: requisitos de VRAM para modelos cuantizados 27B y 35B-A3B

Resumen rápido

Tamaños oficiales de pesos

Tabla de VRAM de Qwen3.6-27B

Tabla de VRAM de Qwen3.6-35B-A3B

27B vs 35B-A3B

Por qué el contexto largo consume tanta VRAM

Cómo elegir

Referencias

Ejecutar Gemma 4 en local: requisitos de VRAM para modelos cuantizados E2B, E4B, 26B y 31B

Resumen rápido

Tabla de VRAM de Gemma 4 E2B

Tabla de VRAM de Gemma 4 E4B

Tabla de VRAM de Gemma 4 26B A4B

Tabla de VRAM de Gemma 4 31B

Por qué el uso real supera el tamaño del archivo

Cómo elegir

Referencias

Cómo usar llama-quantize para modelos GGUF

Flujo básico

Opciones comunes

Cómo elegir una cuantización

Conclusión práctica

Cómo obtener modelos GGUF desde Hugging Face con llama.cpp

Elegir cuantización GGUF de Llama en Hugging Face: consejos prácticos de Q8 a Q2

Entiende primero 32, 16 y los niveles Q

Qué significa K_M / K_S

Estrategia práctica de selección

Orden de calidad, de mejor a peor

Descargar modelos GGUF desde Hugging Face e importarlos en Ollama

Paso 1: descargar el archivo GGUF desde Hugging Face

Paso 2: escribir el Modelfile

Paso 3: importar a Ollama

Paso 4: ejecutar el modelo

Cómo ver el Modelfile de un modelo existente

Cuándo conviene esta ruta

Precauciones habituales

Conclusión

Qué significa `K_M` / `K_S`