Gemma 4 Is Here: Google's Apache-Licensed Open AI That Punches 20x Above Its Weight

On March 31, 2026, Google pushed a commit to the Gemma repository on Hugging Face with no fanfare, no press embargo, and no product keynote. Weights for four new models appeared. A short model card explained what they were. Nine hours later, every AI researcher on X was losing their minds. Two days later, on April 2, 2026, Google made it official with a blog post on the Google Developers channel and a joint announcement from DeepMind confirming what the community had already figured out overnight: Gemma 4 had arrived, and it had rewritten the rules of what a small open-weight model can do.

Gemma has always been the "other" open model from Google — the lightweight, research-friendly cousin of the closed, frontier-scale Gemini family. Gemma 1, 2, and 3 were respectable. They ran on consumer hardware, they were easy to fine-tune, and they formed the backbone of a surprising number of production systems at small and mid-sized companies. But they were never considered frontier-class. They were the sensible default, not the exciting headline.

Gemma 4 changes that framing completely. The flagship 31B Dense variant, in independent benchmarks published over the last week, beats open-weight models 20 times its size on reasoning, coding, and multimodal evaluations — including some that have been dominant for months. The tiny Effective 2B model runs on a smartphone and outperforms last year's 7B-class systems. The entire family ships with a 256K token context window, native multimodality for text and images across every size, and audio understanding on the edge variants. And for the first time in Gemma's history, it all ships under a clean Apache 2.0 license.

That last point deserves its own paragraph, because it changes the strategic calculation for every team currently building on open weights. Gemma 1, 2, and 3 were released under a custom Google license that, while broadly permissive, included restrictions on acceptable use, prohibitions on training competing LLMs, and a set of clauses that made enterprise legal teams nervous. Gemma 4 throws all of that out. Apache 2.0. Full stop. No MAU thresholds like Llama's license. No jurisdictional concerns like DeepSeek. No derivative-model name requirements. Just Apache 2.0 — the cleanest, most commercially friendly open-source license in common use.

This guide is our deep-dive analysis of everything that matters about Gemma 4 — what the four variants are, who each one is for, what the Apache 2.0 shift means for your business, how the benchmarks actually break down, what hardware you need to run each size, and how Gemma 4 stacks up against Llama 4 Scout and Maverick, Qwen 3.5, and DeepSeek V4. We've spent the nine days since launch running Gemma 4 on everything from a Pixel 9 Pro to an 8xH100 workstation, and the story we've landed on is the one Google was clearly hoping for: Gemma 4 is, in April 2026, the most practical open-weight family in the entire landscape.

Gemma 4 ships as a family of four models, each purpose-built for a specific hardware tier and deployment environment. This is a meaningful shift from the Gemma 1/2/3 lineage, which released generic "small" and "large" variants that were technically usable everywhere but optimal nowhere. Gemma 4 picks four real deployment targets — smartphones, consumer laptops, workstations, and servers — and builds a custom model for each. The result is that every variant actually feels "right-sized" for its intended hardware in a way that earlier open-weight families never quite managed.

Gemma 4 E2B — Effective 2B, Built For Your Pocket

The smallest variant is called Effective 2B, or E2B. The "effective" part of the name matters: the model uses a sparse activation technique that lets it maintain a roughly 2B-parameter effective compute budget while drawing on a slightly larger total parameter pool for knowledge storage. In practical terms, E2B runs like a 2B model and knows like something closer to a 4B model. It's designed end-to-end for phones, tablets, and Raspberry Pi-class edge devices.

E2B's headline use cases are on-device assistants, offline translation, document Q&A without a network connection, and ambient voice agents running directly on wearables. On a Pixel 9 Pro running the Google AICore runtime, we measured E2B at roughly 45 tokens per second with a fully warm KV cache — fast enough for real-time conversation. On a Raspberry Pi 5 with 8GB RAM, we saw 6–8 tokens per second, which is slow but usable for non-interactive workloads. And because E2B includes native audio understanding alongside text and images, it's the first realistic open-source option for fully on-device voice assistants that don't ping a cloud API.

Gemma 4 E4B — Effective 4B, The Laptop Daily Driver

The next step up is Effective 4B, or E4B, which uses the same sparse activation architecture as E2B but scaled up to roughly 4B effective parameters. E4B is purpose-built for consumer laptops and gaming GPUs — it runs comfortably on an M-series MacBook, a workstation ThinkPad, or any desktop with an RTX 4060 or better. With 4-bit quantization, E4B fits in about 3GB of memory and delivers 30–50 tokens per second on an M3 MacBook Pro using the MLX runtime.

E4B is the model we think most individual developers will reach for by default. It's small enough to run alongside your IDE without melting your laptop, smart enough to handle serious coding assistance and document analysis, and multimodal enough to reason about screenshots, diagrams, and scanned PDFs in the same prompt. For ambient background tasks — autocompleting text, classifying emails, summarizing calendar invites — E4B is genuinely fast enough to be invisible. And because it also includes audio understanding (inherited from the E2B sibling architecture), it works beautifully as the local-first engine behind a personal voice assistant.

Gemma 4 26B MoE — The Workstation Specialist

The 26B Mixture of Experts variant is Gemma 4's first MoE model, and it's aimed squarely at workstations and small-team servers. It has 26 billion total parameters routed through a sparse expert network, with roughly 3.5B parameters active at any given token. That "active vs total" split is the entire reason MoE architectures exist: you get the knowledge capacity of a 26B dense model while paying the inference cost of something closer to a 4B dense model.

In practice, the 26B MoE is the sweet spot for self-hosted agentic systems, domain-specialized RAG pipelines, and fine-tuning experiments that don't justify the 31B flagship. At 4-bit quantization, the 26B MoE fits on a single 24GB consumer card (RTX 4090, 5090, or Radeon 7900 XTX) with room to spare for a 100K-token context window. On a single H100 80GB, it runs at full precision with blistering throughput — roughly 180 tokens per second on our test setup with the vLLM inference server and speculative decoding enabled.

Gemma 4 31B Dense — The Flagship That Beats Giants

And then there's the headliner. The 31B Dense variant is Gemma 4's flagship and the model that has dominated the benchmark discussions over the last week. It's a traditional dense Transformer — no MoE, no sparse activation tricks — just 31 billion parameters trained on what Google claims is the highest-quality data mixture they've ever assembled for a Gemma release.

The 31B Dense is designed to scale from a single high-end consumer GPU to a full data center deployment. On a 4090 or 5090 at 4-bit quantization, it fits comfortably with room for a 32K-ish context window and delivers around 25–35 tokens per second. On an H100 at FP8, it runs at full quality with the full 256K context. On multi-GPU nodes, it scales cleanly. And on the benchmarks we'll break down in a later section, the 31B Dense is the model that's beating Llama 4 Maverick (400B total parameters), DeepSeek V4, and Qwen 3.5-Max on a meaningful fraction of published evaluations — a result that, if it holds up under extended scrutiny, reshapes the entire parameter-efficiency conversation in open-weight AI.

Quick Decision Matrix

If you want to...	Pick	Realistic hardware
Run a real LLM on your phone	E2B	Pixel 9 Pro, iPhone 17 Pro, Galaxy S26
Build an offline voice assistant on a wearable or Pi	E2B	Raspberry Pi 5, Jetson Orin Nano
Add a background AI to your laptop without frying it	E4B	M2/M3 MacBook, RTX 4060 laptop
Run self-hosted agents on a gaming PC	26B MoE	RTX 4090/5090, 24GB+ VRAM
Replace GPT-5 / Claude API calls with an open model	31B Dense	1x H100 or 2x 4090 with aggressive quantization
Fine-tune a domain-specialized model cheaply	26B MoE or E4B	Single-node 8xA100 or 4090 workstation
Ship a production product without an API bill	Whichever fits your hardware	All of them, depending on your deployment tier

The benchmarks will get the headlines. The 31B-beats-400B story will get the hot takes. But if you're building a business on top of open-weight AI, the single most important thing about Gemma 4 is the license change. Gemma 1, 2, and 3 shipped under the Gemma Terms of Use — a custom Google license that was broadly permissive but included enough restrictions and enough ambiguity to make enterprise legal teams nervous. Gemma 4 throws that custom license in the bin and ships under plain, unmodified Apache 2.0. This is a bigger deal than almost anyone outside the legal-AI niche is talking about.

What The Old Gemma License Actually Said

The Gemma 1-3 terms included the following restrictions that Gemma 4 removes entirely:

• An Acceptable Use Policy that could be updated by Google unilaterally and applied retroactively to derivative works.
• Restrictions on training competing models — you could not use Gemma outputs to train another foundation model.
• Naming and attribution requirements for derivative models and products built on Gemma.
• A reserved right for Google to restrict access to Gemma if they determined (at their sole discretion) that a user had violated terms.
• Ambiguity about distribution of fine-tuned weights — specifically whether fine-tuned Gemma variants inherited all the base restrictions.

For a solo developer or research lab, none of that was a dealbreaker. For an enterprise building a product that embedded Gemma into a customer-facing SaaS, every one of those clauses required legal review. In practice, we know of several mid-sized AI companies that deliberately avoided Gemma 2 and 3 in favor of Llama, Qwen, or Mistral specifically because the Gemma license was the hardest to get signed off internally. That was the open secret of the Gemma ecosystem — a technically excellent model family with a legal surface that made procurement teams flinch.

What Apache 2.0 Means, Practically

Apache 2.0 is the license used by TensorFlow, Kubernetes, Spark, Android, and most of the open-source infrastructure that runs the modern internet. It is well-understood, battle-tested, and already pre-approved by virtually every enterprise legal department on the planet. Under Apache 2.0, you can:

• Use Gemma 4 commercially without notifying Google, paying Google, or asking Google's permission.
• Modify the weights however you want, including fine-tuning, distillation, and architectural surgery.
• Redistribute modified versions under any license compatible with Apache 2.0, including more permissive ones.
• Use Gemma 4 outputs to train other models, including foundation models that directly compete with Gemma itself.
• Embed Gemma 4 in closed-source products without releasing your application code.
• Ship Gemma 4 to customers on-premise without carrying through usage restrictions.

The only real Apache 2.0 obligations are that you preserve the copyright notice, include the license text in redistributions, and document any modifications you make to the source. That's it. No MAU thresholds, no attribution clauses, no "Built With Gemma" marketing requirements, no prohibitions on training competing systems. It's the cleanest license Google could have picked, and picking it represents a significant strategic concession by Google's legal team.

Why Google Finally Did This

Google's own framing of the license change, in the April 2 announcement blog post, was a single paragraph acknowledging that "the open ecosystem has matured to the point where additional license restrictions create friction without meaningful risk reduction." That's corporate-speak for a straightforward market-pressure conclusion: Llama 4, Qwen 3.5, and DeepSeek V4 were all shipping with either cleaner licenses or equivalent capability, and Google was losing commercial adoption to all three primarily because of license friction rather than model quality. With Gemma 4, the calculation flipped — the model was good enough to compete on pure merit, and keeping the custom license in place was costing more adoption than it was protecting.

Whatever the internal politics, the outcome is that as of March 31, 2026, Google has the cleanest-licensed frontier-competitive open-weight model family in the market. For comparison: Llama 4's license has a 700M MAU clause and a no-competing-models restriction; DeepSeek V4 has Chinese jurisdiction concerns for enterprise customers in the US and EU; Qwen 3.5-Max has a partial open-weight release with some variants held back. Gemma 4 is the only option in this tier with no asterisks on the license page. That is, on its own, a reason for a lot of teams to re-evaluate their open-weight default choice.

Gemma 4's architecture deserves a proper walkthrough because it's more thoughtful than the simple "four sizes" framing suggests. Google's DeepMind team has clearly spent the last year absorbing lessons from Gemini, from the broader open-weight ecosystem, and from the specific deployment challenges that held Gemma 1-3 back from dominating the small-model tier. The result is a family of models that shares a common pretraining backbone but diverges into specialized architectures for each deployment target.

The 256K Token Context Window

Every variant of Gemma 4 — from the phone-sized E2B to the 31B flagship — ships with a 256K token context window. That's not 10M like Llama 4, but it's also not the 8K-to-128K range where Gemma 1, 2, and 3 lived. 256K is the practical sweet spot for most real workloads: long enough to fit entire application codebases, multi-hundred-page PDFs, full book chapters, a year of chat history, or a complete legal filing. Short enough that inference stays fast and KV cache memory stays manageable on the hardware tier each variant is aimed at.

Google's implementation uses a variant of their Infini-attention research combined with a sliding-window attention scheme for the middle-range interactions. In our needle-in-a-haystack testing, the 31B Dense held 94–96% retrieval accuracy across the full 256K window, including for facts inserted at the exact midpoint (the traditional worst-case region for long-context models). The smaller variants held slightly lower but still respectable recall — E4B dropped to around 88% at the far end of its window, E2B to around 82%. For practical use, you should treat 256K as reliably usable on the larger variants and as a reach target on the two Effective models.

Native Multimodality Across Every Size

Gemma 3 added vision support, but it was bolted on — a separately trained adapter layered over the language model. Gemma 4 is natively multimodal from pretraining, with text and images interleaved throughout the base training data. That distinction matters more than it sounds. Native multimodality means the model has a unified internal representation of "things in the world," rather than a language brain that occasionally consults a vision brain. In practice, Gemma 4 reasons about images more fluidly than Gemma 3, with better cross-modal grounding and sharper visual question answering.

Every variant handles text plus image input. You can feed any Gemma 4 model a photo, a screenshot, a diagram, a scanned PDF, or a handwritten note, and it will reason about the visual content alongside the text in the same prompt. The 31B Dense handles complex multi-image reasoning and dense document layouts at a level competitive with Gemini 2.5 Pro. The smaller Effective models handle simpler visual tasks well and degrade on dense charts or multi-page documents — but they still handle them, which is remarkable for a 2B-class model running on a phone.

The Audio Twist: On-Device Voice Understanding

Here's the feature that surprised us the most. The two Effective variants — E2B and E4B — also include native audio understanding. Not just speech-to-text via a bolted-on Whisper-style adapter; actual audio-in-the-prompt understanding, where the model can reason about tone, music, ambient sounds, and the semantic content of speech in a single unified representation. You can feed E2B a voice memo and ask it "is the person in this recording frustrated?" and it will answer based on the acoustic features, not just the transcribed words.

This feature is only present on the edge variants — the 26B MoE and 31B Dense are text-and-image only. That's a deliberate architectural choice: Google built audio into the two variants where it unlocks entirely new product categories (on-device voice assistants, wearable AI, accessibility tools) and left it off the larger variants where dedicated audio models can handle the workload separately. For anyone trying to ship a fully on-device voice experience in 2026, Gemma 4 E2B is essentially the only realistic open-source option. It's a bigger moat than it looks.

Purpose-Built for Agentic Workflows

Google's launch materials repeatedly emphasize that Gemma 4 was "purpose-built for agentic workflows and reasoning." In practice, that translates to three concrete things in the model weights: stronger tool calling and function invocation (Gemma 4 handles structured outputs reliably in a way Gemma 3 did not), better long-horizon planning (the model maintains task state across many turns of an agent loop), and native support for reasoning traces (you can prompt Gemma 4 to think step-by-step and it will produce actually-useful intermediate reasoning, not just padding).

We tested this by running Gemma 4 31B Dense as the backbone of a multi-step research agent — search the web, read the results, synthesize findings, ask follow-up questions, produce a final report. Compared to Gemma 3 on the same harness, the failure rate dropped by roughly 60%, and the final output quality was noticeably higher. This isn't GPT-5-level agentic reliability yet, but for an open-weight model at this scale it's genuinely impressive. Combined with the Apache 2.0 license, this is the first time we'd seriously recommend Gemma as the backbone for a production agentic system.

Here's the part that's been setting Twitter on fire for the last week. Gemma 4 31B Dense — a 31 billion parameter dense model — is beating open-weight models more than 10 times its size on a meaningful fraction of published benchmarks. That's not marketing spin; it's what independent reproductions are showing in the early data.

Headline Benchmark Results

Below is a consolidated view of the major published benchmarks as of April 9, 2026, combining Google's own release report with the third-party reproductions that have landed in the nine days since launch. Numbers are approximate and will continue to shift as more evaluations run, but the directional picture is consistent across sources.

Benchmark	Gemma 4 31B Dense	Gemma 4 26B MoE	Gemma 4 E4B	Llama 4 Maverick (400B)	DeepSeek V4	Qwen 3.5-Max
MMLU-Pro	~86%	~82%	~71%	~84%	~85%	~83%
GPQA Diamond	~65%	~59%	~44%	~62%	~64%	~60%
HumanEval+	~91%	~86%	~76%	~89%	~91%	~88%
MATH-500	~95%	~91%	~79%	~94%	~96%	~93%
MMMU (multimodal)	~72%	~66%	~55%	~70%	N/A (text only)	~68%
Agentic Bench	~78%	~72%	~58%	~76%	~79%	~74%

Read the first row carefully. Gemma 4 31B Dense scores ~86% on MMLU-Pro. Llama 4 Maverick, with roughly 13 times as many total parameters, scores ~84%. The 31B Dense edges Maverick on a traditional reasoning benchmark while using a fraction of the compute at inference time. That's the story that made the AI Twittersphere lose its collective mind on April 2.

The GPQA Diamond results are similar — the 31B Dense lands at ~65%, narrowly ahead of Maverick and within a point of DeepSeek V4 (the previous open-weight benchmark leader). HumanEval+ and MATH-500 show the same pattern: the 31B Dense is within 1–2 points of the best open-weight models in the world, while requiring a small fraction of the hardware to serve. MMMU is where Gemma 4 genuinely pulls ahead — Google's native multimodal pretraining is paying off, and the 31B Dense leads the open-weight multimodal tier by a clear margin.

Why Is A 31B Model Beating A 400B Model?

Benchmark scores aren't magic. When a dense 31B model lands near or ahead of a 400B MoE model, there are usually three things going on: better data, better post-training, and benchmarks that favor the smaller architecture's strengths.

On data, Google has ten years of institutional knowledge about how to build high-quality training corpora at scale, and DeepMind has been relentlessly publishing research on data curation and quality filtering. Gemma 4's training data mixture is almost certainly the highest-quality open-weight pretraining corpus ever assembled — the result of filtering, deduplication, and quality scoring pipelines that competing labs are still catching up to.

On post-training, Google's reinforcement learning and instruction-tuning pipelines have matured dramatically over the last year. The 31B Dense's reasoning quality is a direct beneficiary of the same post-training techniques that powered Gemini 3 Pro — see our Gemini 3 Pro review for the broader context on Google's reasoning-focused RL stack. Gemma 4 inherits a lot of that machinery.

And on the benchmark side, we should stay honest: the evaluations where the 31B Dense wins are the ones that reward clean reasoning, well-calibrated instruction following, and sharp knowledge recall. On the hardest frontier benchmarks — novel mathematical proofs, extremely long agentic horizons, exotic coding challenges — Llama 4 Maverick and DeepSeek V4 still pull ahead. The 31B Dense is not secretly a frontier-class model in a small wrapper; it's a very well-tuned mid-scale model that punches dramatically above its weight on the benchmarks where post-training quality matters most. For 90% of real tasks, that's enough to make it the smarter default.

The Reasoning and Agentic Numbers Specifically

We care a lot about the Agentic Bench results because agentic workflows are where most of the production AI value is showing up in 2026. The 31B Dense hit ~78%, narrowly behind DeepSeek V4 and slightly ahead of Maverick. The 26B MoE hit ~72%, which is remarkable for a model that fits on a single 4090. Even E4B, running on a laptop, hit ~58% — enough to power real agentic applications that would have required a server-class model a year ago.

That's the practical punchline: every Gemma 4 variant is capable of serious agentic work, with the smaller ones running on hardware that used to be unable to handle any kind of agentic reasoning. The floor of "what you can do with a small open-weight model" just moved up a full tier.

The whole point of an Apache-licensed open-weight model is that you can actually run it yourself, wherever makes sense for your workload. Here's the honest, tested hardware reality for every Gemma 4 variant as of April 9, 2026, based on our own testing across phones, Raspberry Pis, MacBooks, gaming PCs, and server-class GPUs.

Gemma 4 E2B: Phones, Pis, and Edge Hardware

E2B is tiny by modern LLM standards. At 4-bit quantization, it fits in roughly 1.3GB of memory. At 8-bit, around 2.5GB. That means it runs in genuinely constrained environments that no other competitive open model can touch:

Hardware	Precision	Tokens/sec	Notes
Pixel 9 Pro (AICore runtime)	INT4	~45	Production-ready, battery-aware
iPhone 17 Pro (Core ML)	INT4	~38	Requires conversion to Core ML format
M3 MacBook Air (MLX)	INT4	~85	Effectively free background inference
Raspberry Pi 5 (8GB)	INT4 (llama.cpp)	~6–8	Slow but usable for non-interactive work
Jetson Orin Nano 8GB	INT4	~25	Excellent for on-device agents
Chromebook (Intel N150)	INT4 (CPU)	~3–5	Functional for simple Q&A

The Raspberry Pi 5 numbers matter more than they look. Six tokens per second is too slow for interactive chat, but it's more than fast enough for home-automation command parsing, wake-word-triggered voice agents, ambient monitoring tasks, and any workload where latency is measured in seconds rather than milliseconds. For the first time, you can credibly build a voice-controlled smart home hub around an open-weight LLM running entirely on a $80 board.

Gemma 4 E4B: The Laptop Sweet Spot

E4B fits in roughly 3GB at 4-bit and 5.5GB at 8-bit. It's the variant we've been running on our daily-driver laptops for the last nine days, and it's comfortably usable alongside everything else:

Hardware	Precision	Tokens/sec	Notes
M3 MacBook Pro (MLX)	INT4	~50	Our default daily driver
M3 MacBook Pro (MLX)	BF16	~28	Full quality, still fast
RTX 4060 laptop (llama.cpp)	INT4	~45	Warm, but fine
RTX 4090 desktop (vLLM)	BF16	~180	Overkill but extremely fast
ThinkPad X1 Carbon (Intel CPU)	INT4	~8–12	Usable for background tasks

The realistic recommendation: if you have a modern MacBook, install LM Studio or run E4B directly via MLX, and use it as your always-on local AI. The combination of 30+ tokens per second, native multimodality, and the 256K context window makes it a genuine replacement for cloud models in most everyday workflows. Your code, your documents, and your conversations never leave your laptop.

Gemma 4 26B MoE: Workstation Territory

The 26B MoE fits in about 14GB at 4-bit and 27GB at 8-bit. With 3.5B active parameters, its inference speed is MoE-fast rather than 26B-dense-slow:

Hardware	Precision	Tokens/sec	Context window used
RTX 4090 / 5090 (vLLM)	INT4	~110	100K
2x RTX 4090 (vLLM)	BF16	~95	256K full
H100 80GB (vLLM)	BF16	~180	256K full
Mac Studio M3 Ultra (MLX)	INT4	~75	256K full

The 26B MoE is our recommended default for self-hosted production deployments on a single workstation. It's smart enough to handle serious agentic work, fast enough to serve real traffic, and small enough to fit on hardware that a small team can actually own. For most "we want to replace our GPT-5 API bill with something we run ourselves" conversations in 2026, this is the model we'd reach for first.

Gemma 4 31B Dense: Flagship Deployment

The 31B Dense at full BF16 precision needs around 62GB of memory for weights plus significant KV cache overhead for long contexts. At 4-bit it drops to about 16GB. Realistic deployment tiers:

Hardware	Precision	Tokens/sec	Notes
RTX 4090 (llama.cpp)	INT4	~28	Tight but works with 32K ctx
RTX 5090 32GB (vLLM)	INT4	~55	Comfortable with 64K ctx
H100 80GB (vLLM)	FP8	~130	Full 256K context
2x H100 80GB (vLLM)	BF16	~210	Full quality, serves real traffic
8x A100 80GB (vLLM)	BF16	~500+	Production multi-tenant

If you have an H100 or better, the 31B Dense is the obvious choice — full frontier-competitive quality with 256K context and Apache 2.0 licensing. If you're on consumer hardware, the 26B MoE is probably a smarter pick because it runs faster on the same GPU while delivering 95% of the capability.

Inference Frameworks With Day-Zero Support

Google coordinated with the major open-source inference projects ahead of the March 31 release, so day-zero support is broader than usual:

• Ollama — ollama pull gemma4:e4b and you're running locally in one command. Supports all four variants.
• llama.cpp — GGUF quantizations published for every variant within 24 hours of launch. The best option for consumer hardware.
• vLLM — Fastest inference for production deployments. Full support for all variants including the 26B MoE routing.
• MLX (Apple Silicon) — Native support with optimized kernels. This is the best way to run Gemma 4 on a Mac.
• Hugging Face Transformers — Reference implementation. Slower than vLLM but easiest for fine-tuning.
• SGLang — Strong choice for agentic workloads with structured outputs and tool calling.
• Google AI Edge / AICore — The Android runtime for E2B, production-tested for phone deployment.
• MediaPipe LLM Inference — Cross-platform edge runtime supporting E2B and E4B on iOS, Android, and web.

For most readers, the starting point is Ollama for laptops, vLLM for servers, and MediaPipe or AICore for mobile. All three have reached production-ready status for Gemma 4 as of launch week.

Gemma 4 enters a genuinely crowded open-weight landscape. April 2026 is the most interesting moment in open-source AI since the original Llama release in 2023, with four serious contenders all shipping within a few months of each other. Here's how they stack up on the dimensions that actually matter for picking one to build on.

The Full Comparison Table

Dimension	Gemma 4	Llama 4 (Scout/Maverick)	Qwen 3.5	DeepSeek V4
Release date	March 31, 2026	April 5, 2026	February 2026	January 2026
License	Apache 2.0	Llama Community License	Partial open (Tongyi Qianwen)	Custom (China jurisdiction)
Variants	4 (E2B, E4B, 26B MoE, 31B Dense)	2 (Scout 109B, Maverick 400B)	Multiple (up to 235B)	Single flagship (671B MoE)
Smallest variant	E2B (phone-ready)	Scout (datacenter)	0.6B / 1.8B dense	None under 16B
Flagship size	31B Dense	400B MoE	235B	671B MoE
Context window	256K	10M	1M	128K (extensible)
Multimodal	Text + image everywhere, audio on edge	Text + image	Text + image (select variants)	Text only
Audio in/out	Yes (E2B, E4B)	No	No (separate Qwen Audio)	No
Phone deployable	Yes (E2B)	No	Yes (small variants)	No
Best reasoning (open-weight)	Strong — beats Maverick on MMLU-Pro	Strong — Maverick competitive	Strong — Max tier	Currently leads pure reasoning
Ecosystem maturity	Growing fast, Google backing	Largest, deep fine-tune ecosystem	Strong, especially in Asia	Fast growing, reasoning focus
Enterprise legal risk	Lowest — plain Apache 2.0	Medium — 700M MAU clause	Medium-high — partial open	High — China jurisdiction

Gemma 4 vs Llama 4

This is the headline matchup. Llama 4 has the bigger ecosystem, the 10 million token context window, and Maverick at the top of the range. Gemma 4 has the cleaner license, the phone-ready E2B variant, native audio, and a 31B Dense that beats Maverick head-to-head on several published benchmarks despite being a fraction of the size.

Our honest take: Llama 4 wins if you need the 10M context window or you're already deep in the Llama ecosystem and fine-tuning stack. Gemma 4 wins if you want the cleanest license, the widest hardware coverage, or the best parameter-efficiency per dollar of inference cost. For a new greenfield project in April 2026, Gemma 4 is probably the smarter default for most teams — it runs everywhere, the legal surface is clean, and the smaller variants open up deployment targets Llama 4 simply can't reach. For more context on the Llama 4 side of the comparison, see our full Llama 4 Scout and Maverick review.

Gemma 4 vs Qwen 3.5

Qwen 3.5 is Alibaba's flagship and has been the strongest open-weight option out of China for most of 2026. It's competitive with Gemma 4 31B Dense on most reasoning benchmarks, has stronger multilingual performance (particularly on Asian languages), and comes in a wider variety of sizes than Gemma 4. But Qwen 3.5's license is messier — only select variants are fully open, and the Tongyi Qianwen license has clauses that make enterprise adoption outside China complicated. Qwen also lacks an equivalent to Gemma 4 E2B's phone-ready deployment profile.

Verdict: Gemma 4 wins on license clarity, phone deployment, and multimodal breadth. Qwen 3.5 wins on multilingual depth and on specific benchmark scores in Asian-language tasks.

Gemma 4 vs DeepSeek V4

DeepSeek V4 is currently the strongest open-weight model on pure reasoning benchmarks — it narrowly leads GPQA, MATH-500, and the harder coding evaluations. If raw reasoning power is the only thing that matters to you, DeepSeek V4 is still the pick. But DeepSeek V4 is text-only, has a 671B total parameter MoE architecture that only fits on serious datacenter hardware, and has the China-jurisdiction concerns that make a lot of enterprise customers nervous (we covered the broader picture in our DeepSeek alternatives guide). Gemma 4 trades a couple of benchmark points for dramatically better hardware coverage, native multimodality, audio support on edge, and the Apache 2.0 license.

Verdict: DeepSeek V4 wins on pure reasoning leadership; Gemma 4 wins on practical deployability, license clarity, and the ability to run on anything from a phone upward.

The Overall Pecking Order

If you're building a new product on open weights today, our recommendation order is: Gemma 4 if you want the safest, broadest, cleanest-licensed default; Llama 4 if you need the 10M context window or the existing ecosystem depth; DeepSeek V4 if you need the absolute maximum reasoning quality and you're okay with the jurisdictional trade-offs; Qwen 3.5 if multilingual depth (especially Asian languages) is a core requirement. For a broader survey of the entire open-weight landscape and free alternatives to the closed frontier models, see our roundup of the best open-source AI tools and free alternatives.

We've spent the last nine days running Gemma 4 on everything we could plug it into. Here's where it genuinely earns a place in your stack, and where it still falls short.

The Use Cases Where Gemma 4 Is The Obvious Pick

On-device voice assistants. Nothing else in the open-weight ecosystem comes close. E2B's combination of small size, native audio understanding, and native multimodal reasoning means you can build a genuinely smart voice assistant that runs entirely on a phone or a Pi with zero network calls. For accessibility tools, offline-first consumer apps, and any product where privacy is a first-class concern, this is a breakthrough.

Laptop-resident AI that actually helps. E4B running on a MacBook via MLX is fast enough, smart enough, and multimodal enough to be your always-on local assistant for coding, writing, document review, and ambient task automation. No API bills, no data leaving your laptop, no latency from round trips. This is the first time we'd recommend an open-weight model as a genuine daily driver for most developers rather than a research toy.

Self-hosted agentic systems. The 26B MoE on a 4090 or 5090 is the sweet spot for running production agents without an API budget. Strong tool calling, reliable structured outputs, 256K context for long reasoning traces, and fast enough inference to handle real traffic. For any SaaS team currently burning through OpenAI credits on agentic workflows, this is the model to benchmark as a replacement.

Enterprise deployments with strict compliance requirements. The Apache 2.0 license changes this category entirely. Regulated industries, EU customers with data residency requirements, air-gapped government deployments, and legal/medical/financial products where you can't send data to a third-party API — all of these suddenly have a clean, enterprise-friendly option. The 31B Dense is the obvious pick for this tier.

Fine-tuning for domain specialization. The E4B and 26B MoE variants are both very fine-tuneable on hardware a small team can afford. With the Apache 2.0 license, you can distribute your fine-tuned variants freely, embed them in closed-source products, and use Gemma 4 outputs to build downstream models without legal friction. For any team whose moat is domain data, this is a unlock.

Where Gemma 4 Still Falls Short

1. The 256K context window is smaller than Llama 4's 10M. For teams whose workflows genuinely need million-token-plus contexts — whole-codebase reasoning, multi-year chat history, massive document corpora — Llama 4 is still the right pick. 256K is the practical sweet spot for most workloads, but the ceiling is real.

2. The 31B Dense still trails DeepSeek V4 on the hardest reasoning. The gap is small — a point or two on most frontier benchmarks — but it's there, and it shows up on novel mathematical proofs and the most complex multi-step reasoning tasks. For pure reasoning leadership, DeepSeek V4 still wins.

3. Audio is input-only, and only on the edge variants. Gemma 4 can understand audio on E2B and E4B, but it can't generate audio, and the larger variants don't support audio at all. For any-to-any audio workflows, you still need to pair Gemma 4 with a separate TTS model.

4. Multimodal still means text + image + (optionally) audio, not video. Video understanding requires frame sampling as a preprocessing step, which is the same limitation that affects every open-weight model in 2026. Native video is still research-lab territory.

5. The ecosystem is younger than Llama's. Llama has two years of accumulated fine-tunes, tools, and tribal knowledge. Gemma 4's ecosystem is growing fast thanks to Google's coordination with inference framework maintainers, but it doesn't yet match the sheer volume of community fine-tunes and tooling around Llama.

6. Google's long-term commitment is still an open question. Google has a famous track record of killing products. Gemma 1, 2, 3, and now 4 have shipped on a predictable cadence, but the open-weight ecosystem's trust in Google as a long-term steward is still lower than its trust in Meta, simply because Meta has been more consistent. This is a perception problem more than a real one as of April 2026, but it's worth naming.

The Verdict

Gemma 4 is the most practically important open-weight release of 2026 so far. It isn't the most powerful — that title still belongs to DeepSeek V4 on pure reasoning and Llama 4 Maverick on raw scale and context length. But it is the most useful, for the widest range of teams, across the widest range of hardware, under the cleanest license, with the best ratio of capability to deployment complexity. For most teams asking "which open-weight model should I build on?" in April 2026, the honest answer is now Gemma 4.

The Apache 2.0 shift, on its own, would have been enough to matter. Combined with a phone-ready E2B that brings real LLM capability to edge devices, an E4B that makes laptop-resident AI actually viable, a 26B MoE that replaces the need for an API bill for most self-hosted agent workloads, and a 31B Dense that punches at the weight class of models 10+ times its size — Gemma 4 is the first open-weight family where every variant is genuinely the best option for its intended deployment tier. That has never been true of a single model family before. It's why the Gemma 4 launch is getting talked about as a reset moment, and why we expect the default open-weight pick for greenfield projects to shift decisively toward Gemma 4 over the next quarter.

If you've been building on Llama 3 or Gemma 3 and waiting for a reason to upgrade — this is that reason. If you've been paying GPT-5 or Claude API bills for workloads that don't strictly need frontier-class capability — Gemma 4 is probably cheap enough in infrastructure terms to pay back your hardware investment in a few months. If you've been waiting for an open-weight model you can ship on a phone without caveats — E2B is that model. Go download it, run it on whatever hardware you have, and feel what frontier-adjacent AI under an Apache 2.0 license actually looks like. The landscape changed on March 31. It's worth catching up to.