Requirements

Gemma 4 Hardware Requirements

Complete RAM, VRAM, and memory bandwidth requirements for running Gemma 4 locally across phones, 16 GB Macs, NVIDIA RTX desktops, AMD Radeon GPUs, and edge boards.

The most practical hardware question is not what the biggest model in the catalog is—it is which checkpoint maintains crisp generation speed and full stability without exceeding your VRAM or unified memory ceiling.

Because LLM token generation reads model weights from memory once per output token, usable capacity determines whether a model loads at all, while memory bandwidth (GB/s) determines how fast words stream on screen.

Hardware tier requirements matrix

Use the tier table below to map your physical RAM or dedicated GPU VRAM to a reliable Gemma 4 checkpoint at Q4_K_M with comfortable 8K–16K context headroom.

Hardware ClassUsable Model BudgetBest First ModelStretch TargetKey Bottleneck
6–8 GB Android / iPhone3.0–4.4 GBGemma 4 E2B (Q4_K_M)Gemma 4 E4B (8 GB flagship)OS LMK / Jetsam termination & thermals
12–16 GB Android / iPad Pro6.0–12.0 GBGemma 4 E4BGemma 4 12B (M4 16 GB iPad)Thermal throttling during long turns
8 GB Laptop / RTX 40606.5–7.0 GB VRAMGemma 4 E4BGemma 4 12B (tight 4K ctx)Exceeding 8 GB spills to PCIe RAM
16 GB Apple Silicon Mac~12.0 GB wired GPUGemma 4 E4B / 12B26B-A4B (8K ctx, calm config)Swap pressure & Metal wired cap
12–16 GB RTX (4070 / 4060 Ti)10–14 GB VRAMGemma 4 12B (Q4/Q6)26B-A4B (partial CPU offload)Narrow 128-bit/192-bit bus speed
24 GB RTX 3090 / 4090 / 32 GB Mac20–24 GBGemma 4 26B-A4B (Q4/Q6)Gemma 4 31B (Q4_K_M)Long-context KV cache at 64K+
48 GB+ Mac Studio / Dual GPU36–96 GB+Gemma 4 31B (Q8_0)70B–120B+ open modelsPrefill compute at very long context

Bandwidth math: estimating tokens per second

During interactive chat, each generated token requires streaming active model weights from VRAM or unified RAM into compute units. A reliable first-order estimate is: tok/s ≈ (Memory Bandwidth in GB/s / Active Model Footprint in GB) × backend efficiency (roughly 0.65–0.75 on CUDA/Metal).

For example, running Gemma 4 E4B Q4_K_M (~4.6 GB) on an Apple M4 Max (546 GB/s) yields around 75+ tok/s, whereas an entry Apple M1 (68 GB/s) yields roughly 10–12 tok/s—still readable, but noticeably slower if you jump up to a 15.8 GB checkpoint.

Sparse MoE models break the standard size-to-speed penalty: Gemma 4 26B-A4B occupies 15.8 GB of capacity, yet only ~4B active weights (~2.5 GB at Q4) move through memory per token, doubling or tripling generation speed compared to dense 31B models on the same GPU.

How context length and KV cache shift memory limits

Every token in your system prompt, pasted code file, screenshot patch, and conversation reply stays cached as Key and Value attention tensors. A model that uses 7.1 GB at idle can quickly cross 12–14 GB when pushed to 64K or 128K context under FP16 KV precision.

On 16 GB devices, start at 4,096 or 8,192 context tokens and enable Q8_0 KV cache quantization. Only expand to 32K–128K contexts once you verify zero swap activity in Task Manager or Activity Monitor.

  • Keep dedicated discrete GPU utilization below 85% at rest so KV cache buffers never push layers across PCIe into DDR4/DDR5 system RAM.
  • On Windows NVIDIA systems, disable or monitor Shared GPU Memory fallback: spilling just 500 MB across PCIe can drop throughput from 45 tok/s to under 4 tok/s.
  • For vision prompts on Gemma 4 12B and E4B, resize 4K screenshots to ~1024px–1536px before submission unless tiny OCR text requires native resolution.

CPU-only and system RAM offloading realities

When a model exceeds GPU VRAM, runtimes such as llama.cpp split layers between GPU VRAM and host DDR5/DDR4 system RAM. Because dual-channel DDR5 tops out around 50–80 GB/s compared to 500–1,008 GB/s on discrete GPUs, partial offloading turns dense 31B models into 2–6 tok/s batch workloads.

Sparse MoE checkpoints are the one major exception: with llama.cpp expert tensor overrides (-ot ".ffn_.*_exps.=CPU"), keeping shared attention and KV cache in 12–16 GB VRAM while streaming inactive MoE experts from fast system RAM can maintain surprisingly usable interactive speeds.

Verify exact hardware fit before downloading

  1. Open the Gemma 4 Run homepage checker and select your exact GPU, Apple Silicon Mac, or mobile SoC.
  2. Inspect the Memory % badge for Q4_K_M: target 75% or lower for long coding or RAG sessions.
  3. If your target model lands in Tight Fit (C) or Barely Runs (D), enable Q8_0 KV cache quantization or step down one checkpoint size.
  4. Run a 4K context smoke test first and monitor Task Manager VRAM or macOS Memory Pressure before scaling context.

Recommended models

Frequently asked questions

Can a 16 GB RAM laptop run Gemma 4 smoothly?
Yes. On a 16 GB Mac or Windows laptop, Gemma 4 E4B (4.6 GB) runs very comfortably with generous context headroom, and Gemma 4 12B Q4_K_M (~7.1 GB) fits well with conservative 4K–8K context. Gemma 4 26B-A4B is tight on 16 GB and requires disciplined settings.
Is 8 GB VRAM enough for Gemma 4?
An 8 GB GPU such as an RTX 4060 or RTX 3070 runs Gemma 4 E2B and E4B completely inside VRAM at high speed. Gemma 4 12B Q4_K_M (~7.1 GB) leaves almost zero margin for KV cache on 8 GB cards, so keep context short or expect partial RAM offloading.
Do I need an RTX 4090 or 24 GB GPU for Gemma 4 26B-A4B?
A 24 GB GPU (RTX 3090, RTX 4090) or 24–36 GB Apple Silicon Mac provides the cleanest single-device home for 26B-A4B Q4_K_M (~15.8 GB) because it leaves 8 GB+ for long context and flash attention.
How much disk space should I reserve for local Gemma 4 models?
Reserve at least 2x the GGUF size during download and model conversion, or roughly 5 GB for E2B/E4B setups, 10–15 GB for 12B, and 20–25 GB for 26B-A4B or 31B.
Does CPU speed matter if my model fits inside GPU VRAM?
Once weights and KV cache sit completely inside GPU VRAM, CPU clock speed barely affects generation speed. CPU core count and RAM bandwidth only dominate when layers spill off GPU or when running CPU-only inference.
Why do phone RAM numbers look misleading for local AI?
An 8 GB iPhone or Android phone dedicates 3.5 GB to 4.5 GB to the OS kernel, display framebuffers, and background services. Active app memory ceilings (Jetsam on iOS, LMK on Android) cap single-app allocations near 4.0–4.8 GB.