谷歌发布 Gemma 4 开源模型：Apache 2.0 协议，四款规格，31B 杀入开源前三

Google releases the Gemma 4 series with four open-source models, adopting the Apache 2.0 license for the first time. The models cover everything from Raspberry Pi to workstations. The 31B dense model ranks among the top three in open-source, while the 26B MoE model achieves near-trillion-parameter performance with extremely low activation parameters.

Google Finally Made “Open Source” Real

In the early morning of April 3 (Beijing time), Google officially released the Gemma 4 series models. Four specifications, Apache 2.0 license, fully open source.

This deserves to be unpacked. The Gemma series has been iterated over two years, with over 400 million downloads and more than 100,000 derivative variants—a beautiful set of numbers. But insiders have long shared a quiet consensus: the previous Gemma models were only “open,” not truly “open source.” You could download and run them locally, but redistribution was limited, and modified versions couldn’t be freely shared. For developers wanting to build commercial products on top of it, these were very real roadblocks.

This time, moving directly to Apache 2.0 means you can modify it, use it, and sell it as you like. Google’s change in licensing stance is less about generosity and more about being cornered by Llama and DeepSeek. Meta’s Llama series has long held developers’ mindshare in the open-source community, while DeepSeek dominates the Chinese market with unbeatable cost performance. If Google kept hesitating on licensing, Gemma’s ecosystem niche would only grow more awkward.

So, this isn’t about Google suddenly becoming generous—the market simply left it no room to hesitate.

Gemma 4 four-model comparison chart, including parameters, activated parameters, context length, and applicable scenarios for E2B, E4B, 26B MoE, and 31B Dense

Four Models, Four Roles

Gemma 4 drops four specifications at once, covering the full hardware spectrum from IoT devices to developer workstations. Let’s look at them one by one:

E2B / E4B: “Local Brains” for Phones and Edge Devices

These two were designed specifically for edge scenarios. E2B is the efficient 2-billion-parameter version; E4B is the efficient 4-billion-parameter version. Google worked closely with the Pixel team, Qualcomm, and MediaTek for deep optimization.

Key specs:

128K context window
Supports image, video, and native audio input
Can run fully offline on Pixel phones, Raspberry Pi, and Jetson Orin Nano
Near-zero latency

“Running a large model on a Raspberry Pi” sounds gimmicky, but anyone who’s done IoT projects knows: if you can run a multimodal, 128K-context model on edge hardware, many formerly cloud-dependent scenarios can now go fully local. Factory quality control, smart homes, in-vehicle assistants—all demand ultra-low latency and strict privacy. E2B/E4B hits that point exactly.

And don’t overlook their native audio input. Instead of converting speech to text first (ASR), the model directly understands audio, cutting out an entire pipeline of latency and compute cost.

26B MoE: The Actuarial Type

The 26B Mixture-of-Experts (MoE) model has 26 billion total parameters but only activates 3.8 billion during inference.

The advantage is obvious: you get the knowledge capacity of a 26B model but pay the inference bill for only 3.8B. For production deployments with over 100,000 daily calls, that difference equals real money.

Performance-wise, it scores 1441 on Arena AI’s text benchmark, ranking sixth among open models. More notably, that score is close to Qwen3.5-397B-A17B—whose total parameter count is 15 times larger. Achieving near-parity with less than one-twentieth the parameters perfectly illustrates MoE’s efficiency advantage.

It has a 256K context window, supports 140+ languages, and natively supports function calling and structured outputs. Function calling allows direct integration with external tools—querying databases, invoking APIs, executing code—while structured outputs ensure strict JSON formats, making system parsing straightforward. Together, these make it tailor-made for agent workflows.

31B Dense: Brute-Force Aesthetics

31 billion parameters, all activated, no tricks.

Arena AI score: 1452, ranking third among open models. That puts it on par with the 600B+ GLM-5 tier. Google DeepMind CEO Demis Hassabis posted only a brief message on X, but the leaderboard results for 31B Dense spoke volumes.

Also features a 256K context, 140+ languages, function calling, and structured outputs. The difference from 26B MoE: Dense architecture activates all parameters every inference—more costly, but with a higher ceiling. For scenarios demanding ultimate quality—multi-step reasoning, long-document analysis, or complex code generation—31B Dense is the steadier pick.

26B MoE vs 31B Dense: Pick Wrong, and Either the Bill or the Latency Will Hurt

Although their parameter counts differ by less than 20%, they perform very differently in practice.

A quick breakdown:

26B MoE activates 3.8B parameters per inference, 31B Dense activates all 31B
On the same GPU, MoE’s throughput is ~5–8× higher
MoE’s per-inference latency is roughly 1/4–1/3 of Dense’s

But MoE isn’t perfect. Its “specialized experts” route different tokens to different subnetworks. For standardized tasks (summarization, classification, basic code generation, info extraction), the routing is efficient and cost-effective. But for complex reasoning that requires global context, Dense’s “all parameters think together” approach leads.

A simple decision guide:

Daily calls > 100K, standardized tasks, latency-sensitive → 26B MoE
High complexity, highest output quality, manageable volume → 31B Dense
On a budget but want quality → run the pipeline on MoE, reserve Dense for key tasks

In practice, many teams will end up using both: MoE for initial passes and batch tasks, Dense for critical or fallback processing. This is why OpenAI-compatible API aggregators are becoming crucial—you need to switch models dynamically and set “auto fallback” rules, instead of maintaining separate call logic per model.

Technical Details: Gemini 3 Technology Downscaled

Google confirmed Gemma 4 is built on the same research and tech foundation as Gemini 3—and that’s not just PR fluff. Its actual performance clearly inherits core Gemini 3 capabilities:

Multi-step planning and complex reasoning: Essential for agent applications. The model can understand objectives, break down steps, and adapt plans mid-execution. Arena AI scores show Gemma 4 competes head-to-head with closed models in this regard.

Native multimodality: Not stitched post-training but integrated during training across text, images, video, and audio. E2B/E4B support direct audio input; 26B and 31B handle text and images.

140+ language support: For global product developers, that means one model covers almost all major language markets—no per-language fine-tuning needed.

Function calling and structured output: Since 2025, these have become key battlegrounds in open AI. Function calling lets models “do things” beyond chatting; structured outputs make responses programmatically reliable. Gemma 4’s native capabilities here drastically lower the entry barrier for agent app development.

Shifts in the Open-Source Ecosystem

Gemma 4’s release has stirred up competition in open-source AI once again.

The current top tier roughly looks like this:

Meta Llama series: largest community, most mature ecosystem—but starting to lag in reasoning
DeepSeek series: unbeatable value, heavily adopted by Chinese developers
Qwen series: from Alibaba, exceptional in Chinese, broad parameter range
Mistral series: Europe’s representative, early MoE pioneer
Gemma series: long stuck in “open but not open source”; now officially joined the open ranks

Gemma 4’s launch directly challenges Qwen and Mistral. At the 30B scale, the 31B Dense ranks third in Arena AI scores—a spot formerly held by Qwen. The 26B MoE architecture and positioning also compete head-on with Mistral’s Mixtral series.

But the deeper shift is this: Google is finally releasing its top-tier Gemini 3–grade technology as truly open source. This is a win for the ecosystem—more competition means more choice for developers and faster model improvement.

What It Means for Developers

If you’re building AI applications, Gemma 4 deserves a serious look in these scenarios:

Edge deployment: E2B/E4B are among the strongest open-source edge models available. If your product needs offline AI capabilities on phones or IoT devices, shortlist them.

Agent workflows: Native function calling + structured output + 256K context + multi-step reasoning equals the new norm for building agents. Both 26B MoE and 31B Dense can handle it.

Multi-model architecture: In production, many teams now mix models—routing tasks by type and falling back automatically when one fails. Gemma 4’s OpenAI-compatible API fits seamlessly. API hubs like OpenAI Hub let you call Gemma 4 and other models with a single key, switching costlessly.

Cost optimization: If you’re currently using closed models (GPT-4o, Claude Sonnet, etc.) for large-scale standardized tasks, the 26B MoE’s value is worth testing. With only 3.8B active parameters, it approaches the quality of 10B+ models, potentially saving major inference cost.

Some Cold Realities

After all the praise, a few caveats are worth noting.

First, Arena AI scores aren’t everything. They mainly reflect general conversation performance; your task might be code generation, data extraction, or long-document understanding—run your own benchmarks.

Second, although MoE inference is cheap, fine-tuning isn’t. Full fine-tuning still loads all 26B parameters, requiring nearly as much VRAM as 31B Dense. LoRA fine-tuning can limit that, but whether it meets expectations depends on your task.

Third, E2B/E4B’s real-world edge performance still needs broader developer testing. “Runs on a Raspberry Pi” and “runs well on a Raspberry Pi” are very different claims. Actual inference speed, memory use, and heating at 128K context—these need real measurements.

Fourth, Google’s open-source community strategy has lagged. Llama has Meta’s long-term support, DeepSeek thrives on grassroots engagement. Gemma, despite huge download numbers, hasn’t built much community depth. Apache 2.0 is a great start, but a thriving ecosystem takes more than a license.

Final Thoughts

Gemma 4 is a late but sincere step by Google into open-source AI. The Apache 2.0 license clears compliance worries, the four specs span from Raspberry Pi to workstation, and the 31B Dense model lands directly in the open-source top three.

But open-source competition is never just about benchmarks. Ecosystem, community, tools, fine-tuning convenience—these “soft powers” determine whether a model gets real-world adoption. Google has the tech and resources, and now the right license. The next question is whether it will invest community-building effort like Meta does with Llama.

For developers, one more strong option is always a good thing. Benchmark it on your real tasks, let data decide, and don’t get swayed by leaderboard scores.