- Page updated
- Sources checked
- GGUF sizes and embedding tensors checked October 12, 2026 (E2B/E4B October 19)
- Capacity estimates, labeled
- Jump to the checker ↓
Gemma 4 is Google's family of open-weight models with image input and a 262K context, released under Apache 2.0. This page covers all five sizes for PCs and Macs: the small E2B and E4B (2.3B and 4.5B effective parameters, 5.1B and 8B with their per-layer embeddings, and a 131,072-token context; gemma4:latest on Ollama is the E4B), the dense 12B, the mixture-of-experts 26B-A4B (26B parameters, about 4B active per token) and the dense 31B.
Short answer: at a 32K context with llama.cpp (RigCheck estimates), Gemma 4 E4B at 8-bit (Q8_0) fits an 8 GB card with about 4.2 GB of it in system RAM (its 3.7 GB of embedding tables and 0.5 GB of host buffers), and a 16 GB Mac holds its Q4_K_M; E2B fits either at 8-bit or more. Gemma 4 12B at 4-bit (UD-Q4_K_XL) needs about 11 GB, fitting a 12 GB card; an 8 GB card holds the 3-bit UD-IQ3_XXS. 26B-A4B at 4-bit (UD-Q4_K_XL) needs about 21 GB and 31B about 23 GB with IQ4_XS (16.4 GB): both fit 24 GB cards (RTX 3090/4090, RX 7900 XTX) or 32 GB Macs, while the 31B's Q4_K_M fits 32 GB cards or 48 GB Macs but exceeds a 32 GB Mac's 24 GB usable budget. 16 GB cards take their 3-bit or 2-bit files.
Can my hardware run Gemma 4? #
private checker…
RigCheck allocation estimate. Input embeddings stay in system RAM even when all decoder layers fit on the GPU. For E2B and E4B that includes the per-layer embedding table (llama.cpp places it on the CPU like the token embeddings): 1.3–4.7 GB and 1.6–5.6 GB depending on the file, 35–58% of each file's size. We count it in RAM in full; llama.cpp's default --lazy-mode auto reads a table larger than 4 GiB (the BF16 files only) from disk on demand instead. Their per-format sizes and the output tensor come from pinned GGUF headers (read October 12, 2026). We add a RigCheck allowance of 0.5 GB for host runtime/staging buffers, separate from the 8 GB OS reserve. Remaining decoder weights are approximated evenly across layers; output weights sit on the last GPU, compute buffers and the vision file on the first. Commands disable automatic fitting with --fit off and pin decoder layers plus the output layer with -ngl, using --tensor-split for multiple cards. Actual tensor placement and buffer peaks can still differ; confirm runtime allocation before filling memory. When tied input/output weights cross CPU and GPU buffer types, the estimate also reserves an output copy; unified-memory estimates keep this conservative allowance, though a backend may reuse mapped storage. CPU-only runs do not add that copy.
- Developer
- Google Official
- Params · Gemma 4 12B
- the dense 12B Official
- Params · Gemma 4 26B-A4B
- 26B parameters, about 4B active per token Official
- Params · Gemma 4 31B
- the dense 31B Official
- Context
- 131,072 tokens for E2B and E4B, 262,144 for the others Official
- Input · Gemma 4 12B
- text, image, audio Official
- License
- Apache 2.0 Official
- Ollama
- Ollama has gemma4 packages Official
- llama.cpp
- llama.cpp supports the architecture, Unsloth publishes GGUF files Unsloth
How much VRAM does Gemma 4 need? #
Unsloth's GGUF files as Hugging Face lists them (decimal GB, read October 9, 2026), and the total memory each needs at a 32K context with an f16 KV cache and no image input (RigCheck estimate). Official BF16 weights: 10.2 GB (E2B), 16.0 GB (E4B), 23.9 GB (12B), 51.6 GB (26B-A4B), 62.5 GB (31B).
Gemma 4 31B
| File | File size | Needs at 32K | Source |
|---|---|---|---|
| BF16 | 61.4 GB | 70.2 GB | Unsloth |
| Q8_0 | 32.6 GB | 40.0 GB | Unsloth |
| Q6_K | 25.2 GB | 32.3 GB | Unsloth |
| Q5_K_M | 21.7 GB | 28.6 GB | Unsloth |
| UD-Q4_K_XL | 18.8 GB | 25.7 GB | Unsloth |
| Q4_K_M | 18.3 GB | 25.0 GB | Unsloth |
| IQ4_XS | 16.4 GB | 23.1 GB | Unsloth |
| Q3_K_M | 14.7 GB | 21.2 GB | Unsloth |
| UD-IQ3_XXS | 11.8 GB | 18.3 GB | Unsloth |
| UD-IQ2_XXS | 8.5 GB | 15.0 GB | Unsloth |
Gemma 4 26B-A4B
| File | File size | Needs at 32K | Source |
|---|---|---|---|
| BF16 | 50.5 GB | 55.0 GB | Unsloth |
| Q8_0 | 26.9 GB | 30.7 GB | Unsloth |
| UD-Q6_K_XL | 23.3 GB | 27.1 GB | Unsloth |
| UD-Q5_K_XL | 21.2 GB | 25.0 GB | Unsloth |
| UD-Q4_K_XL | 17.0 GB | 20.8 GB | Unsloth |
| MXFP4_MOE | 16.6 GB | 20.4 GB | Unsloth |
| UD-IQ4_XS | 13.6 GB | 17.4 GB | Unsloth |
| UD-Q3_K_XL | 12.9 GB | 16.7 GB | Unsloth |
| UD-IQ3_XXS | 11.4 GB | 15.0 GB | Unsloth |
| UD-IQ2_XXS | 9.9 GB | 13.3 GB | Unsloth |
Gemma 4 12B
| File | File size | Needs at 32K | Source |
|---|---|---|---|
| BF16 | 23.8 GB | 28.9 GB | Unsloth |
| Q8_0 | 12.7 GB | 16.8 GB | Unsloth |
| Q6_K | 9.8 GB | 13.7 GB | Unsloth |
| Q5_K_M | 8.4 GB | 12.1 GB | Unsloth |
| UD-Q4_K_XL | 7.4 GB | 11.1 GB | Unsloth |
| Q4_K_M | 7.1 GB | 10.7 GB | Unsloth |
| IQ4_XS | 6.4 GB | 10.0 GB | Unsloth |
| Q3_K_M | 5.7 GB | 9.2 GB | Unsloth |
| UD-IQ3_XXS | 4.6 GB | 8.1 GB | Unsloth |
| UD-IQ2_M | 4.2 GB | 7.7 GB | Unsloth |
Gemma 4 E4B
| File | File size | Needs at 32K | Source |
|---|---|---|---|
| BF16 | 15.1 GB | 19.0 GB | Unsloth |
| Q8_0 | 8.2 GB | 11.5 GB | Unsloth |
| Q6_K | 7.1 GB | 10.2 GB | Unsloth |
| Q5_K_M | 5.5 GB | 8.5 GB | Unsloth |
| UD-Q4_K_XL | 5.1 GB | 8.1 GB | Unsloth |
| Q4_K_M | 5.0 GB | 8.0 GB | Unsloth |
| IQ4_XS | 4.7 GB | 7.7 GB | Unsloth |
| Q3_K_M | 4.1 GB | 7.0 GB | Unsloth |
| UD-IQ3_XXS | 3.7 GB | 6.6 GB | Unsloth |
| UD-IQ2_M | 3.5 GB | 6.4 GB | Unsloth |
Gemma 4 E2B
| File | File size | Needs at 32K | Source |
|---|---|---|---|
| BF16 | 9.3 GB | 12.3 GB | Unsloth |
| Q8_0 | 5.0 GB | 7.6 GB | Unsloth |
| Q6_K | 4.5 GB | 7.0 GB | Unsloth |
| Q5_K_M | 3.4 GB | 5.9 GB | Unsloth |
| UD-Q4_K_XL | 3.2 GB | 5.7 GB | Unsloth |
| Q4_K_M | 3.1 GB | 5.5 GB | Unsloth |
| IQ4_XS | 3.0 GB | 5.4 GB | Unsloth |
| Q3_K_M | 2.5 GB | 4.9 GB | Unsloth |
| UD-IQ3_XXS | 2.4 GB | 4.8 GB | Unsloth |
| UD-IQ2_M | 2.3 GB | 4.7 GB | Unsloth |
Unsloth's table gives recommended total memory (RAM + VRAM, or unified memory) for 4-bit, 8-bit and BF16: 4, 5–8 and 10 GB for E2B; 5.5–6, 9–12 and 16 GB for E4B; 7–8, 13–14 and 25 GB for 12B; 16–18, 28–30 and 52 GB for 26B-A4B; 17–20, 34–38 and 62 GB for 31B, and says llama.cpp still runs below that with RAM or disk offload, more slowly. Ollama's default packages, as its tags page lists them: gemma4:e2b 4.6–7.5 GB, gemma4:e4b (also gemma4:latest) 6.6–9.5 GB, gemma4:12b 7.7–8.0 GB, gemma4:26b 16–19 GB, gemma4:31b 19–20 GB.
What hardware can run Gemma 4? #
RigCheck estimate at a 32K context with an f16 KV cache and no image input, from the file sizes above and the assumptions under the checker. "Largest" means the largest of the checker's ten files for that model.
Gemma 4 31B
| Hardware | Largest file that fits fully | With layers in system RAM (slower) |
|---|---|---|
| No GPU + 32 GB RAM | IQ4_XS (all in RAM, CPU only) | no larger file |
| RTX 4060 (8 GB) + 32 GB RAM | none | Q5_K_M (49 of 60 layers, 22 GB in RAM) |
| RTX 3060 (12 GB) + 32 GB RAM | none | Q6_K (43 of 60 layers, 22 GB in RAM) |
| RTX 5060 Ti (16 GB) + 32 GB RAM | UD-IQ2_XXS | Q6_K (35 of 60 layers, 18 GB in RAM) |
| RX 9070 XT (16 GB) + 32 GB RAM | UD-IQ2_XXS | Q6_K (35 of 60 layers, 18 GB in RAM) |
| RTX 4090 (24 GB) + 32 GB RAM | IQ4_XS | Q8_0 (28 of 60 layers, 18 GB in RAM) |
| RTX 5090 (32 GB) + 32 GB RAM | Q5_K_M | Q8_0 (15 of 60 layers, 11 GB in RAM) |
| Mac, 16 GB unified | none | not applicable (unified memory) |
| Mac, 24 GB unified | UD-IQ2_XXS | not applicable (unified memory) |
| Mac, 32 GB unified | IQ4_XS | not applicable (unified memory) |
Gemma 4 26B-A4B
| Hardware | Largest file that fits fully | With layers in system RAM (slower) |
|---|---|---|
| No GPU + 32 GB RAM | UD-Q4_K_XL (all in RAM, CPU only) | no larger file |
| RTX 4060 (8 GB) + 32 GB RAM | none | Q8_0 (25 of 30 layers, 24 GB in RAM) |
| RTX 3060 (12 GB) + 32 GB RAM | none | Q8_0 (21 of 30 layers, 20 GB in RAM) |
| RTX 5060 Ti (16 GB) + 32 GB RAM | UD-IQ3_XXS | Q8_0 (17 of 30 layers, 17 GB in RAM) |
| RX 9070 XT (16 GB) + 32 GB RAM | UD-IQ3_XXS | Q8_0 (17 of 30 layers, 17 GB in RAM) |
| RTX 4090 (24 GB) + 32 GB RAM | UD-Q4_K_XL | Q8_0 (9 of 30 layers, 9 GB in RAM) |
| RTX 5090 (32 GB) + 32 GB RAM | Q8_0 | no larger file |
| Mac, 16 GB unified | none | not applicable (unified memory) |
| Mac, 24 GB unified | UD-IQ3_XXS | not applicable (unified memory) |
| Mac, 32 GB unified | UD-Q4_K_XL | not applicable (unified memory) |
Gemma 4 12B
| Hardware | Largest file that fits fully | With layers in system RAM (slower) |
|---|---|---|
| No GPU + 32 GB RAM | Q8_0 (all in RAM, CPU only) | no larger file |
| RTX 4060 (8 GB) + 32 GB RAM | UD-IQ3_XXS | BF16 (40 of 48 layers, 21 GB in RAM) |
| RTX 3060 (12 GB) + 32 GB RAM | Q5_K_M | BF16 (33 of 48 layers, 18 GB in RAM) |
| RTX 5060 Ti (16 GB) + 32 GB RAM | Q6_K | BF16 (25 of 48 layers, 14 GB in RAM) |
| RX 9070 XT (16 GB) + 32 GB RAM | Q6_K | BF16 (25 of 48 layers, 14 GB in RAM) |
| RTX 4090 (24 GB) + 32 GB RAM | Q8_0 | BF16 (10 of 48 layers, 7 GB in RAM) |
| RTX 5090 (32 GB) + 32 GB RAM | BF16 | no larger file |
| Mac, 16 GB unified | UD-IQ2_M | not applicable (unified memory) |
| Mac, 24 GB unified | Q6_K | not applicable (unified memory) |
| Mac, 32 GB unified | Q8_0 | not applicable (unified memory) |
Gemma 4 E4B
| Hardware | Largest file that fits fully | With layers in system RAM (slower) |
|---|---|---|
| No GPU + 32 GB RAM | BF16 (all in RAM, CPU only) | no larger file |
| RTX 4060 (8 GB) + 32 GB RAM | Q8_0 | BF16 (20 of 42 layers, 12 GB in RAM) |
| RTX 3060 (12 GB) + 32 GB RAM | Q8_0 | BF16 (3 of 42 layers, 8 GB in RAM) |
| RTX 5060 Ti (16 GB) + 32 GB RAM | BF16 | no larger file |
| RX 9070 XT (16 GB) + 32 GB RAM | BF16 | no larger file |
| RTX 4090 (24 GB) + 32 GB RAM | BF16 | no larger file |
| RTX 5090 (32 GB) + 32 GB RAM | BF16 | no larger file |
| Mac, 16 GB unified | Q4_K_M | not applicable (unified memory) |
| Mac, 24 GB unified | Q8_0 | not applicable (unified memory) |
| Mac, 32 GB unified | BF16 | not applicable (unified memory) |
Gemma 4 E2B
| Hardware | Largest file that fits fully | With layers in system RAM (slower) |
|---|---|---|
| No GPU + 32 GB RAM | BF16 (all in RAM, CPU only) | no larger file |
| RTX 4060 (8 GB) + 32 GB RAM | BF16 | no larger file |
| RTX 3060 (12 GB) + 32 GB RAM | BF16 | no larger file |
| RTX 5060 Ti (16 GB) + 32 GB RAM | BF16 | no larger file |
| RX 9070 XT (16 GB) + 32 GB RAM | BF16 | no larger file |
| RTX 4090 (24 GB) + 32 GB RAM | BF16 | no larger file |
| RTX 5090 (32 GB) + 32 GB RAM | BF16 | no larger file |
| Mac, 16 GB unified | Q8_0 | not applicable (unified memory) |
| Mac, 24 GB unified | BF16 | not applicable (unified memory) |
| Mac, 32 GB unified | BF16 | not applicable (unified memory) |
Capacity only, not tested setups. With layers in system RAM, any of them runs slower; we found no published speeds to say how much slower for each.
Gemma 4 on a Jetson Orin Nano #
NVIDIA NVIDIA's Jetson AI Lab tutorial "Gemma 4 on Jetson" says that so far E2B is the one that fits best on the Orin Nano, and runs it with llama.cpp: the Q4_K_S file (3.0 GB) in NVIDIA's llama_cpp:latest-jetson-orin container, on JetPack 6 (L4T r36.x). For this board RigCheck quotes that route instead of estimating capacity: its 8 GB of unified memory is shared with the operating system, and we found no source for that reserve precise enough to decide a fit.
sudo docker run -it --rm --pull always --runtime=nvidia --network host \
-v $HOME/.cache/huggingface:/root/.cache/huggingface \
ghcr.io/nvidia-ai-iot/llama_cpp:latest-jetson-orin \
llama-server -hf unsloth/gemma-4-E2B-it-GGUF:Q4_K_S
| Jetson | Gemma 4 sizes NVIDIA names | Source |
|---|---|---|
| Orin Nano (8 GB) | E2B | NVIDIA |
| Orin NX | E2B, E4B | NVIDIA |
| AGX Orin | the full family | NVIDIA |
| Jetson Thor | the full family | NVIDIA |
"Full family" in that tutorial means E2B, E4B, 26B-A4B and 31B; it does not cover the 12B. It also says Ollama does not run Gemma 4 on the Orin Nano yet, that E2B audio currently has an issue under llama.cpp (use vLLM for audio on the bigger Jetsons), and recommends an NVMe SSD for downloads; NVIDIA's RAM optimization guide notes that turning off the desktop frees about 800 MB. The Orin Nano Super's memory is 8 GB of 128-bit LPDDR5 at 102 GB/s in its MAXN SUPER mode (NVIDIA). These are NVIDIA's published routes, not RigCheck estimates or tested setups.
Measured Gemma 4 on your own hardware, or tried and it failed? Send us the numbers: paste the benchmark output or log into the form (or email it). After checking it we add it to this page, labeled as a community report and shared under CC BY 4.0.
Gemma 4 specs #
| E2B | E4B | 12B | 26B-A4B | 31B | |
|---|---|---|---|---|---|
| Type | dense, per-layer embeddings | dense, per-layer embeddings | dense | mixture of experts: 128 experts, 8 per token | dense |
| Layers | 35 (28 + 7; the last 20 reuse earlier KV caches) | 42 (35 + 7; the last 18 reuse earlier KV caches) | 48 (40 sliding-window, 8 full attention) | 30 (25 + 5) | 60 (50 + 10) |
| KV cache at 32K, f16 | 0.2 GB | 0.6 GB | 1.0 GB | 1.0 GB | 3.9 GB |
| Input | text, image, audio | text, image, audio | text, image, audio | text, image | text, image |
Layers, experts and inputs from Google's config.json files; KV cache is a RigCheck calculation. Context: 131,072 tokens for E2B and E4B, 262,144 for the others; all Apache 2.0. Runtimes: llama.cpp supports the architecture, Unsloth publishes GGUF files and Ollama has gemma4 packages (checked October 9, 2026).
RigCheck Lab measurements #
RigCheck measurement RigCheck Lab measured Gemma 4 26B-A4B itself, with llama.cpp's llama-bench on rented cloud machines with one graphics card each (2026-10-21): all layers on the GPU, flash attention, an f16 KV cache. Each row is one model file at one context on one card, run as separate processes (3 per row); the numbers are the lowest and highest of those runs' averages. They hold only for that file, context, card, host and llama.cpp build: no other setup is shown here.
| RigCheck Lab, Gemma 4 26B-A4B: tokens per second and peak GPU memory, by card, file and context | |||||||
|---|---|---|---|---|---|---|---|
| Graphics card | Model | File | Context | Prompt processing (tok/s) | Generation (tok/s) | Peak GPU memory (GB) | Runs |
| --- | --- | --- | --- | --- | --- | --- | --- |
| RTX 4060 Ti 16 GB | Gemma 4 26B-A4B | UD-IQ3_XXS | about 4K | 2,907–2,915 | 76.5 | 12.6 | 3 of 3 ran |
| RTX 4060 Ti 16 GB | Gemma 4 26B-A4B | UD-IQ3_XXS | about 32K | 1,558–1,562 | 65.2–65.3 | 13.2 | 3 of 3 ran |
| RTX 4090 | Gemma 4 26B-A4B | UD-Q4_K_XL | about 4K | 8,850–8,922 | 163.0–163.3 | 18.5 | 3 of 3 ran |
| RTX 4090 | Gemma 4 26B-A4B | UD-Q4_K_XL | about 32K | 6,231–6,233 | 142.6–146.3 | 19.1 | 3 of 3 ran |
Context: prompt processing times 512 tokens after 3,584 (about 4K) or 32,256 (about 32K) untimed tokens; generation times 128 tokens after the same untimed tokens. Each run repeats its test 3 times, and those single samples vary more than the averages shown (their standard deviations are in the data). Peak GPU memory is the whole card's memory in use as nvidia-smi reports it (MiB, converted to GB), read about every 200 ms, so short spikes can be missed. Hosts: Host 1, RTX 4060 Ti 16 GB, 2026-10-21: Vast.ai machine 39330, 165 W power limit, PCIe 3.0 ×8, Intel(R) Core(TM) i5-8500 CPU @ 3.00GHz with 6 CPU cores and 33.5 GB of RAM allocated, driver 580.173.02, llama.cpp build 11783 (CUDA). Host 2, RTX 4090, 2026-10-21: Vast.ai machine 47598, 400 W power limit (the card ships at 450 W), PCIe 4.0 ×16, AMD EPYC 7402 24-Core Processor with 12 CPU cores and 67.5 GB of RAM allocated, driver 580.142, llama.cpp build 11783 (CUDA). Every run, with its command, file checksum, samples and correction history, is in lab.json (CC BY 4.0); how runs are made and corrected: RigCheck Lab method.
Common setups #
The checker's own answer for 8 common setups (graphics cards with 32 or 64 GB of system RAM, then Macs), in the finder's quick mode (graphics cards: llama.cpp on one graphics card, a 32K context, no image input; Macs: llama.cpp in unified memory, a 32K context, no image input). Answers are capacity estimates, not measured setups; "Unknown" means the checker has no route or source for that hardware. Your own setup: the checker.
| Gemma 4: answers by setup | |||||
|---|---|---|---|---|---|
| Setup | Gemma 4 E2B | Gemma 4 E4B | Gemma 4 12B | Gemma 4 26B-A4B | Gemma 4 31B |
| --- | --- | --- | --- | --- | --- |
| GeForce RTX 3060 (12 GB) + 32 GB RAM | ✓ Fits: BF16, GPU memory (input embeddings in system RAM) (capacity estimate) | ✓ Fits: Q8_0, GPU memory (input embeddings in system RAM) (capacity estimate) | ✓ Fits: Q5_K_M, GPU memory (input embeddings in system RAM) (capacity estimate) | ! Fits with caveats: Q8_0, GPU and system RAM (9 of 30 layers on the GPU) (capacity estimate) | ! Fits with caveats: Q6_K, GPU and system RAM (17 of 60 layers on the GPU) (capacity estimate) |
| GeForce RTX 4060 Ti (16 GB) + 32 GB RAM | ✓ Fits: BF16, GPU memory (input embeddings in system RAM) (capacity estimate) | ✓ Fits: BF16, GPU memory (input embeddings in system RAM) (capacity estimate) | ✓ Fits: Q6_K, GPU memory (input embeddings in system RAM) (capacity estimate) | ✓ Fits: UD-IQ3_XXS, GPU memory (input embeddings in system RAM) (capacity estimate) | ✓ Fits: UD-IQ2_XXS, GPU memory (input embeddings in system RAM) (capacity estimate) |
| GeForce RTX 3090 / 3090 Ti (24 GB) + 64 GB RAM | ✓ Fits: BF16, GPU memory (input embeddings in system RAM) (capacity estimate) | ✓ Fits: BF16, GPU memory (input embeddings in system RAM) (capacity estimate) | ✓ Fits: Q8_0, GPU memory (input embeddings in system RAM) (capacity estimate) | ✓ Fits: UD-Q4_K_XL, GPU memory (input embeddings in system RAM) (capacity estimate) | ✓ Fits: IQ4_XS, GPU memory (input embeddings in system RAM) (capacity estimate) |
| GeForce RTX 5090 (32 GB) + 64 GB RAM | ✓ Fits: BF16, GPU memory (input embeddings in system RAM) (capacity estimate) | ✓ Fits: BF16, GPU memory (input embeddings in system RAM) (capacity estimate) | ✓ Fits: BF16, GPU memory (input embeddings in system RAM) (capacity estimate) | ✓ Fits: Q8_0, GPU memory (input embeddings in system RAM) (capacity estimate) | ✓ Fits: Q5_K_M, GPU memory (input embeddings in system RAM) (capacity estimate) |
| Apple Silicon Mac (64 GB unified) | ✓ Fits: BF16, unified memory (after raising the Mac's GPU wired-memory limit) (capacity estimate) | ✓ Fits: BF16, unified memory (after raising the Mac's GPU wired-memory limit) (capacity estimate) | ✓ Fits: BF16, unified memory (after raising the Mac's GPU wired-memory limit) (capacity estimate) | ✓ Fits: BF16, unified memory (after raising the Mac's GPU wired-memory limit) (capacity estimate) | ✓ Fits: Q8_0, unified memory (after raising the Mac's GPU wired-memory limit) (capacity estimate) |
| Mac with M5 Max, 40-core GPU (128 GB unified) | ✓ Fits: BF16, unified memory (after raising the Mac's GPU wired-memory limit) (capacity estimate) | ✓ Fits: BF16, unified memory (after raising the Mac's GPU wired-memory limit) (capacity estimate) | ✓ Fits: BF16, unified memory (after raising the Mac's GPU wired-memory limit) (capacity estimate) | ✓ Fits: BF16, unified memory (after raising the Mac's GPU wired-memory limit) (capacity estimate) | ✓ Fits: BF16, unified memory (after raising the Mac's GPU wired-memory limit) (capacity estimate) |
| Mac Studio M3 Ultra (256 GB unified) | ✓ Fits: BF16, unified memory (after raising the Mac's GPU wired-memory limit) (capacity estimate) | ✓ Fits: BF16, unified memory (after raising the Mac's GPU wired-memory limit) (capacity estimate) | ✓ Fits: BF16, unified memory (after raising the Mac's GPU wired-memory limit) (capacity estimate) | ✓ Fits: BF16, unified memory (after raising the Mac's GPU wired-memory limit) (capacity estimate) | ✓ Fits: BF16, unified memory (after raising the Mac's GPU wired-memory limit) (capacity estimate) |
| Mac Studio M3 Ultra (512 GB unified) | – Unknown This checker covers the graphics cards and machines in its list. | – Unknown This checker covers the graphics cards and machines in its list. | – Unknown This checker covers the graphics cards and machines in its list. | – Unknown This checker covers the graphics cards and machines in its list. | – Unknown This checker covers the graphics cards and machines in its list. |
Machine-readable: the same answers as JSON (CC BY 4.0, attribution "RigCheck").
Related hardware #
Graphics card and Mac pages where this page's checker gives an answer, smallest memory first: graphics cards with 64 GB of system RAM, Macs with their unified memory, in the finder's quick mode (capacity estimate; each page lists every model).
- RTX 3060 12 GB : Gemma 4 E2B: fits: BF16, GPU memory (input embeddings in system RAM); Gemma 4 E4B: fits: Q8_0, GPU memory (input embeddings in system RAM); Gemma 4 12B: fits: Q5_K_M, GPU memory (input embeddings in system RAM); Gemma 4 26B-A4B: fits with caveats: BF16, GPU and system RAM (4 of 30 layers on the GPU); Gemma 4 31B: fits with caveats: Q8_0, GPU and system RAM (13 of 60 layers on the GPU)
- RTX 4070 Ti : Gemma 4 E2B: fits: BF16, GPU memory (input embeddings in system RAM); Gemma 4 E4B: fits: Q8_0, GPU memory (input embeddings in system RAM); Gemma 4 12B: fits: Q5_K_M, GPU memory (input embeddings in system RAM); Gemma 4 26B-A4B: fits with caveats: BF16, GPU and system RAM (4 of 30 layers on the GPU); Gemma 4 31B: fits with caveats: Q8_0, GPU and system RAM (13 of 60 layers on the GPU)
- RTX 4060 Ti 16 GB : Gemma 4 E2B: fits: BF16, GPU memory (input embeddings in system RAM); Gemma 4 E4B: fits: BF16, GPU memory (input embeddings in system RAM); Gemma 4 12B: fits: Q6_K, GPU memory (input embeddings in system RAM); Gemma 4 26B-A4B: fits: UD-IQ3_XXS, GPU memory (input embeddings in system RAM); Gemma 4 31B: fits: UD-IQ2_XXS, GPU memory (input embeddings in system RAM)
- Radeon VII / Instinct MI50 16 GB : Gemma 4 E2B: fits with caveats: BF16, system RAM, CPU only; Gemma 4 E4B: fits with caveats: BF16, system RAM, CPU only; Gemma 4 12B: fits with caveats: BF16, system RAM, CPU only; Gemma 4 26B-A4B: fits with caveats: BF16, system RAM, CPU only; Gemma 4 31B: fits with caveats: Q8_0, system RAM, CPU only
- Mac with 24 GB : Gemma 4 E2B: fits: BF16, unified memory (after raising the Mac's GPU wired-memory limit); Gemma 4 E4B: fits: Q8_0, unified memory (after raising the Mac's GPU wired-memory limit); Gemma 4 12B: fits: Q6_K, unified memory (after raising the Mac's GPU wired-memory limit); Gemma 4 26B-A4B: fits: UD-IQ3_XXS, unified memory (after raising the Mac's GPU wired-memory limit); Gemma 4 31B: fits: UD-IQ2_XXS, unified memory (after raising the Mac's GPU wired-memory limit)
- RTX 3090 : Gemma 4 E2B: fits: BF16, GPU memory (input embeddings in system RAM); Gemma 4 E4B: fits: BF16, GPU memory (input embeddings in system RAM); Gemma 4 12B: fits: Q8_0, GPU memory (input embeddings in system RAM); Gemma 4 26B-A4B: fits: UD-Q4_K_XL, GPU memory (input embeddings in system RAM); Gemma 4 31B: fits: IQ4_XS, GPU memory (input embeddings in system RAM)
All graphics cards · All Macs · Any other machine
FAQ #
Which Gemma 4 model should I run on my GPU? #
By our estimate at a 32K context: on an 8 GB card the E4B at 8-bit or the 12B at 3-bit; on a 12 GB card the 12B at up to 5-bit; on a 16 GB card the 12B at 6-bit, or the 26B-A4B and 31B at 2–3 bits; on a 24 GB card the 26B-A4B or 31B at 4-bit. Which of those suits you best depends on the task; this page only answers what fits.
How much memory do Gemma 4 E2B and E4B need? #
Less VRAM than their file sizes suggest: the per-layer embedding table, which llama.cpp keeps in system RAM, is 35–58% of each file. By our estimate at a 32K context, E4B at 8-bit (Q8_0, 8.2 GB file) needs about 11.5 GB in total, of which about 4.2 GB sits in system RAM (3.7 GB of embedding tables, 0.5 GB of host buffers; the 8 GB OS reserve comes on top), so it fits an 8 GB card; its 4-bit UD-Q4_K_XL needs about 8.1 GB. E2B at 8-bit needs about 7.6 GB. A 16 GB Mac (8 GB usable under our reserve) holds E4B Q4_K_M or E2B Q8_0. Unsloth recommends 5.5–6 GB of total memory for E4B at 4-bit and 4 GB for E2B. The longest context is 131,072 tokens.
How much VRAM does Gemma 4 26B-A4B need? #
About 21 GB at a 32K context for the 4-bit UD-Q4_K_XL (17.0 GB file), by our estimate, so a 24 GB card holds it. A 16 GB card holds UD-IQ3_XXS (11.4 GB) fully, or the 4-bit file with part of it in system RAM. Unsloth recommends 16–18 GB of total memory for 4-bit.
How much VRAM does Gemma 4 31B need? #
About 25 GB at a 32K context for the 4-bit Q4_K_M (18.3 GB), so on a 24 GB card the slightly smaller IQ4_XS (16.4 GB) is the largest that fits fully; a 32 GB card holds Q5_K_M. Unsloth recommends 17–20 GB of total memory for 4-bit.
Can Gemma 4 run on a Mac? #
Yes. By our conservative estimate a Mac with 16 GB holds the E4B at 4-bit, the E2B at 8-bit or the 12B at 2-bit, 24 GB the 12B at 6-bit or the 26B-A4B at 3-bit, and 32 GB the 26B-A4B at UD-Q4_K_XL or the 31B at IQ4_XS, at a 32K context. The 31B Q4_K_M fits a 48 GB Mac under these reserves. Use llama.cpp (Metal) or Ollama, which also lists MLX builds.
Can Gemma 4 run on a Jetson Orin Nano? #
The E2B, by NVIDIA's own Jetson AI Lab tutorial: it names E2B as the best fit on the Orin Nano and runs the Q4_K_S file with llama.cpp in NVIDIA's Jetson container on JetPack 6. For E4B NVIDIA points to the Orin NX, and for the 26B-A4B and 31B to the AGX Orin or Thor. Ollama does not run Gemma 4 on the Orin Nano yet. This is NVIDIA's route, not a RigCheck capacity estimate.
Can I run Gemma 4 without a GPU? #
Yes, with llama.cpp's CPU build: by our estimate 32 GB of RAM holds the E2B and E4B at BF16, the 12B at 8-bit, the 26B-A4B at 4-bit or the 31B at 4-bit at a 32K context. The 26B-A4B has about 4B parameters active per token, the E2B and E4B 2.3B and 4.5B effective; we found no published CPU speed for any of them, so this page does not rank them for CPU use.
Is Gemma 4 on Ollama? #
Yes: ollama run gemma4 pulls the E4B (6.6–9.5 GB); gemma4:e2b (4.6–7.5 GB), gemma4:12b (7.7–8.0 GB), gemma4:26b (16–19 GB) and gemma4:31b (19–20 GB), sizes as its tags page lists them, plus q8_0, bf16, QAT and MLX variants (checked October 9, 2026; E2B and E4B October 19).
Sources #
- Hugging Face: google/gemma-4-E2B-it ,google/gemma-4-E4B-it ,google/gemma-4-12B-it ,google/gemma-4-26B-A4B-it ,google/gemma-4-31B-it (config.json, license, file sizes)
- Unsloth GGUF: E2B ,E4B ,12B ,26B-A4B ,31B , andUnsloth's Gemma 4 guide (memory table, llama.cpp commands)
- Ollama library: gemma4 tags andOllama's GPU support list (checked October 9, 2026)
- llama.cpp: src/models/gemma4.cpp ,src/llama-kv-cache-iswa.cpp (sliding-window cache size) andtools/server/README.md
- NVIDIA Jetson AI Lab: Gemma 4 on Jetson (which sizes fit which Jetson, the Orin Nano llama.cpp command, Ollama and audio notes) andRAM optimization ;Jetson Orin Nano Super Developer Kit (memory) and NVIDIA'sSuper upgrade post (read October 19, 2026)
- Usable-memory reserves, buffers and the offload model are RigCheck assumptions, stated under the checker.
- llama.cpp input, decoder and output device assignment ,tied tensor duplication andautomatic fit allocation (read October 12, 2026). Per-format input/output tensor sizes were read from the linked GGUF files.
- llama.cpp for E2B and E4B (read October 19, 2026): src/llama-hparams.cpp (layers without their own KV cache),src/llama-arch.cpp (the per-layer embedding table is an input tensor) andsrc/llama-model-.cpp (lazy reading of tables above 4 GiB). Per-file token and per-layer embedding sizes from the GGUF headers.