¿Qué es Gemma 4 12B?

Gemma 4 12B es el modelo abierto de 12.000 millones de parámetros de Google, publicado el 3 de junio de 2026 bajo licencia Apache 2.0. Es nativamente multimodal (texto, visión y audio) con un diseño sin codificador, y Google afirma que su rendimiento en benchmarks se acerca al del modelo de 26B usando menos de la mitad de memoria.

¿Cuánta memoria necesito para ejecutar Gemma 4 12B en local?

Google indica 16 GB de VRAM o memoria unificada como mínimo para ejecutar Gemma 4 12B en un portátil de consumo. Con la cuantización de 4 bits por defecto, los pesos ocupan aproximadamente 8 GB, así que 16 GB deja margen para el contexto y otras aplicaciones. Con 24 GB o más, las sesiones largas de programación son cómodas.

¿Puedo usar Gemma 4 12B con OpenCode?

Sí. Ejecuta Gemma 4 12B con Ollama y luego añade Ollama como proveedor personalizado en ~/.config/opencode/opencode.jsonc apuntando a http://localhost:11434/v1.. Reinicia OpenCode y selecciona el modelo con /models. No se necesita clave API ni conexión a internet una vez descargado el modelo.

Cómo ejecutar Gemma 4 12B en local con Ollama y OpenCode

Google lanzó Gemma 4 12B el 3 de junio de 2026, y ocupa justo el hueco que la mayoría de desarrolladores que trabajan en local buscan: lo bastante grande para razonar bien, lo bastante pequeño para funcionar en un portátil que ya tienes.

Lo más destacado es el nuevo tamaño intermedio. La familia Gemma 4 anterior ofrecía un modelo edge diminuto y un modelo insignia de 26B, con un hueco entre ambos. El 12B lo llena. Google afirma que sus benchmarks se acercan al modelo de 26B usando menos de la mitad de memoria, y todo cabe en el mínimo de 16 GB que la mayoría de Macs recientes y GPUs de gama media ya superan.

Esta guía repasa lo que ha cambiado en la variante de 12B y luego explica paso a paso cómo ejecutarlo con Ollama y conectarlo a OpenCode como asistente de programación local y privado.

Novedades de Gemma 4 12B

12.000 millones de parámetros, posicionado entre el modelo edge E4B y el modelo insignia de 26B Mixture-of-Experts.
Entrada multimodal nativa. Texto, visión y audio entran en el mismo modelo. La arquitectura no usa codificador: las imágenes pasan por un módulo de embedding ligero y el audio crudo se proyecta directamente al espacio de tokens de texto. Menos componentes que un codificador de visión añadido a posteriori.
Razonamiento cercano al modelo de 26B. Google informa de que el rendimiento en benchmarks del 12B se aproxima al de su variante de 26B, con menos de la mitad de consumo de memoria.
Drafters de Multi-Token Prediction (MTP) para reducir la latencia, lo que ayuda en el uso interactivo, donde cada token cuenta.
Diseñado para flujos de trabajo con agentes, de modo que las llamadas a herramientas y los bucles de programación en varios pasos están integrados de forma nativa y no son un añadido posterior.
Licencia Apache 2.0. Uso comercial, fine-tuning, redistribución. La familia Gemma 4 ya ha superado los 150 millones de descargas.

Los pesos están en Hugging Face y Kaggle, con soporte desde el lanzamiento en Transformers, llama.cpp, MLX, SGLang y vLLM. Ollama está construido sobre llama.cpp y GGUF, así que el 12B funciona ahí igual que los modelos anteriores de Gemma 4.

Gemma 4 12B frente al resto de la familia

Variante	Ideal para	Memoria
E4B (edge)	Móviles, sistemas embebidos y apps en dispositivo	Mínima
12B (nuevo)	Programación local más visión/audio en un portátil	16 GB+
26B MoE (modelo insignia)	Razonamiento más exigente, trabajo con muchos archivos	24 GB+

Si tienes una máquina más modesta o simplemente quieres el modelo por defecto más pequeño, la configuración Gemma 4 + Ollama + OpenCode anterior sigue siendo válida. El 12B es la mejora a la que recurres cuando tienes margen de memoria y quieres un razonamiento notablemente mejor sin saltar al 26B.

Requisitos

Un Mac con Apple Silicon (M1–M5) y al menos 16 GB de memoria unificada, o un PC con una GPU de 16 GB+
Homebrew en macOS
OpenCode instalado (consulta opencode.ai)

El mínimo indicado por Google es 16 GB. Con ese nivel puedes ejecutar el 12B cómodamente para el trabajo diario. Si tienes 24 GB o más, las sesiones largas y las ventanas de contexto grandes dejan de ser un problema.

Paso 1: Instalar Ollama

En macOS:

brew install --cask ollama-app
open -a Ollama

En Linux:

curl -fsSL https://ollama.com/install.sh | sh

Espera a que aparezca el icono en la barra de menú (macOS) o a que arranque el servicio, y luego confirma que el servidor está activo:

ollama list

La API local se ejecuta en http://localhost:11434.

Paso 2: Descargar Gemma 4 12B

ollama pull gemma4:12b

Con la cuantización de 4 bits por defecto, la descarga es de aproximadamente 8 GB. Verifica que se ha descargado:

ollama list
# NAME             ID              SIZE      MODIFIED
# gemma4:12b       ...             ~8 GB     ...

Haz una comprobación rápida:

ollama run gemma4:12b "Write a small TypeScript function that debounces a callback"

Confirma que la GPU está haciendo el trabajo:

ollama ps
# Should show a CPU/GPU split, e.g. 12%/88% CPU/GPU

En Apple Silicon, las versiones recientes de Ollama usan el backend MLX de Apple automáticamente, así que no necesitas configurar nada para la aceleración.

¿No encuentras el tag? Gemma 4 12B es muy reciente, así que si gemma4:12b aún no está en el registro de Ollama, descarga el GGUF oficial desde Hugging Face e impórtalo, o actualiza Ollama (brew upgrade ollama-app) e inténtalo de nuevo.

Paso 3: Conectar Gemma 4 12B a OpenCode

OpenCode lee su configuración desde ~/.config/opencode/opencode.jsonc. Añade Ollama como proveedor personalizado:

{
  "provider": {
    "ollama": {
      "npm": "@ai-sdk/openai-compatible",
      "options": {
        "baseURL": "http://localhost:11434/v1"
      },
      "models": {
        "gemma4:12b": {}
      }
    }
  }
}

Ollama no valida claves, pero OpenCode sigue esperando una entrada de autenticación. Añade una clave ficticia en ~/.local/share/opencode/auth.json:

{
  "ollama": {
    "type": "api",
    "key": "ollama"
  }
}

Reinicia OpenCode, ejecuta /models y cambia a ollama/gemma4:12b. Ahora tienes un asistente de programación que nunca envía una línea de tu código fuera de la máquina.

Paso 4: Mantener el modelo cargado

Por defecto, Ollama libera un modelo de la memoria tras unos cinco minutos de inactividad, lo que significa un arranque en frío cada vez que vuelves al terminal. Mantenlo cargado:

launchctl setenv OLLAMA_KEEP_ALIVE "-1"

Reinicia Ollama para que surta efecto. Para que persista entre reinicios, añade esto a ~/.zshrc:

export OLLAMA_KEEP_ALIVE="-1"

En el icono de Ollama de la barra de menú también puedes activar Launch at Login para que el servidor esté listo antes que tú.

Qué hace bien Gemma 4 12B en OpenCode

Los parámetros extra y los drafters MTP se notan sobre todo en el trabajo que antes resultaba justo con el modelo más pequeño:

Ediciones en varios pasos. Mantiene un plan a lo largo de varios archivos mejor que el 8B, así que las pequeñas refactorizaciones salen bien a la primera con más frecuencia.
Explicación y revisión de código. Pregunta qué hace un módulo o dónde puede esconderse un bug, y las respuestas son más precisas.
Boilerplate y scaffolding. Archivos de configuración, stubs de tests, handlers de rutas y capas CRUD salen limpios.
Entrada de visión. Como el 12B es multimodal, puedes pasarle una captura de un diálogo de error o un mockup de UI y pedirle una corrección o un componente, sin necesidad de montar un modelo de visión aparte.

Dónde todavía se queda corto

Refactorizaciones grandes y transversales. Los cambios coordinados en una docena de archivos siguen desviándose. El 12B lo hace mejor que el 8B, pero no ha solucionado el problema.
La depuración más difícil. En los bugs que abarcan varias capas de abstracción o requieren conocimiento profundo del dominio, ahí es donde un modelo de vanguardia en la nube sigue siendo imprescindible.
Contexto muy largo con 16 GB. El modelo soporta ventanas grandes, pero la calidad se degrada bajo presión de memoria en una máquina de 16 GB. Mantén las entradas razonables o sube a 24 GB+.

Modo híbrido: Gemma 4 12B local más modelos en la nube

Al final, la mayoría opta por usar local para el 70 % rutinario y la nube para el 30 % difícil. Aquí tienes dónde conseguir cada uno:

haimaker.ai — una sola clave API para Claude Opus, GPT-5, Gemini Pro y cientos de modelos más, con precios unificados y benchmarks para que compares antes de decidir.
Ollama — tu Gemma 4 12B local, gratuito y privado, para ediciones y lecturas cotidianas.
APIs de proveedores directamente — si solo necesitas un proveedor en la nube y quieres gestionar las claves por proveedor tú mismo.

Añade Haimaker junto a Ollama en OpenCode:

{
  "provider": {
    "ollama": {
      "npm": "@ai-sdk/openai-compatible",
      "options": {
        "baseURL": "http://localhost:11434/v1"
      },
      "models": {
        "gemma4:12b": {}
      }
    },
    "haimaker": {
      "npm": "@ai-sdk/openai-compatible",
      "options": {
        "baseURL": "https://api.haimaker.ai/v1"
      },
      "models": {
        "anthropic/claude-sonnet-4-6": {},
        "openai/gpt-5": {},
        "google/gemini-2.5-pro": {}
      }
    }
  }
}

Añade tu clave de Haimaker en auth.json:

{
  "ollama": {
    "type": "api",
    "key": "ollama"
  },
  "haimaker": {
    "type": "api",
    "key": "YOUR_HAIMAKER_API_KEY"
  }
}

Usa Gemma 4 12B para lo rápido y luego /models a Sonnet o GPT-5 cuando la tarea se complique. Tu factura en la nube se reduce a una fracción de ejecutarlo todo en un modelo de vanguardia. Para evitar el cambio manual, el auto-router de Haimaker puede detectar la complejidad de la tarea y elegir el modelo por ti.

Regístrate en haimaker.ai y explora el catálogo completo de modelos.

CONSIGUE TU CLAVE API DE HAIMAKER

Solución de problemas

El proveedor no aparece en /models. Reinicia OpenCode después de editar la configuración. No recarga opencode.jsonc mientras está en ejecución.

«Model not found». Ejecuta ollama list y comprueba que el ID del modelo coincide exactamente, normalmente gemma4:12b. Si el tag aún no está en el registro, consulta la nota del Paso 2 sobre importar el GGUF de Hugging Face.

Errores de autenticación con Ollama. La clave ficticia "key": "ollama" en auth.json es suficiente. OpenCode solo necesita que exista una entrada.

Generación lenta. Asegúrate de tener una versión reciente de Ollama para la aceleración MLX en Apple Silicon (ollama --version). Cierra aplicaciones que consuman mucha memoria. Con 16 GB, unas pocas pestañas del navegador reproduciendo vídeo pueden hacerte entrar en swap.

La calidad baja con prompts largos. Eso es presión de memoria en una máquina de 16 GB. Mantén las entradas de contexto moderadas o sube a 24 GB+ para tener margen.

Comandos útiles de Ollama

Comando	Descripción
`ollama list`	Listar modelos descargados
`ollama ps`	Mostrar modelos en ejecución y uso de memoria
`ollama run gemma4:12b`	Chat interactivo
`ollama stop gemma4:12b`	Liberar de memoria
`ollama pull gemma4:12b`	Actualizar a la última versión
`ollama rm gemma4:12b`	Eliminar el modelo

Conclusión

Gemma 4 12B es el modelo local que mucha gente estaba esperando: multimodal, con licencia Apache y lo bastante potente para manejar la mayor parte de la programación diaria en un portátil de 16 GB. Ejecútalo con Ollama, dirige OpenCode hacia él y tendrás un asistente privado para el trabajo rutinario. Mantén un modelo en la nube a un /models de distancia para los problemas difíciles, y conservas la velocidad y privacidad de ejecutar en local sin toparte con su límite de razonamiento.

¿Nuevo en configuraciones locales? Empieza con la guía Gemma 4 + OpenCode para el modelo por defecto más pequeño, o la configuración Gemma 4 + OpenClaw si OpenClaw es tu agente. Para precios en la nube, consulta el catálogo de modelos.