The Gemma 4 Local Hardware Matcher is a browser-based tool that auto-detects your GPU, VRAM, and OS to recommend the optimal Gemma 4 model tier and generate a ready-to-run command for local inference — no installation or data upload required.
What is the Gemma 4 Local Hardware Matcher?
It is a web tool that reads your system's GPU and memory using browser-native WebGPU and WebGL APIs (no server communication), then cross-references your hardware against Gemma 4’s model tiers — from the 5B-parameter E2B for phones to the 31B Dense for workstations. It outputs a personalized recommendation including the best model, quantization level, expected speed in tokens per second, and a copy-paste terminal command for Ollama, llama.cpp, or Transformers. The tool is provided by GemmaMatch and runs entirely in your browser.
Key Features
- Automatic GPU detection — Identifies your exact GPU model (e.g., RTX 4060, Apple M1 Pro) and VRAM using WebGPU or WebGL; on Mac it also reads unified memory size. No data leaves your browser.
- Personalized model tier recommendation — Matches your hardware to the largest runnable Gemma 4 model (E2B, E4B, 26B MoE, or 31B Dense) with a specific quantization (e.g., Q4_K_M, Q2_K) and a speed estimate.
- Ready-to-use run commands — Generates pre-filled terminal commands for Ollama (
ollama run gemma4:26b), llama.cpp, or Hugging Face Transformers, including context-length flags and parallelism settings.
- Manual mode for planning — Lets you set OS, RAM, and VRAM by hand to compare upgrade scenarios or correct detection errors (e.g., dual-GPU laptops reporting integrated GPU).
- Platform-specific setup guides — Links to dedicated guides for Mac (Apple Silicon), iOS/Android (via AI Edge Gallery on Android or App Store), and Windows (NVIDIA/AMD via Ollama or LM Studio).
- Supports multiple runtimes — Commands for Ollama (GGUF), LM Studio (GGUF/EXL2), llama.cpp (GGUF), ExLlamaV2 (EXL2, NVIDIA-only), and MLX (Apple Silicon, with known MoE bugs).
- Quantization comparison table — Shows bits, VRAM usage, quality level, and fit status for 7 quantization levels of the 26B MoE model, from Q2_K (12 GB) to F16 (55.8 GB).
- Privacy-first design — All detection and computation happens locally; no analytics, cookies, or tracking. Works offline after page load.
Who is it for?
- AI enthusiasts with consumer GPUs — Users with RTX 4060 (8 GB) or MacBook M1/M2 (8 GB) get recommendations for E4B (9B dense) at 20–35 t/s, avoiding the trial-and-error of picking the wrong model.
- Developers setting up local LLM workflows — Copy a ready-to-run Ollama command for the 26B MoE (RTX 4070 Ti 16 GB) or 31B Dense (RTX 4090 24 GB) with correct quantization and context flags like
--ctx-size 4096 to prevent OOM.
- Mobile users wanting offline AI — iPhone 15 Pro or Android flagship users get linked to AI Edge Gallery for one-tap install of the E2B model, with a note that E4B requires 10+ GB RAM.
- Hardware shoppers comparing upgrades — Switch to manual mode to test how different RAM/VRAM combinations (e.g., 16 GB vs 32 GB) unlock larger model tiers before buying.
What can you do with it?
- Instantly get a personalized Gemma 4 setup — Load the page, let it detect your hardware, and receive a recommendation with a copy-paste command. For example, on a MacBook Pro 16 GB M1 Pro, you get "26B MoE via Ollama at 17–22 tok/s" with the exact Ollama command.
- Troubleshoot OOM errors — The tool’s quantization table and manual mode let you experiment with lower quantizations (e.g., Q2_K instead of Q4_K_M) or smaller model tiers to fit limited VRAM, and the FAQ advises context-length reduction as the first step.
- Learn about Gemma 4 model tiers — The hardware requirements table lists min RAM/VRAM and recommended GPUs for all four tiers, helping users understand the trade-off between model size and hardware.
How does it work?
- Auto-detect hardware — On page load, the tool uses WebGPU (or WebGL fallback) to read your GPU model and VRAM. On Mac, it identifies the Apple Silicon chip and unified memory size. No data is sent to any server.
- Match to best model tier — Your detected specs are cross-referenced against Gemma 4’s model requirements (E2B, E4B, 26B MoE, 31B Dense) and quantization levels. The matcher selects the largest comfortable fit and estimates tokens/second based on memory bandwidth.
- Generate run command — You get a pre-filled terminal command for your chosen runtime (Ollama, llama.cpp, or Transformers) with appropriate flags (e.g.,
-np 1 for parallelism, --ctx-size for context length). On mobile, it links directly to the AI Edge Gallery app.
FAQ
Can an RTX 4060 run Gemma 4?
Yes, an RTX 4060 (8 GB VRAM) can run the E4B model (9B dense) at Q4_K_M quantization with 20–35 t/s. The 26B MoE requires 12+ GB VRAM and won’t fit. Use Ollama or LM Studio with gemma4:e4b.
Can an RTX 4090 run Gemma 4 31B?
Yes, the RTX 4090 (24 GB VRAM) runs Gemma 4 31B Dense at Q4_K_M (~20 GB) at 15–25 t/s. For best results, use -np 1 with Ollama; long contexts (10k+ tokens) may be tight.
Yes. On iOS/Android, the tool detects limited hardware but links to Google AI Edge Gallery for one-tap install of the E2B model (5B parameters, ~3 GB). The E4B may crash on devices with under 10 GB RAM.
How accurate is the GPU detection?
Detection is generally accurate for single-GPU systems. On dual-GPU laptops, the browser may report the integrated GPU. Manual mode lets you correct this. Very new GPU models may show as "Unknown GPU" — use manual entry.
Yes, the hardware matcher is completely free to use. No sign-up, no installs, no data collection.
