Google DeepMind released Gemma 4 on April 2, 2026, and it immediately set new benchmarks for what an open-weight model can do at its parameter count. With a 256K token context window — more than twice the context of Llama 4 Scout — Apache 2.0 licensing that permits unrestricted commercial use, and multimodal capabilities across text and vision, Gemma 4 changes the calculus for developers who need frontier-adjacent performance without the cost and data privacy constraints of cloud API calls. This guide covers everything you need to know to evaluate, run, and deploy Gemma 4.
What Is Gemma 4
Gemma 4 is the fourth generation of Google DeepMind's Gemma model family — open-weight models designed to be small enough to run locally while performing competitively with much larger closed models. The family is built on the same research infrastructure as Google's Gemini models, which means the architecture benefits from Google's advances in attention mechanisms, training data quality, and post-training alignment — though the open Gemma models are trained on substantially less compute than Gemini Ultra or even Gemini Pro.
"Open-weight" is an important distinction from "open-source." Gemma 4 model weights are publicly available to download, inspect, and modify — but Google does not release the training code, training data, or the full training pipeline. This is a common approach among major labs releasing open models: you get the model itself but not everything needed to replicate the training from scratch. For most practical uses — running inference, fine-tuning on your own data, building applications — the distinction doesn't matter. For researchers who want to study the training process itself, it does.
Gemma 4 is available in multiple parameter sizes on Google's model hub and HuggingFace, with variants optimized for instruction following (IT models) and base pre-trained weights for custom fine-tuning. The instruction-tuned variants are the most immediately useful for building applications; the base models are for teams with the expertise and compute to perform their own alignment training.
Benchmark Performance
Gemma 4's benchmark results are notable because they demonstrate meaningful improvement over Gemma 3 while maintaining or improving performance per parameter compared to similarly-sized open models from other labs.
On MMLU (Massive Multitask Language Understanding), which measures knowledge across 57 academic and professional domains, Gemma 4 27B scores approximately 87.2% — competitive with significantly larger models from the previous generation, and above Llama 4 Scout at 8B parameters and Mistral 7B v0.3 on the same benchmark. This reflects the quality of Google DeepMind's training data and alignment process rather than raw parameter count.
On HumanEval, the standard benchmark for code generation across Python programming tasks, Gemma 4 27B scores approximately 74.3% pass@1 (percentage of problems solved correctly on the first attempt). This puts it above Mistral 7B and competitive with Code Llama 34B — a model more than twice its size. For developers building coding assistants or code generation tools that need to run locally or at low API cost, Gemma 4 27B represents a compelling option.
On MATH (a benchmark of competition mathematics problems requiring multi-step reasoning), Gemma 4 27B demonstrates stronger performance than its predecessor, though complex multi-step mathematical reasoning remains a relative weakness compared to frontier closed models like Claude 3.7 Sonnet or GPT-4o. The performance gap on tasks requiring long chains of mathematical reasoning is where the compute advantage of larger closed models remains clearest.
On the MT-Bench conversational quality benchmark, which measures multi-turn dialogue quality, instruction following, and reasoning across diverse task types, Gemma 4 IT scores place it above Llama 4 Scout and competitive with Mistral Large at a fraction of the parameter count. The instruction-tuned variants are noticeably better than the base model on open-ended conversational tasks, which is expected — the alignment training contributes significantly to how well the model follows natural language instructions.
Context window utilization at 256K tokens is a significant advantage over comparable open models. Llama 4 Scout supports 10M theoretical context but performs best at 128K tokens in practice. Gemma 4's 256K context window maintains strong recall performance — verified by "needle in a haystack" retrieval tests — across the full length, making it practical for long-document analysis use cases where other open models struggle.
Model Sizes and Hardware Requirements
Gemma 4 is available in three primary parameter sizes, each targeting a different deployment environment:
Gemma 4 4B: The smallest and fastest variant. Requires approximately 4-6GB of VRAM to run in 8-bit quantized format, making it compatible with consumer GPUs including the RTX 3060 (12GB), RTX 4060 Ti (16GB), and Apple Silicon M1/M2 Macs with 16GB unified memory. Performance on standard tasks is strong for its size. Best for: edge deployment, mobile applications where model weights are downloaded to the device, and latency-sensitive applications where response time matters more than maximum capability.
Gemma 4 12B: The middle tier. Requires approximately 10-14GB VRAM in 8-bit format. Compatible with RTX 3080 (10GB, at the limit in 8-bit), RTX 4070 Ti (12GB), RTX 4080 (16GB), and Apple Silicon M2 Pro/Max with 32GB+ unified memory. Substantially better than 4B on complex reasoning and coding tasks. Best for: local development environments with mid-range GPUs, small-scale production deployments on dedicated GPU servers, and use cases where 4B performance is insufficient but 27B hardware requirements are prohibitive.
Gemma 4 27B: The full-performance variant. Requires approximately 20-25GB VRAM in 8-bit format. Compatible with RTX 4090 (24GB), A100 40GB, H100 80GB, or multi-GPU setups combining two 16GB cards. Apple Silicon M2 Ultra with 96GB unified memory handles it well. Best for: production deployments where maximum capability is required, research and evaluation use cases, and enterprise on-premise deployments. This is the variant whose benchmarks are reported above.
All three sizes support 4-bit GGUF quantization via llama.cpp and Ollama, which reduces VRAM requirements further: Gemma 4 27B Q4_K_M runs in approximately 16-18GB VRAM at some quality cost. The quality tradeoff at 4-bit is noticeable for complex reasoning tasks but acceptable for many practical applications. For CPU-only inference, 4-bit quantization makes Gemma 4 12B runnable on modern laptops without dedicated GPUs, though at significantly slower generation speeds (3-8 tokens/second versus 40-80 tokens/second on a modern GPU).
How to Run Gemma 4 Locally
Option 1: Ollama (easiest)
Ollama provides one-command local model deployment with automatic model management, an OpenAI-compatible API, and support for all three Gemma 4 sizes. Install Ollama from ollama.ai, then run:
ollama pull gemma4:27b
ollama run gemma4:27bThis downloads the 4-bit quantized Gemma 4 27B (approximately 17GB) and starts an interactive chat session. The Ollama API at localhost:11434 accepts OpenAI-compatible requests, making it straightforward to point existing code that uses the OpenAI SDK at your local Gemma 4 instance instead.
Option 2: HuggingFace Transformers
For Python developers who need more control over inference parameters or want to integrate Gemma 4 into existing PyTorch pipelines:
pip install transformers accelerate
from transformers import AutoTokenizer, AutoModelForCausalLM
import torch
model_id = "google/gemma-4-27b-it"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
model_id, torch_dtype=torch.bfloat16, device_map="auto"
)This requires a HuggingFace account and accepting Google's model use agreement on the model card. The bfloat16 format requires approximately 54GB VRAM for 27B; use load_in_8bit=True for 8-bit quantization at lower VRAM cost.
Option 3: Google AI Studio and Vertex AI
For developers who want API access without local hardware requirements, Google AI Studio provides free Gemma 4 access via API for experimentation, and Google Cloud Vertex AI hosts Gemma 4 for production deployment at standard Vertex pricing. This removes local hardware requirements while keeping the model within Google's infrastructure — a relevant consideration for teams with Google Cloud contracts or data residency requirements.
Multimodal Capabilities
Gemma 4 includes vision capabilities across all three sizes, allowing the model to process and reason about images alongside text. The vision encoder handles standard image formats (JPEG, PNG, WebP) at up to 1024x1024 pixel resolution. Capabilities include: image description and analysis, document understanding (reading text in images, interpreting charts and tables), visual question answering, and code understanding from screenshots.
The multimodal capability is most practically useful for document processing workflows — extracting data from photographed forms, analyzing dashboard screenshots, interpreting charts in research papers — and for building applications that need to understand both text and visual context without separate specialized models for each modality. The vision quality at 27B is competitive with similarly-sized multimodal open models; the full frontier multimodal capability of Claude 3.7 Sonnet or GPT-4o remains above Gemma 4 27B on complex visual reasoning, but for practical document and image understanding tasks, Gemma 4 performs well.
Video understanding is not directly supported in Gemma 4 — for video analysis, individual frames can be extracted and processed, but there is no temporal reasoning across frame sequences at this model size.
Licensing and Commercial Use
Gemma 4 is released under the Apache 2.0 license for most use cases. This is among the most permissive licenses available for open-weight models and represents a significant improvement over earlier Gemma versions, which used a custom Gemma Terms of Use with restrictions on certain commercial applications. Apache 2.0 means:
- You can use Gemma 4 in commercial products without paying royalties
- You can modify the weights (fine-tune) and distribute the modified version
- You must include the original license and copyright notice in distributions
- You cannot use the Gemma name or Google branding in ways that suggest Google endorsement
Important exception: Google's Gemma Terms of Use prohibit using Gemma 4 to train other foundation models intended to compete directly with Gemma or Google's other AI models. For fine-tuning on domain-specific data to improve performance on your specific application, there is no restriction. For using Gemma 4 as the basis for a new general-purpose foundation model that you would release as a competitor to Gemma, the terms apply. The vast majority of practical commercial applications fall outside the restriction.
Fine-Tuning Guide
Fine-tuning Gemma 4 on domain-specific data can significantly improve performance on specialized tasks compared to the base instruction-tuned model. The most practical approach for most teams is parameter-efficient fine-tuning using LoRA (Low-Rank Adaptation), which trains a small number of additional parameters rather than updating all model weights — reducing compute requirements dramatically.
Minimum hardware for LoRA fine-tuning:
- Gemma 4 4B: 12GB VRAM (RTX 3060 or Apple M2 Pro)
- Gemma 4 12B: 24GB VRAM (RTX 4090 or A100 40GB)
- Gemma 4 27B: 40GB+ VRAM (A100 40GB at the limit; A100 80GB or H100 recommended)
The HuggingFace PEFT library handles LoRA fine-tuning with minimal code. A practical starting point is a dataset of 1,000-10,000 domain-specific examples in instruction-response format. Smaller datasets (200-500 examples) can improve performance on narrow tasks; larger datasets (50,000+) are necessary for broad domain adaptation. Training typically runs for 1-3 epochs to avoid overfitting.
Quantization-aware training via QLoRA reduces the VRAM requirement further by combining 4-bit quantization with LoRA, making Gemma 4 27B fine-tuning accessible on hardware with 24GB VRAM. Quality loss versus full-precision LoRA is minimal for most applications. The Axolotl training framework provides a configuration-driven approach to QLoRA fine-tuning that reduces the code required to set up a training run.
Gemma 4 vs Llama 4 vs Mistral
Gemma 4 27B vs Meta Llama 4 Scout (109B MoE): Llama 4 Scout uses a Mixture of Experts architecture with 109B total parameters but only 17B active during inference, giving it a favorable performance-per-compute ratio. On most benchmarks, Llama 4 Scout and Gemma 4 27B are competitive, with Llama 4 Scout leading on multilingual tasks (it was trained on significantly more non-English data) and Gemma 4 27B holding an advantage on long-context tasks where the 256K window provides reliable recall. For English-language applications with long-document requirements, Gemma 4 27B is the stronger choice. For multilingual applications or deployments where Llama 4's ecosystem tooling is more developed, Llama 4 Scout is competitive.
Gemma 4 27B vs Mistral Large 2: Mistral Large 2 (123B parameters) is significantly larger than Gemma 4 27B and performs better on complex reasoning and instruction-following tasks. The comparison is roughly: Gemma 4 27B delivers Mistral Large 2-comparable performance on coding and structured tasks at a fraction of the hardware cost. On creative writing, nuanced instruction following, and tasks requiring sophisticated multi-step reasoning, Mistral Large 2 maintains a lead. For cost-sensitive deployments where Mistral Large 2's hardware requirements are prohibitive, Gemma 4 27B is the practical alternative.
Gemma 4 vs frontier closed models (Claude, GPT-4o): The performance gap between Gemma 4 27B and frontier closed models is real and meaningful on complex tasks: multi-step agentic workflows, the most demanding reasoning problems, and tasks requiring the model to maintain coherent long-horizon plans. On routine tasks — document summarization, code review, question answering, and data extraction — Gemma 4 27B often produces comparable quality to frontier models at dramatically lower cost when deployed locally. The decision between Gemma 4 local and frontier API access should be made per-application based on task complexity, volume, and data privacy requirements rather than as a blanket choice.
FAQ
Can I run Gemma 4 on a MacBook?
Yes, with the right configuration. Gemma 4 4B runs well on MacBook Pro with M2/M3 and 16GB unified memory via Ollama, generating 20-40 tokens per second — usable for interactive chat and development testing. Gemma 4 12B runs on MacBook Pro M2 Max or M3 Max with 32GB+ unified memory. Gemma 4 27B requires an M2 Ultra or M3 Ultra Mac Studio or Mac Pro with 96GB+ unified memory. Apple Silicon's unified memory architecture gives Macs an efficiency advantage over discrete GPU setups for this workload — a 16GB M2 MacBook Pro outperforms a similarly-priced Windows laptop with a discrete 8GB GPU card because the unified memory reduces the bottleneck of transferring data between system RAM and GPU memory.
Is Gemma 4 better than Llama 4 for coding tasks?
On standard coding benchmarks (HumanEval, MBPP), Gemma 4 27B and Llama 4 Scout are competitive, with Gemma 4 27B holding a slight edge on Python-specific tasks in our testing. For long-context coding tasks — analyzing large codebases, maintaining context across extensive files — Gemma 4's 256K context window gives it a practical advantage over Llama 4 Scout's reliable context limit. For multilingual code (non-English comments, documentation, variable names), Llama 4's stronger multilingual training is an advantage. Neither replaces frontier coding-optimized models like Claude 3.7 Sonnet or GitHub Copilot on the most complex multi-file agentic tasks.
What is the Gemma 4 context window of 256K tokens in practice?
256,000 tokens is approximately 192,000 words or 650-700 pages of text. In practical terms: you can feed the entire Harry Potter series (approximately 500,000 words) in two passes, analyze a full software repository with several hundred files in one session, or process months of customer support transcripts in a single prompt. The critical qualifier is "reliable recall" — the model actually retrieves information accurately from across the context, not just technically supports the length. Gemma 4's recall on needle-in-a-haystack tests at 256K is strong by open-model standards, though recall accuracy decreases somewhat at maximum context lengths compared to retrieval from the first 64K tokens.
Do I need to accept terms to use Gemma 4?
Yes — downloading Gemma 4 from HuggingFace requires accepting Google's Gemma Terms of Use on the model card. This is a one-time action tied to your HuggingFace account. The terms are permissive (Apache 2.0 for most uses) but do include the restriction on training competing foundation models mentioned above. Accessing Gemma 4 through Google AI Studio or Vertex AI also requires Google account acceptance of their API terms of service. Via Ollama, the download is handled automatically but the same underlying terms apply. There is no cost to accepting the terms — Gemma 4 is free to use under its license conditions.
Bottom Line
Gemma 4 27B is the strongest open-weight model available for English-language long-context tasks in 2026, with its 256K token context window providing a practical advantage over Llama 4 and Mistral alternatives on document analysis and large-codebase work. The Apache 2.0 license removes the commercial use restrictions that complicated earlier Gemma deployments. For teams that need frontier-adjacent performance without cloud API costs, data privacy constraints that prevent sending data to third-party APIs, or the ability to fine-tune on proprietary data — Gemma 4 27B is the most capable open-weight option currently available. Teams with access to cloud APIs and no data privacy constraints will find frontier closed models (Claude 3.7 Sonnet, GPT-4o) still hold a meaningful performance lead on the most complex tasks.
