Gemma 4 by Google
The Powerful Open AI Model
for Coding, Reasoning & More

Google Gemma 4

Gemma 4 is Google DeepMind's most capable family of open-weight models, launched on April 2, 2026. It is built from the same research and technology as Google's frontier Gemini 3 models, but distilled into smaller checkpoints you can download, run, and modify yourself. The headline theme is intelligence-per-parameter: frontier-class reasoning packaged small enough to run on everything from phones to workstations.

A major change from earlier generations is licensing. Where Gemma 1 through 3 shipped under a custom Google license, Gemma 4 is released under the permissive Apache 2.0 license, removing most enterprise legal friction. The family is natively multimodal, fluent in 140+ languages, and purpose-built for reasoning and agentic workflows.

Gemma 4 download

Gemma 4 is free to download from three main sources: Hugging Face, Kaggle, and Ollama. Because the weights are open under Apache 2.0, there's no cost for the model itself - you only pay for the hardware you run it on.

The simplest route is a local runner that fetches the weights for you on first run. If you're building a pipeline, pull the checkpoint explicitly instead. You'll accept the license once (a one-click step on the model card, or a token in automated environments) before the download begins.

# Easiest - Ollama downloads on first run
ollama run gemma4

# Explicit pull from Hugging Face
huggingface-cli download google/gemma-4-12b-it --local-dir ./gemma-4-12b

Gemma 4 model

"The Gemma 4 model" really means a family. It ships in five sizes so you can pick the smallest model that clears your quality bar: E2B and E4B for edge and on-device, the new 12B unified multimodal model, a 26B Mixture-of-Experts, and a 31B dense flagship. Most sizes come in a base (pretrained) and an instruction-tuned flavor.

Because the whole family shares one tokenizer and chat template, moving between sizes is mostly swapping a checkpoint name - your prompts, evaluation harness, and serving code stay the same.

Gemma 4 31B

The 31B Dense model is the flagship. Every parameter is active on every token, which trades speed for consistency and top-end quality. It's the pick when reasoning quality is the absolute priority and you have the hardware - a single high-end data-center GPU handles it at production latency, and in 4-bit quantization it can fit on a 16 GB consumer GPU.

On public leaderboards the 31B reached around #3 on Arena's open-model text leaderboard, competing with models many times its size, and it supports text and image input with up to a 256K context window.

Gemma 4 26B

The 26B is a Mixture-of-Experts (MoE) model - often written 26B A4B, meaning roughly 4B parameters are active per token even though the full model is larger. A learned router sends each token to a handful of specialized experts while the rest sit idle and cost nothing, so you get quality approaching the dense 31B at meaningfully lower serving cost.

It supports the same 256K context and text-plus-image input, and per active parameter it's one of the most efficient reasoning models in the open-weight field, landing around #6 on Arena's text leaderboard.

Gemma 4 12B

Released on June 3, 2026, the 12B is a mid-size model with a novel unified, encoder-free architecture: image and audio inputs flow directly into the LLM backbone instead of passing through separate encoders first. It's the first mid-sized Gemma with native audio input, and it ships with Multi-Token Prediction (MTP) drafters to cut latency.

Practically, it bridges the edge-friendly E4B and the heavier 26B MoE: it runs on a laptop with 16 GB of RAM yet approaches the 26B on benchmarks at under half the memory footprint - the best all-round pick for local assistants and RAG.

Gemma 4 E4B

The E4B ("Effective 4B", around 4.5B parameters) is the larger of the two edge models. The "effective" naming reflects a Per-Layer Embedding design that maximizes capability per unit of memory. It takes text, image, and audio input, supports a 128K context, and runs comfortably on laptops and modest GPUs - reportedly on as little as 6–8 GB of VRAM, while still outperforming the previous-generation Gemma 3 27B on math and agentic tasks.

Alongside it, the even smaller E2B targets phones and embedded devices via MediaPipe and LiteRT. Together they open on-device categories - offline assistants, voice apps, robotics - that weren't viable with earlier open models.

Gemma 4 API

You can use Gemma 4 without hosting it yourself. Google exposes it through Google AI Studio and Google Cloud (Vertex AI, Cloud Run, GKE), and third-party providers such as OpenRouter, Together, and Fireworks serve it via OpenAI-compatible endpoints. If you self-host, tools like vLLM and llama.cpp's server also expose an OpenAI-style API so your existing client code just works.

# OpenAI-compatible call against a self-hosted or provider endpoint
curl $BASE_URL/v1/chat/completions \
  -H "Authorization: Bearer $KEY" \
  -d '{"model":"gemma-4-12b-it","messages":[{"role":"user","content":"Hi"}]}'

Gemma 4 Hugging Face

Hugging Face is the primary home for the weights and the day-one integration point for the Python ecosystem - Transformers, TRL, Transformers.js, and Candle all support Gemma 4. The models are gated: click Accept on the model card (or authenticate with a token) once, and you're set.

from transformers import pipeline
pipe = pipeline("text-generation", model="google/gemma-4-12b-it")
print(pipe("Explain what makes Gemma 4 open."))

Gemma 4 requirements

Beyond hardware (covered in §19), getting started needs only a few things:

Software: a runner - Ollama, LM Studio, llama.cpp, or Python with Transformers (Python 3.10+). GPU acceleration wants recent NVIDIA CUDA, AMD ROCm, or Apple Metal drivers; CPU-only works too, just slower.

License: accept the terms once on the model card. Gemma 4 is Apache 2.0, so commercial use, modification, and redistribution are permitted - but note the license does not grant trademark rights, so you can't brand your product as "Gemma".

Disk: budget from a couple of gigabytes for a quantized edge model up to tens of gigabytes for a full-precision flagship checkpoint.

How to run Gemma 4 locally

The friendliest path is Ollama: install it, run one command, and it downloads and serves the model. Prefer a GUI? LM Studio gives you a chat window and a local server. Want maximum portability or CPU support? llama.cpp runs GGUF files anywhere. On a Mac, MLX takes advantage of unified memory.

# Ollama - the fastest local path
ollama run gemma4

# llama.cpp - portable, CPU or GPU, offload all layers with -ngl 99
./llama-cli -m gemma-4-12b-it-Q4_K_M.gguf -ngl 99 -c 8192 -p "Hello"

Gemma 4 vs Gemini

These aren't really competitors so much as two ends of one strategy. Gemini is Google's proprietary frontier line (Gemini 3, and newer Flash tiers) - the most capable models, delivered as a managed API you reach through Google's cloud. You can't download the weights or run them offline. Gemma 4 is the open-weight sibling, built from the same research, that you can download, fine-tune, and run inside your own infrastructure.

Pick Gemini when you want the highest possible capability and are happy with a hosted service; pick Gemma 4 when you need data control, offline or on-device deployment, custom fine-tuning, or predictable self-hosted costs.

Gemma 4 vs Qwen

Alibaba's Qwen family (the 3.5 / 3.6 generation) is Gemma 4's closest open-weight rival - both released in 2026 under Apache 2.0. The two publish on largely non-overlapping benchmark suites, so a clean apples-to-apples score is hard. In broad strokes: Gemma 4 leads on native multimodality, deployment breadth from phones to servers, ease of fine-tuning, and general-chat rankings, while Qwen leads on agentic coding, tool use, and very long context, with MoE routing that can make it faster and cheaper per token.

Rule of thumb: Gemma 4 for multimodal, on-device, and local-first products; Qwen if coding agents and long-horizon repo work are your center of gravity. Validate on your own tasks - specific numbers vary a lot between sources.

Gemma 4 vs Llama

Meta's Llama 4 (Scout and Maverick, released April 5, 2026) takes a very different shape. Its models are large - Scout is a 17B-active/109B MoE, Maverick a 17B-active/400B MoE - and they ship under Meta's Community License, which restricts apps above 700M monthly active users and requires "Built with Llama" branding. They take text and image only, with roughly a dozen languages.

Independent write-ups generally give Gemma 4 the edge on reasoning, math, and coding benchmarks at comparable sizes, plus native audio/video, 140+ languages, unrestricted Apache 2.0 licensing, and true on-device deployment (the E4B runs on 6–8 GB of VRAM). Llama 4's standout advantages are Scout's headline ~10M-token context and Maverick's raw scale for maximum reasoning - both of which need serious multi-GPU hardware. Choose Gemma 4 for laptops, edge, and licensing simplicity; choose Llama 4 when you genuinely need extreme context or the largest open model.

Gemma 4 benchmarks

On disclosed benchmarks the 31B flagship is strong on reasoning and math - reported around 89.2% on AIME 2026, 85.2% on MMLU Pro, roughly 80% on LiveCodeBench v6, and a notably high 84.3% on GPQA Diamond (graduate-level reasoning) - and it placed about #3 on Arena's open-model text leaderboard, with the 26B MoE around #6.

Gemma 4 pricing

The weights cost nothing - Apache 2.0, no licensing fees, no monthly-user caps. "Pricing" enters only two ways: the hardware you run it on when self-hosting, or per-token fees if you use a hosted API instead of running it yourself.

Hosted options include Google Cloud (Vertex AI, Cloud Run, GKE) and providers like OpenRouter, Together, and Fireworks. Per-token rates for open models in this class typically land well under a dollar per million tokens, but they vary by provider and change often - always check current rates before budgeting.

Gemma 4 fine-tuning

Gemma 4 is designed to be adapted. Full fine-tuning updates every weight and needs heavy hardware, so most people use parameter-efficient methods: LoRA freezes the base model and trains small adapter matrices, and QLoRA loads the frozen base in 4-bit so even a 12B model tunes on a single consumer GPU. Libraries like Unsloth make this fast; Google also supports fine-tuning via Colab, Vertex AI Training, and Keras.

Data quality beats quantity - a few thousand clean, correctly-formatted examples usually beat a large noisy set. Match the model's chat template exactly, use a low learning rate, and hold out a validation set. When done, keep the adapter or merge and export to GGUF or MLX for deployment.

Gemma 4 Ollama

Ollama is the easiest way to run Gemma 4. Install it, then ollama run gemma4 pulls the weights and drops you into a chat prompt. It also runs a local HTTP server on port 11434 with an OpenAI-compatible endpoint, so apps and scripts can talk to it just like a cloud API - fully offline.

ollama run gemma4              # default (12B) chat
ollama run gemma4:e4b          # pick a specific size
ollama pull gemma4:27b         # download without chatting

Gemma 4 system requirements

Hardware needs scale with model size and precision. As a rough guide at 4-bit quantization: the E2B runs on phones and ~2 GB; E4B on ~6–8 GB (a modest laptop GPU or even CPU); the 12B on a 16 GB laptop; the 26B MoE and 31B on a 24 GB consumer GPU. At full precision the larger models want a data-center GPU (e.g., a single H100 handles the 31B at production latency).

Two reminders: these figures are for weights only - long contexts add significant KV-cache memory, so budget headroom or quantize the cache. And on Apple Silicon, unified memory is shared between the OS and the model, so leave room for both.

Google Gemma 4 E2B for TPU: Offline AI Powers the Pixel 10 Series

Google has officially introduced Gemma 4 E2B for TPU, a new optimized version of its open AI model family designed specifically for the Tensor G5 TPU in the Pixel 10 lineup. Announced during Google I/O Connect India, the model delivers fast, private, and multimodal AI experiences directly on-device without requiring an internet connection.

Built as part of Google's open Gemma family, Gemma 4 E2B demonstrates how advanced AI can run efficiently on smartphones while keeping user data private.