Short answer: Google’s official Gemma 3 12B instruction-tuned QAT Q4_0 GGUF model file is 8.07GB, so it does not fit wholly in a nominal 8GB VRAM pool before KV cache, runtime buffers or display use. The official repository also lists a separate 854MB FP16 vision projector. 12GB is the first common one-device starting tier; 16GB provides more practical room for context, images and runtime variation.
Planning now? Estimate the complete workload with the VRAM calculator, then compare the full Gemma 3 family.
Gemma 3 12B capacity verdict
| Available memory | Official QAT Q4_0 path | Practical interpretation |
|---|---|---|
| 8GB | No whole-model GPU fit | The 8.07GB model file already exceeds the nominal pool before cache and runtime allocations. |
| 12GB | First common starting tier | Leaves about 3.93GB before cache, buffers, display use and any vision allocations. |
| 16GB | More flexible Q4 tier | Adds useful working margin for context, images, batching and runtime differences. |
| 24GB | Substantial Q4 headroom | Useful for heavier workloads or adjacent higher-bit tests; spare capacity is not a speed guarantee. |
What Google publishes
The official Google repository tree lists gemma-3-12b-it-q4_0.gguf at 8.07GB and mmproj-model-f16-12B.gguf at 854MB. Google describes the release as quantization-aware trained (QAT). These are direct capacity facts for this artifact—not proof that all 12B quantizations have the same size, quality or runtime support.
Why 8GB is not a whole-model fit
The 8.07GB file is already larger than the label on an 8GB GPU. Loading also needs runtime tensors, KV cache, temporary buffers and kernels, while a display-connected GPU may have less than 8GB available. CPU or system-memory offload can make some configurations run, but that is a different performance path and should not be described as a complete GPU fit.
12GB versus 16GB
- Choose 12GB when the official QAT Q4_0 artifact is the target, context and concurrency are controlled, and you will test text and vision separately.
- Choose 16GB when you want more margin for context, image use, batching or runtime-specific allocations.
- Choose 24GB when the real workload needs materially more headroom or you want to test larger/higher-bit artifacts—not merely because the model parameter count sounds large.
Compare those tiers in the 8GB vs 12GB vs 16GB guide. For a nearby parameter-class comparison, use the 13B/14B requirements guide without treating its architecture as Gemma arithmetic.
Text-only and image-plus-text need separate tests
| Path | Account for | Representative test |
|---|---|---|
| Text-only | 8.07GB model, cache, runtime buffers and system/display use | Real prompt length, output target and concurrency |
| Image + text | Model, 854MB projector, image processing and runtime allocations | Real image count/resolution with the same output target |
128K capability is not a 12GB or 16GB promise
Google’s Gemma 3 model card documents a 128K-token context capability for the 12B model. A local runtime still has to allocate the relevant cache and buffers. Gemma 3 uses hybrid local/global attention, so a simple formula that assumes full attention across every layer is not an exact memory estimate. Cache implementation and precision, prompt length, generated tokens, images, batching and concurrency all affect the result.
A reproducible fit test
- Record the exact repository, filename, checksum and Gemma license acceptance.
- Record GPU or unified-memory capacity, OS, driver and runtime version.
- Measure available memory before loading; do not rely only on the device label.
- Load the intended GPU/offload and cache configuration.
- Test representative prompt length, output length and concurrency.
- Repeat image workloads with the official projector and representative images.
- Record peak memory, time to first token, throughput and any fallback or out-of-memory error.
- Evaluate output quality before deciding the QAT Q4_0 artifact meets the task.
Use the workload test template and share a measured result.
Continue your decision
Map model sizes · Understand quantization · Browse guides · Follow hardware
Official sources and limits
- Google Gemma 3 12B IT QAT Q4_0 GGUF file tree
- Google Gemma 3 model card
- Google Gemma documentation
- HighVRAM methodology
Reviewed October 25, 2026. File sizes are the repository display values on that date. HighVRAM has not independently benchmarked every tier or runtime. File size does not equal peak VRAM, and fit does not establish speed or output quality.