Google (open-weights, runs local)

Gemma 4 12B · MLX

The fast free local engine — MLX + multi-token prediction, ~1.6x quicker overnight.

Context128,000 tokens

PricingFree · runs locally

Tasks tested45

Avg score3.98/10 average

Medals🥇0 🥈0 🥉0

Release2026-07

Official siteollama.com/library/gemma4 ↗

Official vendor source

Gemma 4 12B · MLX is built by Google (open-weights, runs local) — see the vendor's own product page, pricing, and docs at ollama.com/library/gemma4.

Visit ollama.com/library/gemma4 →

What is Gemma 4 12B · MLX?

Gemma 4 12B · MLX is the Google (open-weights, runs local) frontier model with a 128,000 tokens context window, released 2026-07. Tagline: The fast free local engine — MLX + multi-token prediction, ~1.6x quicker overnight.. Official source: ollama.com/library/gemma4.

Pricing detail. Google's official Gemma 4 12B instruct on Ollama 0.31's new MLX engine with multi-token prediction — the build that made headlines for being ~90% faster on Apple Silicon. Free, offline, ~62 tok/s general / 70+ on code on an M4 Max.

How I use it inside the Agent OS. The default Local engine in the Agent OS — the fast free model that runs the everyday 90% (triage, drafts, loops) at $0, with builds handed to stronger coders.

What I built with Gemma 4 12B · MLX

Every model on Goldie Bench gets the same fixed prompt set — one shot, single HTML file out — and I score the result 0–10 inside the Agent Operating System. Here's what Gemma 4 12B · MLX shipped on the bench: 45 one-shot demos across 128,000 tokens of context. Of those, 42 are scored against the field with my honest 0–10 from the source guides at agentos.guide.

Strengths

The fastest local Gemma yet — ~62 tok/s general, 70+ on code (MLX + MTP, verified on an M4 Max)
Free, offline, 100% on your own machine — the everyday agentic-loop engine
Strong on pages, UI and 2D canvas work one-shot

Trade-offs

Base instruct tune, not a coder build — rich 3D/WebGL scenes routinely come out empty or under-populated one-shot
The speed is real but the one-shot build ceiling is well below frontier coders

Best for

Fast local agentic loops
Pages + simple canvas builds
Free everyday chat + drafting

Every demo by Gemma 4 12B · MLX

45 live demos, sorted by category. Click any tile to play the actual one-shot result. Verdicts and 0–10 scores are pulled from the source guides where I posted them publicly.

Clean neon aesthetic with glowing border, subtle grid, and score/game-over UI render well, but the screenshot shows GAME OVER already triggered at score 0 — the dual game-loop (leftover setTimeout draw() plus interval gameLoop) likely causes double-speed movement and instant self-collision. Solid visuals undermined by a broken/racing game loop.

The title overlay renders with decent gold serif typography and atmosphere, but the 3D dungeon never appears in the screenshot and the code uses `THREE.FogExp` (nonexistent; should be FogExp2) which likely throws and breaks the render — pointer-lock gating means we only ever see the menu. A moody title screen, but the actual torch-lit crawler is unverified/likely broken.

The 3D scene fails to render — only the HUD overlay shows over an empty black canvas, likely due to THREE.FogExp not existing in r128 (should be FogExp2), which throws and halts scene setup. Nice UI chrome, but no game world, ships, or gameplay is visible.

The wall-height formula is broken (division by cos of relative angle without proper fisheye correction produces massive overscaled walls), so the screen floods entirely red and no maze, floor, ceiling, or depth is visible — only a single monster blob floats over the void. Monster chase AI and sprites are coded correctly but the raycaster itself doesn't render a usable 3D view.

Renders a 3D scene with HUD (score, speed, fury bar) and a bold neon title, but the 'dragon' is just a blue blob with flat wings and the ring appears red/collided at start with the camera framing too close and awkward. Functional core with fire-breath and fury mechanics but visually rough and far from the neon-flight polish of the top builds.

Despite reasonable source code with a floor, snow particles, and a geometric dragon, the rendered screenshot shows only the title text over a black void — the 3D scene doesn't visibly render, delivering none of the promised frozen world, sword-draw, or walkable exploration.

A functional 3D Three.js lane-runner with clean neon styling, working collision, scoring, and restart — renders correctly with player cube, obstacles, and grid floor. The camera framing feels awkward (obstacles float mid-screen and the grid barely reads), making it look somewhat unpolished versus the field's best, but it's a legitimate, playable game.

The neon title screen renders with a clean glowing aesthetic, but there's a critical bug: THREE.FogExp doesn't exist (it's FogExp2), which throws during init() and likely leaves the canvas black/non-functional behind the overlay. Even if it ran, the design is thin — no synth music, no real waves/power-ups shown, and the game logic is basic compared to the field's best.

Renders a driving scene with a road plane and dark buildings, but it's overwhelmingly black — the neon accents barely register and there's no city glow or cyberpunk atmosphere. The HUD text is the only vivid neon, leaving the actual 3D scene feeling empty and unpolished versus the field's best.

The neon palette and HUD render, but the perspective/projection math is broken — instead of a receding road we get large flat slabs of magenta/cyan crammed in the lower-left corner with no coherent track or vapor trails. Not a convincing racer despite the aesthetic groundwork.

The screenshot shows only the title overlay and 'Click to Enter' menu against pure black — the 3D scene never renders visibly, likely because THREE.FogExp is invalid (should be FogExp2), which throws before the scene is built, leaving no dungeon visible. The typography is clean but there's no torch-lit crypt or ruins on screen, so it reads as effectively non-rendering on the brief.

The neon road with magenta edges and glowing UI reads clearly, but the scene is broken — no synthwave sun visible, no grid floor, no horizon, and the road plane geometry looks wrong with an odd triangular perspective. It renders but falls well short of a polished outrun horizon.

Renders a decent 3D table with felt, wooden rails, shadows and colored balls, but the balls aren't in a proper triangle rack, there are no pockets, and a likely bug (velocityAlongSync called before its declaration, plus no drag-aim visualization) undermines the physics gameplay. Presentable but generic and functionally shaky compared to the field's best.

The 3D scene fails to render entirely — only the UI overlay (title, score, speed, controls hint) shows over a black void. The likely culprit is THREE.FogExp (should be FogExp2), throwing an error that halts the scene setup before anything is drawn.

The 3D scene fails to render — only the UI overlay shows on a black canvas, likely due to THREE.FogExp (should be FogExp2), pointerLockElements typo, and a stray closing brace breaking the script. The maze is completely non-functional.

Renders cleanly with functional movement, collision, item pickup and a working turn-based battle overlay, but everything is plain colored circles rather than sprites, the map is a bare bordered box, and there's no death/win state or polish — it works but is generic and well below the field's best.

The screenshot shows only a blank blue sky with UI overlays — no ground, castle, or trees render, because THREE.FogExp is not a valid constructor (should be FogExp2), throwing an error that halts init() before the scene renders. Effectively non-rendering as a game world.

The 3D scene fails to render — only the UI overlay (title, HUD, crosshair) shows over a black void, with no visible terrain, trees, player, or enemies. The bug is likely THREE.FogExp (should be FogExp2 in r128), which throws and halts init, breaking the whole world.

The screenshot shows only the start overlay on a flat dark background with no voxel terrain visible behind it, and the code contains a critical bug — THREE.FogExp doesn't exist (it's FogExp2), which throws during init() and prevents the scene from ever rendering. The UI menu is clean but the world never appears.

The 3D wireframe icosahedron core with particle field renders beautifully and gives a genuinely premium, on-brief tech-marketing feel; glass cards and gradient CTAs are polished. The NEBULA h1 appears cut off at the top of the viewport, which slightly hurts the hero hierarchy and keeps it just short of the field's best.

Clean desktop with dock, live clock, and functional windowing/apps in source, but the screenshot shows only the empty desktop and the build is generic with a duplicated terminal-output bug and no maximize/minimize wiring.

The heavy FogExp2 at density 0.5 crushes nearly everything to black — the accretion disk, stars, and event horizon are barely a faint ghost of a ring, leaving a near-empty screen with just the UI text visible. Effectively non-rendering as a visualisation despite competent code structure.

Only the UI overlay renders; no boids are visible in the scene, likely because MAX_SPEED (0.15) is far too low relative to bounds so the tiny cones barely move and camera framing may miss them. The flocking logic is reasonable in code, but the actual rendered result shows an empty simulation.

Only the UI text renders — no cloth, no sphere, no 3D scene. The code uses non-existent Three.js methods (THREE.FogExp, computeVertexPositions) that throw errors and halt init, leaving a blank canvas.

Particles collapsed into a tiny clumped blob in the center rather than a full-screen swirling fluid, and stray 'conciencia' text leaked into the page from a malformed head tag. The title/UI render nicely but the core simulation looks broken and off-brief.

Renders a recognizable Mandelbrot but it's distorted — a shader bug (z.x reused before z.y computed) breaks the iteration math, the rotation animation warps the plane awkwardly, and the color gradient collapses to mostly flat blue. Works and is interactive but flawed and far off the field's best.

No galaxy renders — only the title and hint text appear on a black screen. The bug is in createGalaxy where params.angleOffset references params.arms before params is defined, throwing a ReferenceError that aborts galaxy creation entirely.

Renders only the title/UI and a nearly-empty starfield with faint dots — the bodies flew apart immediately due to randomized normalized velocities and unstable integration, so there's no visible orbital system. Structurally sound Three.js scaffolding, but the actual simulation fails to show a coherent N-body dance.

No particles render — the onTouchMove function has a syntax error (stray `, { passive: false }` object literal after the function body), which throws a parse error and halts all script execution. Only the static UI text shows on an empty black canvas.

The 3D scene fails to render—only the title, subtitle, and controls hint appear over an empty black canvas, likely due to appending the WebGL context to the existing canvas element and the extremely dense FogExp2 (0.5) swallowing everything. Not a path tracer and effectively non-rendering geometry.

The screenshot shows only the UI panel and a rotated dark plane with no visible Turing pattern — the Gray-Scott math uses a wrong kill formulation (v(1-v)) and kill=0.6 which drives the reaction to extinction, so the simulation renders essentially black. Non-functional as a pattern generator.

Renders cleanly with a bright sun, all eight orbiting planets with faint orbit rings, a starfield, and a nicely angled auto-orbiting camera. Solid and functional but generic — no textures, labels, tilt/rings for Saturn, or interactivity, so it falls short of the field's best.

The neon title and starfield render nicely, but the 'tunnel' reads as a couple of scattered wireframe rings drifting off-screen rather than a coherent wormhole flythrough — the group rotation and non-concentric placement break the tunnel illusion.

Instead of flowing aurora curtains, the shader alpha threshold makes the planes render as flat opaque green wedges filling half the screen — reads like a broken solid polygon rather than northern lights. Clean title and starfield, but the core effect fails to convey aurora.

Renders clean with two nicely-formed particle bursts, launch trails, and a starfield, plus working click/tap interaction. The purple wash (trail color rgba(0,0,5) accumulating) is odd for a midnight theme and the effect is solid but standard, keeping it below the top tier.

Only the header text renders; the blobs are essentially invisible—the dense FogExp2 (density 0.5) at z=8 swallows the scene, leaving just faint light dots on a near-black canvas. Effectively non-rendering as a lava lamp.

Only the UI overlay text renders on an otherwise black screen — the Three.js animation is broken (invalid THREE.FogExp and texture.sampler API calls throw, so no glyphs appear). No matrix rain is visible at all.

The plasma canvas fails to render — only the title and control hints show over a dead dark background, because the invalid CDATA block in the uniforms declaration is a JS syntax error that halts execution before Three.js initializes.

Only the neon title overlay rendered; the 3D scene is blank because the animate loop references an undefined `h` variable in the mountain forEach, throwing on the first frame and halting rendering. Nice UI styling but the actual synthwave scene is broken.

No terrain renders — only the UI overlay shows on an empty background, because THREE.FogExp is not a valid constructor (should be FogExp2), throwing an error that halts scene setup. The core deliverable is completely missing.

The scene fails to render any voxel terrain — the fatal bug is THREE.FogExp (should be FogExp2), which throws and halts init before the world/renderer is fully set up, leaving only the UI overlay on a black canvas. The source shows a reasonable procedural approach, but the screenshot is non-rendering.

Renders a legible 3D wavy ocean surface with clean typography, mouse-ripple interaction, camera sway and touch support — solid and on-brief, but the harsh black troughs and flat blue palette look more like a menacing terrain than realistic water, lacking foam, specular sparkle or depth polish.

every demo, in a grid · click any one to play

Compare Gemma 4 12B · MLX against every other model

Every head-to-head featuring Gemma 4 12B · MLX. Verdicts shown for scored pairs.

Gemma 4 12B · MLX vs Fusion

Fusion leads 42–0

Gemma 4 12B · MLX vs Hermes MoA

Hermes MoA leads 42–0

Gemma 4 12B · MLX vs Claude Fable 5

Claude Fable 5 leads 40–2

Gemma 4 12B · MLX vs Grok

Grok leads 38–0

Gemma 4 12B · MLX vs MiniMax M3

MiniMax M3 leads 40–2

Gemma 4 12B · MLX vs Fugu Ultra

Fugu Ultra leads 41–0

Gemma 4 12B · MLX vs GLM-5.2

GLM-5.2 leads 41–1

Gemma 4 12B · MLX vs Fugu Mini

Fugu Mini leads 34–2

Gemma 4 12B · MLX vs Opus 4.8

Opus 4.8 leads 38–3

Gemma 4 12B · MLX vs Kimi K2.7

Kimi K2.7 leads 19–1

Gemma 4 12B · MLX vs Claude Sonnet 5

Claude Sonnet 5 leads 36–4

Gemma 4 12B · MLX vs Qwable 5 27B Coder

Qwable 5 27B Coder leads 36–3

Gemma 4 12B · MLX vs Qwen 3.7

Qwen 3.7 leads 37–5

Gemma 4 12B · MLX vs Laguna XS 2.1

Gemma 4 12B · MLX leads 22–14

Gemma 4 12B · MLX vs Qwythos 9B

Gemma 4 12B · MLX leads 28–12

Gemma 4 12B · MLX vs LongCat-2.0

LongCat-2.0 leads 4–0

Gemma 4 12B · MLX vs Gemma-4 12B Coder

Gemma-4 12B Coder leads 3–2

Gemma 4 12B · MLX vs Kimi K2.7 · Fast

42 shared tasks · unscored

Gemma 4 12B · MLX vs Kimi K2.7 · No-Think

42 shared tasks · unscored

Gemma 4 12B · MLX vs Kimi K2.7 · Quality

42 shared tasks · unscored

Gemma 4 12B · MLX vs Ornith 1.0

42 shared tasks · unscored

Gemma 4 12B · MLX vs Claude Mythos 5

Gemma 4 12B · MLX vs Kilo Code

See all 66 comparisons across every model →

Quick pill index

Direct comparisons against every other scored model on the bench:

Gemma 4 12B · MLX vs Fusion Gemma 4 12B · MLX vs Hermes MoA Gemma 4 12B · MLX vs Claude Fable 5 Gemma 4 12B · MLX vs Grok Gemma 4 12B · MLX vs MiniMax M3 Gemma 4 12B · MLX vs Fugu Ultra Gemma 4 12B · MLX vs GLM-5.2 Gemma 4 12B · MLX vs Fugu Mini Gemma 4 12B · MLX vs Opus 4.8 Gemma 4 12B · MLX vs Kimi K2.7 Gemma 4 12B · MLX vs Claude Sonnet 5 Gemma 4 12B · MLX vs Qwable 5 27B Coder Gemma 4 12B · MLX vs Qwen 3.7 Gemma 4 12B · MLX vs Laguna XS 2.1 Gemma 4 12B · MLX vs Qwythos 9B Gemma 4 12B · MLX vs LongCat-2.0 Gemma 4 12B · MLX vs Gemma-4 12B Coder

Read more on agentos.guide: /gemma4-speed-update, /hermes-gemma4

The same stack Julian uses

Run this stack yourself.

Every demo on this bench was built inside the Agent Operating System — one prompt, one shot, single HTML file out. The Agent OS, the prompts, the templates, the weekly walkthroughs and 3,600+ founders shipping with it every day all live inside the AI Profit Boardroom.

3,600+founders

258documented wins

38countries

$59/momonthly

Join AIPB · $59/mo → Read the Agent OS guides →