Back to blog
Apr 2, 202610 min read

Gemma 4 Launch: Google DeepMind Ships Apache 2.0 Open Models for Phones to Servers

Gemma 4 arrived with four sizes (E2B, E4B, 26B A4B, 31B), an Apache 2.0 license, and day-one support on AI Studio, Hugging Face, Ollama, and Android.

gemma 4 launchapache 2.0google gemma

Google DeepMind released the Gemma 4 family on April 2, 2026. The models were positioned as the most capable open weights yet from the team, designed from the ground up to run efficiently across phones, laptops, and servers.

Quick answer

Gemma 4 delivered:

  • 31B dense and 26B A4B (Mixture-of-Experts with ~4B active parameters) for strong intelligence per parameter.
  • E2B and E4B edge variants aimed at mobile and IoT with very low latency.
  • Apache 2.0 license on both base and instruction-tuned checkpoints.
  • Day-one distribution through Hugging Face, Ollama, Google AI Studio, Android, and common local tools.

The release emphasized practical deployability rather than only leaderboard scores.

What actually shipped

The family spans four sizes that target different deployment points:

  • Larger models (31B and the 26B A4B MoE) bring strong reasoning while activating only a fraction of parameters during inference on the MoE variant.
  • Edge models (E2B, E4B) focus on running directly on phones, single-board computers, and other constrained hardware.

All checkpoints include both the raw base versions and the IT (instruction-tuned) versions that developers typically use first for chat and agent work.

A major change from earlier Gemma releases was the switch to Apache 2.0. This removes many previous commercial usage concerns and makes fine-tunes and derivative distributions much simpler.

Built on Gemini research, aimed at agents and devices

The models incorporate lessons and architecture advances from Gemini 3 work. Highlights called out at launch included improved thinking/reasoning behavior, broader multimodal understanding (including OCR, speech, and visual grounding), longer context windows, and better native support for tool use and agent loops.

The pitch was consistent: these are open models you can actually run where your data lives instead of always routing through cloud APIs.

Technical Architecture Deep Dive: Dense vs. Sparse MoE Variants

Google DeepMind structured the Gemma 4 release into two distinct computational paradigms to balance raw reasoning power against local hardware memory constraints:

  1. Gemma 4 Dense Models (E2B, E4B, 31B): Standard dense transformers where every weight tensor participates in every token prediction. These models deliver exceptional coherence and reasoning density, but demand linear memory bandwidth scaling during token generation.
  2. Gemma 4 Sparse Mixture-of-Experts (26B A4B): A breakthrough architecture activating only ~4 billion parameters per token forward pass across 8 routed experts. This gives developers the contextual understanding of a 26-billion-parameter foundation model at generation latencies typically associated with a 4B parameter footprint.

Hardware Footprint Matrix Across Quantization Levels

Model Size Quantization Disk Footprint Minimum VRAM (4k Context) Recommended Hardware Target
Gemma 4 E2B FP16 4.8 GB 6 GB Integrated Intel Iris / Apple M1 (8GB)
Gemma 4 E2B Q4_K_M 1.6 GB 3.5 GB Android Flagship (Snapdragon 8 Gen 3)
Gemma 4 E4B Q4_K_M 2.9 GB 5.5 GB Apple M2 / RTX 3050 6GB
Gemma 4 26B A4B Q4_K_M 15.2 GB 18 GB (or 16GB + offload) RTX 4090 24GB / Apple M3 Max (36GB)
Gemma 4 31B Q4_K_M 18.5 GB 22 GB Dual RTX 3060 / Apple M4 Pro (24GB)

Production Deployment: Running Gemma 4 Locally

1. Direct High-Throughput Execution via llama.cpp

To achieve maximum inference efficiency on Apple Silicon unified memory or NVIDIA workstations, compile the latest llama.cpp binary and run with GPU layer offloading:

# Clone and build with Metal or CUDA acceleration
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
make LLAMA_CUDA=1 # or make LLAMA_METAL=1 on macOS

# Run Gemma 4 26B A4B with flash attention enabled
./llama-cli \
  -m ./models/gemma-4-26b-a4b-it.Q4_K_M.gguf \
  -p "Explain the difference between dense and sparse attention mechanisms." \
  -n 512 \
  -ngl 99 \
  -fa \
  -c 8192

2. High-Performance Serving via Ollama

If you prefer a RESTful API compatible with OpenAI client libraries for local agent development:

# Pull and initialize the official Gemma 4 model checkpoint
ollama run gemma4:26b-a4b

# Verify GPU tensor allocation in another terminal
ollama ps

Benchmarks & Memory Bandwidth Realities

Local inference throughput during the auto-regressive token generation phase is almost entirely memory-bandwidth bound. A system with high compute TFLOPS but constrained memory bus width (such as an 8-lane PCIe bus or unified memory running at 100 GB/s) will exhibit lower generation speeds than a workstation with 800+ GB/s memory bandwidth:

  • Apple M3 Max (300 GB/s - 400 GB/s): Delivers ~38 to 44 tokens/second on Gemma 4 26B A4B (Q4_K_M).
  • NVIDIA RTX 4090 (1,008 GB/s): Exceeds 72 tokens/second on fully offloaded Q4_K_M weights.
  • Mid-range Workstations (RTX 4060 Ti 16GB, 288 GB/s): Achieves ~24 tokens/second, limited by narrower memory bus width despite sufficient VRAM capacity.

Troubleshooting Common Deployment Pitfalls

  1. OOM During Prompt Ingestion: If your model loads into VRAM but crashes on long prompts, your KV cache is exceeding remaining memory. Add -ctk q8_0 or -ctv q8_0 in llama.cpp to quantize the KV cache tensors.
  2. Slow Generation on Windows: Check whether GPU memory fallback is active in the NVIDIA Control Panel. If dedicated VRAM is exceeded by even 100 MB, Windows will swap pages into system RAM over PCIe, dropping generation speed from 40 t/s down to 2 t/s.

Availability on Day One

Official channels included:

  • Google AI Studio for quick testing of the larger checkpoints.
  • Hugging Face for weights, inference, and community derivatives.
  • Ollama for simple local installation.
  • Android tooling and AI Edge Gallery for on-device experiments.
  • Direct support in popular local LLM runtimes and OS-level tools.

Why this matters for local users

For people using hardware checkers and local setups, the launch meant real options at multiple quality levels with a permissive license. The edge sizes gave credible on-device paths, while the larger models gave desktop and small-server users stronger local alternatives without license friction.

The models were presented as ready for production local agents and private workflows rather than research-only artifacts.

If you want to see which size actually fits the RAM and GPU you have today, start with the hardware checker on the homepage and the model picker guide. The launch gave us the models; your hardware decides what runs well.

FAQ

What license do the Gemma 4 models use?

All official Gemma 4 checkpoints—including E2B, E4B, 12B, 26B-A4B MoE, and 31B—are released under the permissive Apache 2.0 license, allowing commercial use, fine-tuning, and redistribution without the restrictive custom clauses found in older Gemma generations.

Why is Gemma 4 26B A4B faster than dense 27B–31B models?

Gemma 4 26B A4B uses a Sparse Mixture-of-Experts architecture where only roughly 4 billion parameters are activated for each generated token. You still need ~16 GB+ of memory to hold all 26B Q4_K_M weights, but generation bandwidth scales like a 4B model rather than a dense 30B model.

Which Gemma 4 checkpoint should I run first on a 16 GB laptop?

Start with Gemma 4 E4B (gemma4:e4b) for consistently fast interactive chat and plenty of headroom for long context. Move up to 12B or 26B A4B only after confirming your runtime has Flash Attention and KV cache quantization configured cleanly.

Can Gemma 4 E2B and E4B run completely offline on phones?

Yes. Both edge sizes are designed for on-device deployment via LiteRT / AI Edge Gallery on Android or PocketPal / Metal llama.cpp wrappers on 8 GB iPhones, running without internet connectivity once weights are stored locally.

Related posts