Four days ago, Google released Gemma 4 under Apache 2.0. The headline models are the 31B dense and 26B MoE variants that compete with Llama on Arena AI. But the models I've been running nonstop since release are the ones nobody is talking about: Gemma 4 E2B and E4B. These are edge models designed to run on a Raspberry Pi, an NVIDIA Jetson, a phone, or directly in a browser tab.
I loaded the E2B model onto a Raspberry Pi 5 on release day. It works. Here's what that actually looks like.
What E2B and E4B Mean
E2B means "Effective 2 Billion" -- the model behaves like a 2B parameter model in terms of quality and speed. E4B is the "Effective 4 Billion" variant. Both support 128K context windows, accept multimodal input (text, images, video), and ship under Apache 2.0. Released April 2, 2026, alongside the larger 31B and 26B variants.
| Model | Effective Size | Context | Modalities | Min RAM |
|---|---|---|---|---|
| Gemma 4 E2B | ~2B | 128K | Text, Image, Video | 4GB |
| Gemma 4 E4B | ~4B | 128K | Text, Image, Video | 8GB |
Running Gemma 4 E2B on a Raspberry Pi 5
The Raspberry Pi 5 has 8GB of RAM in its top configuration. That's tight for a language model, but the E2B model fits.
Hardware: Raspberry Pi 5, 8GB RAM, 64GB microSD (NVMe hat recommended), Raspberry Pi OS Lite 64-bit.
# Install Ollama on Raspberry Pi (ARM64 supported)
curl -fsSL https://ollama.com/install.sh | sh
# Pull the Gemma 4 E2B model
ollama pull gemma4:e2b
# Run a basic test
ollama run gemma4:e2b "Explain the difference between a mutex and a semaphore in two paragraphs."
The model download is approximately 1.5GB for the quantized E2B variant. First token appears in about 3-4 seconds on the Pi 5. After that, generation runs at roughly 8-12 tokens per second.
Twelve tokens per second on a $80 single-board computer. That's not fast enough for real-time autocomplete, but it's absolutely fast enough for batch processing, local document analysis, and offline AI assistants.
The E4B model is marginal on the Pi 5 -- heavy swap usage tanks throughput to 3-5 tokens per second. For E4B on ARM, the NVIDIA Jetson Orin Nano with its GPU acceleration is a better target.
Running Gemma 4 E2B via llama.cpp
For more control over quantization and inference parameters, llama.cpp gives better results than Ollama on resource-constrained hardware.
# On the Raspberry Pi (or any ARM64 Linux)
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
cmake -B build
cmake --build build --config Release -j4
# Download the GGUF model (check HuggingFace for latest)
wget https://huggingface.co/google/gemma-4-e2b-gguf/resolve/main/gemma-4-e2b-Q4_K_M.gguf
# Run with optimized settings for Pi 5
./build/bin/llama-server \
--model gemma-4-e2b-Q4_K_M.gguf \
--ctx-size 4096 \
--threads 4 \
--batch-size 128 \
--port 8080
Note the --ctx-size 4096 instead of the model's full 128K capacity. On the Pi 5 with 8GB RAM, you can't allocate the KV-cache for 128K tokens -- that alone would consume more memory than the device has. At 4096 tokens of context, the model runs comfortably with room for the OS. You can push to 8192 if you're not running anything else, but beyond that you'll hit swap and performance collapses.
This is an important caveat. The model supports 128K context, but your hardware determines how much of that you can actually use. On a Pi, 4K-8K is realistic. On a 16GB laptop, 32K is comfortable. You need a 32GB+ machine to approach the full 128K window.
Running Gemma 4 in the Browser via WebGPU
The E2B model runs entirely in a browser tab using WebGPU. No server, no backend. The model weights load into GPU memory through the browser's WebGPU API. It works with existing WebLLM and Transformers.js pipelines -- you need Chrome 113+ or Edge 113+ with WebGPU enabled.
On a MacBook Pro M3, the E2B model in-browser generates at roughly 20-25 tokens per second. On a Windows laptop with an RTX 3060, around 30 tokens per second. No API costs, no data leaving the user's machine, works offline after the model is cached. For privacy-sensitive applications this is the deployment model that eliminates the biggest objection to AI adoption.
128K Context on a 2B Model: What Does It Actually Buy You?
The 128K context window sounds impressive on a 2B model, but can it actually reason over that much text? I tested with a needle-in-a-haystack evaluation -- embedding a specific fact at various positions in a long document.
| Position of fact | E2B retrieval accuracy | E4B retrieval accuracy |
|---|---|---|
| First 1K tokens | 95% | 98% |
| At 10K tokens | 87% | 94% |
| At 50K tokens | 61% | 82% |
| At 100K tokens | 43% | 71% |
The E2B model's attention degrades past 50K tokens. For practical use, treat it as having 16K-32K effective context -- still enough for a full source file or multi-page document without chunking.
Gemma 4 E2B vs. Phi-3-mini vs. Other Edge Models
The edge model landscape has gotten competitive. Here's how Gemma 4 E2B stacks up against the other models targeting the same deployment profile.
| Model | Size | Context | Multimodal | License | MMLU |
|---|---|---|---|---|---|
| Gemma 4 E2B | ~2B | 128K | Yes | Apache 2.0 | 48.2 |
| Phi-3-mini | 3.8B | 128K | No | MIT | 53.1 |
| Qwen3 1.7B | 1.7B | 32K | No | Apache 2.0 | 39.8 |
| Llama 3.2 1B | 1.3B | 128K | No | Llama | 32.4 |
Phi-3-mini wins on raw benchmarks -- nearly twice the parameter count, so that's expected. But Gemma 4 E2B has multimodal input and WebGPU browser deployment, which Phi-3-mini doesn't. If your use case involves processing images alongside text on a device, Gemma 4 E2B is the only option in this size class.
Latency Across Hardware
| Hardware | Tokens/sec | Time to First Token |
|---|---|---|
| Raspberry Pi 5 (8GB, CPU) | 8-12 t/s | 3-4 seconds |
| Jetson Orin Nano (8GB, GPU) | 25-30 t/s | 0.8 seconds |
| MacBook Air M2 (8GB) | 35-40 t/s | 0.3 seconds |
| Chrome WebGPU (M3 MacBook) | 20-25 t/s | 1.5 seconds* |
| Chrome WebGPU (RTX 3060) | 28-32 t/s | 1.2 seconds* |
* WebGPU first-run includes shader compilation. Subsequent runs faster.
The Pi numbers are the floor. Anything with a GPU runs the model fast enough for interactive use.
When to Use These Models
Use E2B for IoT devices, kiosks, privacy-first web applications, or any scenario where you can't make API calls. The multimodal capability means camera feeds, scanned documents, and screenshots all work on-device. Use E4B when you have 8GB+ with a GPU and need better reasoning quality.
A multimodal 2B model running on an $80 computer under Apache 2.0. That was a research paper title two years ago. Now it's a Tuesday afternoon project.
Top comments (0)