Gemma 4 Requirements: Mac & GPU Guide (All 5 Models)

You've probably heard that Google's Gemma 4 can run locally on your own hardware. The first question is always the same: "Does my machine have enough juice?"

The answer isn't one-size-fits-all. Gemma 4 is now a family of five models spanning from edge devices to workstations, after Google added a 12B model in June 2026 to sit between the small edge models and the two big workstation models. This guide focuses on the four variants that matter for laptops, desktops, and workstations — and gives you the real numbers straight from Google's official documentation, so you can figure out exactly where your setup falls.

Want the instant answer? Try our interactive Can You Run Gemma 4? hardware checker — pick your device, get a verdict for all five models in seconds.

The Gemma 4 Models for Local Use

Gemma 4 comes in five sizes overall. The smallest — E2B — is designed primarily for phones, tablets, and IoT devices, so we won't spend much time on it here. The four models relevant to laptop and desktop users are:

All four are natively multimodal. E4B, 26B A4B, and 31B handle text + images and support audio and video input. The 12B model goes a step further with a unified, encoder-free multimodal architecture — text, image, and audio share the same weights natively, rather than bolting a separate vision encoder on top. The "E" in E4B stands for effective — more on why that matters for memory in a moment.

How Much Memory Do You Need?

Here's the table that matters most. These numbers come directly from Google's Gemma 4 documentation and represent the minimum GPU/TPU memory required to load the model weights:

These are the minimum memory requirements for loading model weights only — actual usage during inference will be higher. More on that below.

For most people running models locally, Q4_0 (4-bit quantization) is the practical starting point. It dramatically reduces memory usage while keeping output quality surprisingly close to full precision.

Why Does the E4B Need 5 GB for "4 Billion" Parameters?

If you do the math — 4 billion parameters at 4 bits per parameter — you'd expect roughly 2 GB. So where does the extra memory go?

Gemma 4's smaller models use a technique called Per-Layer Embeddings (PLE). Instead of sharing one big embedding table across the entire model, PLE gives every decoder layer its own small embedding lookup for each token. These tables are large in terms of storage but only perform quick lookups — not heavy computation. The model performs like a 4B-parameter model while actually storing considerably more data on disk.

That's why Google uses the word "effective" — the E4B is effective-4B in compute cost, but its actual weight file is closer to what you'd expect from a larger model.

Gemma 4 12B: The 16 GB Sweet Spot

Released June 3, 2026, the 12B model exists to fill a real gap: E4B is built for phones and thin laptops, while 26B A4B and 31B are built for workstations. 12B is the size for a normal 16 GB machine.

At Q4_0, Gemma 4 12B needs about 6.7 GB for the weights (see the table above). That leaves comfortable headroom on any GPU or unified-memory pool with 16 GB total — room for a long conversation's KV cache plus your OS and everything else you have open. It's the model this site gets asked about most now: "I have a 16 GB Mac/GPU, what's the best thing I can run?" — the answer is 12B.

A few things make it worth a dedicated look beyond the memory numbers:

• Encoder-free multimodal design. Instead of a separate multi-layer vision transformer bolted onto the language model, 12B uses a 35M-parameter vision embedder that projects raw 48×48 pixel image patches directly into the model's hidden dimension. Fewer moving parts, less overhead per image.
• Native audio understanding. 12B handles speech recognition and speaker diarization directly, without a separate audio pipeline.
• 256K context, matching the larger 26B A4B and 31B models — the small E4B is the only model in the lineup still capped at 128K.
• 140+ languages and Apache 2.0 licensing, same as the rest of the family.
• A draft model is included for speculative decoding, which speeds up local inference in runtimes that support it (llama.cpp, for example).

Which Macs Run Gemma 4 12B?

Any Apple Silicon Mac with 16 GB or more of unified memory runs 12B at Q4_0 comfortably — that includes the MacBook Air M2/M3/M4 (16 GB configuration), the 16 GB Mac Mini M4, and any MacBook Pro or Mac Studio. This is the headline change from the 12B release: a base-spec MacBook Air is now a legitimate machine for a genuinely capable multimodal model, not just the small E4B.

Which NVIDIA GPUs Run Gemma 4 12B?

The 12 GB RTX 3060 deserves a special callout: it's one of the most common cards among people asking "can my GPU run Gemma 4," and the answer for 12B is a clean yes at Q4_0 — real-world reports put actual VRAM use around 7–8.6 GB depending on context length, well inside the 12 GB budget. SFP8 (13.4 GB) is a tighter fit on a 12 GB card and better suited to 16 GB+ GPUs like the 4060 Ti, 4080, or 4090.

The MoE Catch: 26B Loaded, 4B Active

The 26B A4B model uses a Mixture of Experts (MoE) architecture. Here's what that means in practical terms:

When you send a prompt, the model activates only about 4 billion parameters to process each token — which is why it runs at speeds comparable to a 4B dense model. But all 26 billion parameters need to sit in memory at all times, because the router needs instant access to every expert to decide which ones to activate.

So while 26B A4B runs like a small model, it loads like a large one. Plan your memory budget around the 15.6 GB minimum (at 4-bit), not around the 4B active parameter count.

What the Table Doesn't Tell You

Google's official numbers cover static model weights only. In real-world use, you'll need additional memory for:

KV Cache (Context Window)

Every token in your conversation — both what you type and what the model generates — gets stored in a key-value cache. The longer the conversation, the more memory this consumes. A short prompt might add a few hundred MB, but pushing toward the full 128K or 256K context window can add several gigabytes on top of the base weights.

Operating System and Runtime Overhead

Your OS, the inference runtime (Ollama, llama.cpp, etc.), and other background processes all claim memory. On a typical setup, budget an extra 2–4 GB for system overhead beyond the model itself.

A practical rule of thumb: take the Q4_0 number from the table and add 30–50% for comfortable daily use. So for the E4B at 5 GB base, plan for roughly 7–8 GB of available GPU memory or unified memory.

Which NVIDIA GPU Fits Which Model?

If you're on a desktop or laptop with an NVIDIA GPU, here's how common cards match up against the Q4_0 (4-bit) requirements:

"Tight" means it'll load and run, but you won't have much room for long conversations or other GPU workloads. "Comfortable" means you have headroom for the KV cache and normal multitasking.

# Check your NVIDIA GPU VRAM
nvidia-smi --query-gpu=name,memory.total --format=csv

AMD GPU users: ROCm support is more mature on Linux than Windows. If you're on an AMD card, Linux is the safer bet.

Apple Silicon: Unified Memory Is Your Friend

Apple's M-series chips use unified memory — the CPU and GPU share the same pool of RAM. This is a significant advantage for local AI, because the model doesn't need to be copied between separate CPU and GPU memory. Every gigabyte of RAM your Mac has can be used directly for inference.

# Check your Mac's total memory
system_profiler SPHardwareDataType | grep Memory

The Mac Mini deserves a special mention — it's one of the most cost-effective ways to run local AI on Apple Silicon. The M4 base model starts at 16 GB (enough for 12B or E4B), and the M4 Pro can be configured up to 48 GB, which comfortably handles the 31B dense model. Compared to a MacBook Pro with similar specs, a Mac Mini is significantly cheaper and easier to leave running as a dedicated AI server.

A 16 GB MacBook Air is the machine most people ask about, and as of the 12B release it has a clear answer: yes, comfortably, at Q4_0.

Since macOS and background apps typically consume 3–5 GB, an 8 GB Mac realistically has about 4–5 GB free for the model — just enough to squeeze in E4B (5 GB at Q4_0), though it'll be tight. A 16 GB machine is a much more comfortable starting point.

CPU-Only: Possible, but Set Your Expectations

No GPU? You can still run Gemma 4 on CPU alone — the model loads into system RAM instead. But inference will be significantly slower:

• E4B on CPU: roughly 2–5 tokens/second on a modern laptop. Workable for simple Q&A, but slow for extended chat.
• 26B / 31B on CPU: under 1 token/second on most consumer hardware. Really only practical for batch processing or testing.

For CPU inference, you'll generally need about 2× the model's Q4_0 weight size in system RAM — one copy for the weights, plus working memory for computation. So E4B on CPU needs roughly 10 GB of free system RAM.

What Is Quantization, and Why Should You Care?

You'll see terms like "Q4_0," "SFP8," and "BF16" throughout this guide. Here's what they mean in plain language:

Every AI model stores its knowledge as billions of numbers (called parameters). The precision of those numbers — how many bits each one uses — determines both the model's quality and its memory footprint.

• BF16 (16-bit): Full precision. Best quality, highest memory cost. Mostly for research or high-end servers.
• SFP8 (8-bit): Half the memory of BF16, very close to full quality. A good choice if you have the VRAM to spare.
• Q4_0 (4-bit): Quarter the memory of BF16. Some quality loss, but for most conversational and coding tasks, the difference is hard to notice. This is what most local users run.

Think of it like image compression: a JPEG at 90% quality looks nearly identical to the original, but takes a fraction of the storage. Quantization does the same thing for model weights.

QAT: A Better Way to Reach Q4

On June 5, 2026, Google released official quantization-aware training (QAT) checkpoints for four of the five Gemma 4 models. The difference from the Q4_0 numbers above isn't memory — QAT checkpoints land at essentially the same file size as regular Q4_0 — it's quality. Regular Q4_0 quantizes a model after training, so it never adapts to the lower precision. QAT simulates that precision loss during training, so the model learns weights that hold up better once actually quantized.

The 26B A4B MoE model was left out of Google's official QAT lineup — its narrow expert layers (hidden dimension of just 704) lose too much accuracy at native 4-bit, so Google's own guidance points to INT8 quantization for that model instead. For the full breakdown — what QAT actually is, exact Hugging Face repo names and Ollama tags, and what to use for 26B A4B instead — see our dedicated Gemma 4 QAT guide.

Quick Decision Guide

Not sure which model to try first? Start here:

1. 8 GB or less → Gemma 4 E4B at Q4_0 is feasible but tight. Close unnecessary apps and keep conversations short.
2. 12–16 GB → Gemma 4 12B is the model to run. At Q4_0 it needs about 6.7 GB, leaving real headroom for the KV cache and multitasking — the best quality-per-GB in the lineup right now. Grab the official QAT build for meaningfully better quality at the same memory cost.
3. 16–24 GB → The 26B A4B MoE model becomes feasible. It gives you a big quality jump for the memory cost.
4. 24–32 GB → With the official QAT build, 31B now fits in ~18 GB — a 24 GB card (RTX 3090/4090) or Mac runs it comfortably instead of needing to stretch. 26B A4B still fits comfortably too.
5. 48 GB+ → The full 31B dense model runs comfortably, at BF16 if you want maximum quality. This is as good as Gemma 4 gets locally.

# macOS — check available RAM
sysctl hw.memsize | awk '{printf "Total RAM: %.0f GB\n", $2/1073741824}'

# Windows PowerShell
(Get-CimInstance Win32_ComputerSystem).TotalPhysicalMemory / 1GB

# Linux
free -h | grep Mem

Guides for Your Exact Device

Want the config-by-config breakdown for the machine you actually own? We've built dedicated guides:

• Gemma 4 on Mac Mini — M4 and M4 Pro, 16 GB to 48 GB
• Gemma 4 on MacBook Air — M1 through M4, plus the fanless thermal reality
• Gemma 4 on MacBook Pro — M1 Pro to M4 Max, including used-market picks
• Gemma 4 on Mac Studio — running the 26B and 31B models properly
• Best Mini PC for Gemma 4 — $300 to $2,000 desktop picks
• Gemma 4 on RTX 3060 — the 12GB budget champion, real VRAM and tokens/sec numbers
• Gemma 4 on RTX 3070 & 3080 — why 8GB is tighter than you'd expect
• Gemma 4 CPU Only — no GPU needed, and the MoE 26B sleeper pick

What's Next?

Now that you know which variant fits your hardware, it's time to actually run it.

👉 Next guide: Run Gemma 4 with Ollama: A Practical Guide to Every Model Size

From installation to your first response — about 10 minutes on a decent connection.