explainx / blog
Electron app runs Gemma 4 on Apple Silicon with MLX-LM: build + chat modes, model sizes, setup, when offline helps vs when you still need the network. MIT: github.com/ammaarreshi/gemma-chat
Jun 29, 2026
MacBooks behave like a slow GPU with enormous shared RAM; dedicated cards are fast but VRAM-capped. The right buy depends on whether you wanted a laptop anyway, need privacy at 64k context, or need frontier-speed coding throughput.
Jun 29, 2026
Ollama's June 29, 2026 release makes Gemma 4 nearly 90% faster on Apple Silicon via multi-token prediction — 95 tok/s vs 50 on the Aider coding benchmark. Auto-tuned draft length, identical outputs, ollama launch claude --model gemma4:12b-mlx.
Jul 2, 2026
If you run open weights on your own hardware in 2026, you are almost certainly touching llama.cpp — directly or through Ollama and LM Studio. This guide explains what it is, how GGUF fits in, copy-paste install and run commands, and how to expose a local API for coding agents.
Per its README, Gemma Chat is a local-first desktop app: Electron + Vite + React 19 + TypeScript + Tailwind on the surface, MLX-LM underneath for Gemma 4 on Apple Silicon, with optional Ollama compatibility called out in the repo description. The project bills itself as “vibe code without the internet” after the initial model pull—no API keys in the local narrative, MIT license.
This article is an explainx.ai field guide: stack, model sizing, how the agent loop is described upstream, and what to validate if you fork it for your team.
| Question | Short answer |
|---|---|
| What is it? | Desktop chat + coding agent for Gemma 4, running via MLX on Mac (Apple Silicon). |
| Why care? | A concrete open-source reference for offline-capable assistant UX tied to Google’s open Gemma line and Apple’s MLX runtime. |
| Primary source | github.com/ammaarreshi/gemma-chat |
| Creator signal | Ammaar Reshi—public launch thread and Google Gemma account amplification (April 2026); star/fork counts change—check the repo badge row. |
| License | MIT (per repository LICENSE). |
The README frames two modes:
Supporting pieces called out there include model switching across several Gemma 4 variants, voice input via Whisper (transformers.js / WASM in-browser path per stack table), and first-run automation: Python venv + MLX provisioning.
The README’s architecture section is worth reading directly. In Build mode the story is:
<action> blocks from the stream (upstream notes small models behaving more reliably with XML than JSON tool calls).That pattern—stream → parse imperative actions → mutate workspace → loop—is the same family of “local Codex-style” loops teams are standardizing on in 2026; here it is bound to Gemma + MLX instead of a hosted API.
The project’s README publishes a simple matrix. Paraphrased here—re-verify on the repo before you buy hardware:
| Variant (as labeled upstream) | Approximate size | Notes |
|---|---|---|
| Gemma 4 E2B | ~1.5 GB | Faster, lighter tasks |
| Gemma 4 E4B | ~3 GB | Recommended balance in README |
| Gemma 4 27B MoE | ~8 GB | Stronger reasoning; 16 GB+ RAM class machine |
| Gemma 4 31B | ~18 GB | Heaviest; 32 GB+ RAM class machine |
Community replies on X have asked the same question your laptop will ask: which row is “enough” for acceptable latency on your thermal budget—there is no substitute for local profiling on the exact chip and cooling you ship with.
From the README's Getting Started block:
git clone https://github.com/ammaarreshi/gemma-chat.git
cd gemma-chat
npm install
npm run dev
Note: Some README snapshots on the web have referenced alternate clone URLs; use the repository you intend to fork and verify default branch and package scripts in package.json before documenting runbooks internally.
Packaging:
npm run dist
Upstream states this yields a .dmg for drag-to-Applications installs.
The README frames a progressive setup flow on first launch: Python environment provisioning, MLX dependency installation, and model weight download. That last step is where most "my install is frozen" reports trace back to—~3 GB for the recommended E4B variant means several minutes (or longer on slower connections) with minimal progress feedback in early releases.
Practical timeline from community threads (not a warranty):
npm run dev: Python venv creation and MLX install can add 5–10 minutesIf the app appears stuck during model pull, check disk space (models land in a .models or similar cache directory per upstream code) and network logs before assuming a crash. The Issues tracker has pinned guidance for common first-run blockers—read those before filing duplicates.
The repository's own table is honest about memory footprint, but sustained performance depends on thermal design and concurrent workload. Here's what early adopters report (paraphrased from GitHub discussions and social threads):
| Mac model class | Recommended variant | Notes |
|---|---|---|
| M1 / M2 (8 GB unified) | E2B (1.5 GB) | E4B can run but may swap under load; avoid 27B/31B |
| M1 Pro / M2 Pro (16 GB) | E4B (3 GB) or 27B MoE (8 GB) | Comfortable for typical sessions; 27B is usable |
| M1 Max / M2 Max (32 GB+) | 27B MoE or 31B | Full capability; watch for thermal throttling on long runs |
| M3 / M3 Pro / M3 Max | Same as M1/M2 equivalent | Improved efficiency may help sustained throughput |
The upstream README is clear: if you want the 31B variant to feel fast, 32 GB+ RAM is not optional. Teams evaluating this for multiple developers should also consider concurrent model instances—three people running E4B locally is ~9 GB of model weights alone, before OS and application overhead.
The "vibe code without the internet" tagline is catchy, but operational reality is more nuanced. Here's where the offline model story is strongest—and where it still needs a network.
Privacy-sensitive prototyping — If you're sketching an internal tool, debugging sensitive logic, or iterating on code with confidential business rules, keeping the model weights and inference entirely local removes one exfiltration vector. Your editor, dependencies, and CI may still phone home, but the LLM layer does not.
Travel and unreliable connectivity — Flights, trains, cafes with flaky Wi-Fi, or remote job sites where bandwidth is metered—cached models mean you can still generate boilerplate, refactor helpers, or iterate on UI mockups without stalling on API timeouts.
Cost control for experimentation — If you're doing rapid prompt iteration or UI rewrites, local inference has zero per-token cost once weights are downloaded. That's meaningful for hobbyists, students, or small teams exploring ideas before committing to a hosted plan.
Latency-sensitive workflows — On a well-specced Mac, local MLX inference can deliver lower time-to-first-token than round-tripping to a cloud API—especially for short prompts where network overhead dominates. That responsiveness matters in interactive build loops where every 200ms saved compounds over dozens of iterations.
npm install, pip install, system updates, and framework docs all assume connectivity.The honest framing: Gemma Chat gives you offline inference; it does not give you a hermetically sealed development environment. Treat it as one layer of your stack running locally, not a claim that every dependency is air-gapped.
If you're deciding between Gemma Chat, Ollama, LM Studio, or custom MLX setups, here's how they differ in practice:
| Dimension | Gemma Chat | Ollama | LM Studio | DIY MLX-LM |
|---|---|---|---|---|
| UI paradigm | Electron app, build + chat modes | CLI-first, server-oriented | Desktop GUI, model library | Script or notebook |
| Model scope | Gemma 4 family (opinionated) | Broad model zoo | Broad model library | Any MLX-compatible weights |
| Setup complexity | Medium (npm + Python venv + download) | Low (single binary) | Low (installer) | High (manual dependencies) |
| Tool/workflow integration | Built-in build mode, live preview | MCP and external tool friendly | Plugin ecosystem | Fully custom |
| Update cadence | Depends on maintainer activity | Frequent, vendor-backed | Frequent, commercial support | You own it |
When to pick Gemma Chat: You want a batteries-included coding assistant specifically for Gemma 4 with workspace sandboxing and a UI optimized for iterative builds—and you're willing to debug Electron + MLX integration quirks.
When to pick Ollama: You value broad model support, server-style deployment, and MCP ecosystem compatibility over a bespoke UI. Ollama's model library lets you swap between Gemma, Llama, Mistral, and others with one CLI command.
When to pick LM Studio: You want a polished desktop experience with minimal command-line friction and a curated model library backed by a team shipping frequent updates and support channels.
When to go DIY with MLX-LM: You need full control over inference parameters, custom quantization, or research-oriented experiments—and you're comfortable maintaining Python environments and debugging Metal shaders.
npm dependencies, reading live API docs, and shipping CI/CD still want a network—even when the model weights never leave the machine. That distinction matters for security reviews ("data never hits OpenAI") vs program reality ("the loop still phones home for packages").The MIT license means you can fork, modify, and redistribute—subject to license terms. Here are patterns early adopters discuss:
The repository's model-loading logic lives in Python backend scripts that call MLX-LM. If you want to add a different Gemma checkpoint (e.g., a fine-tuned version for your domain), you'll modify:
Check the src/ and server/ directories (names vary by repo structure) for where model IDs map to Hugging Face or local paths.
The README mentions tools (web search, URL fetch, calculator, bash). If you want to wire MCP servers for internal APIs or databases:
This is not plug-and-play today; treat it as a fork-and-extend project if MCP is a hard requirement.
The build mode writes files into a sandboxed directory. For production use cases where code must persist across sessions or integrate with Git:
If you want to distribute Gemma Chat internally:
npm run dist to build platform-specific installersWhile the upstream README focuses on capabilities, community threads discuss practical latency. Here's what users report (not official benchmarks—treat as anecdotal):
| Mac configuration | Reported TPS range | Notes |
|---|---|---|
| M1, 8 GB | 8–15 TPS | Acceptable for chat; slower for long code generation |
| M2, 16 GB | 12–20 TPS | Comfortable for most workflows |
| M1 Pro, 16 GB | 15–25 TPS | Good balance of speed and responsiveness |
| M3 Max, 32 GB+ (27B model) | 10–18 TPS | Larger model trades throughput for quality |
Context: 20 TPS means a 200-token code snippet generates in ~10 seconds. For interactive build mode, that's fast enough to see incremental progress; for long rewrites, you may step away while it runs.
The live preview iframe reloads when the model flushes partial writes. Early community feedback notes occasional flicker or stale state if the model generates HTML faster than the preview can reconcile—similar UX to hot-reload in Vite or webpack. Not a blocker, but something to expect if you're generating complex multi-file UIs.
One reason teams explore Gemma Chat is the pitch that inference stays local. Here's what that does and does not guarantee:
npm install and pip install pull from public registries; supply-chain risk is orthogonal to where inference happens.For regulated industries or sensitive projects, local weights are a useful data residency primitive—but you still need standard secret scanning, code review, and access control around the tool.
As of this writing, active GitHub Issues and Discussions suggest a few evolving priorities:
Check the Issues and Milestones on the repo for current status—open-source roadmaps shift as contributors prioritize.
explainx.ai indexes skills, tools, agents, and MCP servers for teams that ship with assistants. Gemma Chat is a reference for one slice of that map: desktop shell + local weights + tool protocol + workspace sandbox. Whether you adopt it directly or borrow patterns, the artifact is inspectable in MIT-licensed source.
The broader lesson: local-first LLMs are no longer a research curiosity. With projects like Gemma Chat, Ollama, LM Studio, and raw MLX setups, teams can run capable models on commodity hardware—trading some convenience for privacy, cost control, and offline resilience. That shift matters for regulated industries, cost-conscious startups, and developers in low-connectivity regions.
Star counts, default models, and README clone URLs drift quickly after a viral launch. Reconcile any numbers in this post with the live GitHub page and Issues before budgeting hardware or support.