Google's Gemma 4 Is Out — Here's Why Web Developers Should Pay Attention
Google just released Gemma 4, the latest generation of their open model family — and two things make this one genuinely different. First, it's now Apache 2.0 licensed, removing the custom-license friction that held back adoption. Second, the lineup spans from a 2B-parameter edge model that fits on a Raspberry Pi to a 31B powerhouse that ranks in the top 3 open-source LLMs on the Arena AI leaderboard. If you're a web developer, this one's worth a closer look 🧠.
What's Gemma?
Gemma is Google's family of open-weight language models. They're built on the same research behind Gemini, but packaged for developers to download, run locally, fine-tune, and deploy however they want. The models range from tiny (fits on a phone) to large (competitive with much bigger closed models).
Here's how the family has evolved:
| Version | Release | Sizes | Headline |
|---|---|---|---|
| Gemma 1 | Feb 2024 | 2B, 7B | First open Gemma |
| Gemma 2 | Jun 2024 | 2B, 9B, 27B | Improved quality |
| PaliGemma 2 | Dec 2024 | 3B, 10B, 28B | Vision-language |
| Gemma 3 | Mar 2025 | 1B, 4B, 12B, 27B | Natively multimodal |
| Gemma 3n | May 2025 | E2B, E4B | On-device nano |
| Gemma 4 | Apr 2026 | E2B, E4B, 26B, 31B | Apache 2.0, MoE |
A major change with Gemma 4: the license switched to Apache 2.0. Previous Gemma models used the Gemma Terms of Use, a custom license that allowed commercial use but came with specific restrictions. Gemma 4 drops all of that in favor of the standard Apache 2.0 license. This is a big deal — it means no more license ambiguity, full OSS compatibility, and fewer legal reviews before you ship something built on Gemma.
You can grab the models from Hugging Face, Ollama, Google AI Studio, Kaggle, Vertex AI, LM Studio, or Docker.
What's New in Gemma 4
This isn't a minor version bump. Gemma 4 introduces new architectures, broader modality support, and a model lineup designed to cover everything from edge devices to cloud workstations.
The Model Lineup
| Model | Parameters | Active Params | Context | Modalities | Target Hardware |
|---|---|---|---|---|---|
| E2B | ~2.3B | ~2.3B | 128K | Text, Image, Audio, Video | Phones, Raspberry Pi |
| E4B | ~4.5B | ~4.5B | 128K | Text, Image, Audio, Video | Phones, Jetson Nano |
| 26B (MoE) | 25.2B | 3.8B | 256K | Text, Image, Video | Consumer GPU |
| 31B Dense | 30.7B | 30.7B | 256K | Text, Image, Video | Workstation, Cloud GPUs |
A few things to call out here:
- Mixture-of-Experts (MoE) for 26B. The 26B model has 25.2B total parameters, but only 3.8B are active per token. In practice, it runs like a much smaller model while delivering quality closer to the 31B. If you have a single consumer GPU, this is probably the sweet spot.
- Per-Layer Embeddings (PLE) for edge models. The E2B and E4B models use a technique called PLE that significantly reduces memory usage — critical for running on phones and embedded devices.
- 256K context window on the larger models (128K on edge). That's enough to process entire codebases, long documents, or extended conversation histories.
- Full multimodal support. All four models handle text and images. The edge models (E2B, E4B) also accept audio and video input, making them surprisingly versatile for on-device applications.
- Hybrid attention. All models alternate between local sliding-window attention and global attention layers, balancing efficiency with long-range understanding.
Function Calling and Agentic Support
This is the feature most relevant to web developers building AI-powered apps. Gemma 4 supports native function calling — the model can output structured JSON for tool invocations, follow system prompts, and perform multi-step autonomous reasoning. If you're building agentic workflows where the model needs to call APIs, query databases, or chain together multiple steps, Gemma 4 handles that natively rather than requiring you to hack it in with prompt engineering.
Performance
The 31B model currently ranks in the top 3 of open-source LLMs on the Arena AI leaderboard. It outperforms previous Gemma generations, Meta's Llama, and many models of similar or larger size across reasoning, math, code, science, and multimodal benchmarks. Both pre-trained and instruction-tuned variants are available, and the models support 140+ languages.
Why This Matters for Web Developers
The interesting part isn't the model itself — it's where you can run it.
In-Browser AI
Here's the big idea: open models are now small enough to run in the browser via WebGPU. No server round-trips. No API costs. No data leaving the user's device.
The tooling to make this work already exists:
- MediaPipe LLM Inference API — Google's own library for running Gemma in-browser via WebGPU. Production-grade, well-documented.
- WebLLM — An open-source project for browser-based LLM inference. Supports Gemma out of the box.
- Chrome Built-in AI / Prompt API — Experimental Chrome APIs that use Gemma-based models built directly into the browser. Still early, but the direction is clear.
- Transformers.js — Run Gemma in the browser or Node.js via ONNX Runtime. Same familiar Hugging Face API, but in JavaScript.
What would you actually build with this? Think client-side summarization of long articles, text completion in form fields, semantic search over local data — features that feel instant because they are instant. No network latency, no loading spinners. With Gemma 4's multimodal inputs, you could even process images or video frames directly on the client.
There's a useful pattern here: progressive enhancement for AI. Use a small on-device model (like Gemma 4 E2B) for speed and privacy on capable devices, fall back to a cloud API for heavier tasks or older hardware. The user gets the best experience their device can support.
Server-Side with Node.js
If you need more power or want consistent behavior across all clients, you can run Gemma server-side:
- Google AI JavaScript SDK (
@google/generative-ai) — Official SDK for the Gemini API, which also supports Gemma models hosted on Google AI Studio or Vertex AI. - Ollama + REST API — Run Gemma locally on your machine and call it from Node.js over HTTP. Great for development and testing.
- LangChain.js / Vercel AI SDK — Both support Gemma as a provider, so you can swap models without rewriting your application logic.
The "prototype without API costs" angle is real — and now, with Apache 2.0 licensing, there's zero friction to ship it in production too. Pull a model down with Ollama, wire it up to your Node.js backend, and iterate on your AI features entirely offline. Gemma 4's native function calling makes it especially easy to build agentic flows where the model calls your tools directly.
Practical Use Cases
A few scenarios where this is immediately useful:
- Code assistance — Run a model locally for private, offline code suggestions without sending your codebase to a third party
- AI-powered client-side features — Summarize content, auto-complete user input, or power smart search without a backend
- Agentic workflows — Use Gemma 4's native function calling to build multi-step AI pipelines that invoke your APIs and chain reasoning steps
- Rapid prototyping — Test AI-driven features before committing to a cloud provider or a specific model size
- Fine-tuning for specific tasks — Train a small Gemma model on your domain data for better results on narrow tasks
The Competitive Landscape
Gemma isn't the only open model family out there. Meta's Llama, Mistral, Alibaba's Qwen, Microsoft's Phi, and DeepSeek are all strong contenders with active communities. The space is moving fast and there's genuine competition at every parameter count.
Where Gemma 4 stands out is the combination of Apache 2.0 licensing, MoE efficiency, and ecosystem integration. Chrome's built-in AI APIs are built on Gemma. MediaPipe targets Gemma natively. Vertex AI offers managed Gemma endpoints. If you're already in the Google ecosystem — and most web developers are, at least partially — the on-ramp is shorter. The MoE 26B model is particularly compelling: near-31B quality at a fraction of the compute cost.
Healthy competition drives the whole ecosystem forward. More capable open models mean more options for developers, and that's unambiguously good.
Aliz Stack Connection
We've been documenting AI tooling for the team in our AI-Assisted Development section — that covers IDE assistants, coding agents, prompt engineering, and multi-agent workflows. Open models like Gemma are the other half of the AI picture: not tools that help you write code, but models you embed in the code you ship.
If you're exploring AI features for a project, start with our AI Coding Guidelines for the team's ground rules on responsible use.
The AI-Assisted Development docs are the best starting point for anything AI-related at Aliz — from coding assistants to open models to prompt engineering techniques.