Verdict: For pure on-device reasoning — maths, logic, competition-style problem solving — DeepGrove's Maple-Preview is the fastest free local model you can run on a Mac in August 2026. It decodes at 218 tokens/s on a base Mac mini M4 (independently confirmed at 228 tok/s on an M4 Max), which is 5–16× quicker than Google's Gemma 4 at similar quality. It fits in 5.31 GB, carries an MIT licence, and even runs on an iPhone at 127 tok/s. The trade-off: it is not yet a coding or agentic powerhouse. Gemma 4 remains the better generalist if you need multimodal input, broader task coverage, and a mature ecosystem. For builders assembling a local AI stack, the move is to run both — Maple for the reasoning slot, Gemma for everything else.
Last verified: 2026-08-06 · Best for reasoning: Maple-Preview · Best generalist: Gemma 4 · Best for agents: LFM 2.5-2.6B · All three are free/open-weight.
Pricing, model versions, and benchmark scores change fast — this comparison was last checked on the date above. Verify the live model cards before you commit disk space.
What is Maple-Preview and why does the speed claim matter?
Maple-Preview is a 20B-parameter mixture-of-experts reasoning model released by DeepGrove on August 4, 2026 under the MIT licence. Its headline number — 218 tokens of decode speed per second on a consumer Mac mini M4 — matters because speed has been the single biggest brake on local LLM adoption. A model that takes five minutes to answer one question is unusable for real work; a model that streams faster than you can read changes the calculus entirely [HF model card].
The speed comes from two architectural decisions that are worth understanding before you choose a local model, because they explain both the performance and the limits.
How do ternary weights make a 20B model fit in 5 GB?
Ternary weights are the first half of Maple's speed story. A standard LLM stores every weight — every connection between neurons — as a high-precision number with many decimal places (typically 16-bit floats). Maple instead stores each weight as one of just three symbols: −α, 0, or +α (a negative, zero, or positive value tied to a single per-row scale factor). This is what "ternary" and "2-bit" mean in the model card [HF model card].
The payoff is two-fold. First, the checkpoint shrinks: a model that would occupy roughly 38 GB in full precision compresses to a 5.31 GB file you download once and own forever. Second, during inference the maths simplifies — matrix multiplication (expensive multiply-accumulate operations) is replaced by additions, which consumer chips handle far more efficiently [Benchgen analysis].
Crucially, Maple is natively ternary: it was trained at this precision from the start, rather than trained in full precision and quantized down afterwards. Post-hoc quantization invariably degrades quality; native ternary training sidips that loss, which is why Maple keeps its reasoning ability where most 2-bit quantized models fall apart.
What is the mixture-of-experts trick and why does only 1B activate?
The second half of the speed story is the expert system. Maple holds 256 small specialist networks ("experts") inside it, arranged across 24 transformer layers. For every single token it generates, a learned router wakes up only the 8 most relevant experts and leaves the other 248 asleep [HF model card].
The result: you get the knowledge capacity of a 20.2-billion-parameter model, but only 1.49 billion parameters are active for any given token. That is why the spec line reads "20B-A1B" — 20 billion total, 1 billion active. Active params are what determine inference cost; total params are what determine knowledge. Mixture-of-experts (MoE) lets you decouple the two.
Gemma 4 also ships MoE variants (the 26B-A4B size, with 4 billion active), so the architecture is not unique to Maple. The difference is that Maple combines MoE with ternary weights — that combination is what pushes the Pareto frontier.
Maple-Preview vs Gemma 4 vs LFM 2.5: how do the numbers compare?
| Spec | Maple-Preview (DeepGrove) | Gemma 4 (Google DeepMind) | LFM 2.5-2.6B (Liquid AI) |
|---|---|---|---|
| Released | August 4, 2026 | March 31, 2026 | August 4, 2026 |
| Architecture | 20B-A1B MoE, ternary 2-bit | Dense + MoE (E2B–31B sizes) | 2.6B hybrid |
| Active params | 1.49B | varies by size | 2.6B |
| Checkpoint size | 5.31 GB | varies (E2B ~small, 31B large) | <2.5 GB |
| Context window | 131,072 tokens | 128K (small) / 256K (medium) | 128K |
| Decode speed (Mac) | 218 tok/s M4 mini · 281.5 tok/s M5 Pro | moderate (mid-pack on DeepGrove's chart) | 220 tok/s M5 Max |
| iPhone speed | 127 tok/s | not a primary target | 30 tok/s |
| Reasoning benchmarks | AIME 2026 87.5% · HMMT 2026 78.8% · LCBv6 75.1% · GPQA-D 73.5% | competitive, multimodal | agent-focused |
| Licence | MIT (commercial OK) | Apache 2.0 (commercial OK) | open weights |
| Multimodal | text only | text + image + audio (E2B/E4B/12B) | text only |
| Best for | on-device reasoning, maths | generalist, multimodal edge work | agentic tasks on-device |
Sources: DeepGrove launch page and HF model card [1]; Google AI Gemma 4 model card and release notes [2] [3]; Liquid AI LFM2.5-2.6B blog [4]; benchmark aggregation by Benchgen [5].
Benchmark scores are as reported by DeepGrove in its own launch comparison table. Independent third-party benchmarks are not yet widely available for Maple-Preview (released days ago). Treat the numbers as vendor-reported until corroborated.
Is Maple-Preview actually faster than Gemma 4 in real use?
On raw decode speed, yes — and the margin is large. DeepGrove's chart places Gemma 4's E2B and E4B variants in the mid-range on speed, with Maple-Preview sitting at the top right of the Pareto frontier (fast and capable). The 5–16× claim compares Maple-Preview against Gemma 4, Qwen 3.5, and gpt-oss at similar reasoning quality [DeepGrove announcement].
An independent hands-on test (published August 5, 2026) measured 228 tok/s on an M4 Max — slightly above DeepGrove's own 218 tok/s figure for a base M4 — and confirmed peak memory of 7.6 GB while answering. Both the speed and the footprint claims held up on real hardware.
The honest caveat: speed is not the same as usefulness. A model that answers instantly but produces broken code is still a broken model. The same hands-on test found Maple-Preview produced a visually polished todo app in 22 seconds that was dead on arrival — two JavaScript syntax errors meant the page never parsed. Gemma 4, with its broader training and multimodal input, is the safer bet if your workload is coding-heavy or agentic. If you want a deeper look at stacking local models into a working agent system, our guide to using an agent operating system for SEO and memory in 2026 walks through the exact configuration.
What are Maple-Preview's real benchmark scores?
DeepGrove reports four reasoning benchmarks on the launch page [HF model card] [Benchgen]:
| Benchmark | Maple-Preview | What it tests |
|---|---|---|
| AIME 2026 | 87.5% | competition-level mathematics |
| HMMT 2026 | 78.8% | Harvard-MIT maths tournament |
| LiveCodeBench v6 | 75.1% | code generation with hidden tests |
| GPQA-Diamond | 73.5% | graduate-level science QA |
| Average | 78.7% | — |
For context, Qwen3.5 35B-A3B (a larger model with 3 billion active params) averages 82.9% on the same set, edging Maple out — particularly on GPQA-Diamond (84.2% vs 73.5%). So Maple is competitive with, but not yet beating, the strongest models one size class up. The point is that it gets within a few points while running dramatically faster and at a fraction of the memory.
DeepGrove also demonstrated Maple-Preview solving IMO 2024 Problem 1 correctly (7/7) at 281.5 tok/s on a MacBook Pro M5 Pro — a live, verifiable reasoning win on consumer hardware [Benchgen].
Where does Maple-Preview fall short?
Three limitations are worth flagging before you wire it into production:
- Minimal agentic post-training. DeepGrove states plainly on the model card that this preview "received minimal post-training for agentic tasks and only small-scale general reinforcement learning." It is a reasoning engine, not yet an agent. Tool-use, multi-step task planning, and function calling are not its strength [HF model card].
- Coding that looks done but is not. Independent testing found Maple can generate visually convincing code that fails to run — syntax errors, unparsed scripts, dead buttons. It reasons about code well (LiveCodeBench 75.1%) but does not reliably ship working software yet. If you are building an AI-driven long-horizon workflow, keep a stronger builder model in the loop.
- Infinite-thinking failure mode. On very hard problems, Maple sometimes never stops its chain-of-thought and hits the token cap without producing an answer. Set a token budget and move on when it stalls.
Gemma 4 does not share these limits to the same degree — it has had far more post-training, supports multimodal input (text, image, audio on E2B/E4B/12B), and benefits from Google's mature tooling ecosystem (Ollama, LM Studio, LiteRT-LM) [Gemma 4 model card].
How do you run Maple-Preview locally on a Mac?
Maple-Preview runs on Apple Silicon via an MLX-based runtime that DeepGrove forked from the standard mlx-lm library. The setup is roughly five commands:
- Clone the runtime —
git clone https://github.com/deepgrove-ai/mlx-lm-deepgrove.git ~/maple-mlx - Install —
cd ~/maple-mlx && ./setup.sh && source .venv/bin/activate - Download the 5 GB checkpoint —
hf download deepgrove/maple-preview-2bit-mlx --local-dir maple-2bit-mlx - First generation —
python -m mlx_lm generate --model ./maple-2bit-mlx --trust-remote-code --flash-head --prompt "Your question" --temp 1.0 - Serve as a local API —
python -m mlx_lm server --model ./maple-2bit-mlx --trust-remote-code --flash-head --port 8124
Step 5 turns Maple into a local OpenAI-compatible endpoint — anything that speaks the OpenAI API (scripts, agents, editors) can point at http://127.0.0.1:8124/v1 and get free local reasoning. The --flash-head flag is a free speed boost; keep it on. Source: DeepGrove's GitHub runtime and the MLX build on HuggingFace [GitHub] [HF].
On CUDA/Linux, the path uses Transformers with Triton and FlashAttention — see the model card for the vLLM and SGLang server commands [HF model card].
No Mac? DeepGrove hosts a free browser demo at chat.deepgrove.ai so you can test the model before committing the 5 GB download.
No Mac? Try it in the browser first
DeepGrove hosts a free interactive demo at chat.deepgrove.ai where you can talk to the same Maple-Preview model with zero installation. It is the fastest way to judge whether the reasoning quality meets your bar before you spend the disk space and setup time.
What this means for you
If you are a builder or small-business owner running local AI (the audience we write for), Maple-Preview changes the cost arithmetic of on-device reasoning:
- Reasoning moves off the cloud bill. Every competition-maths, logic-check, or analysis question you route to Maple costs $0 instead of a metered API call. The 5 GB download is the only cost, and the MIT licence means you can use it commercially.
- Privacy is structural, not a policy. Contracts, financials, client strategy — reason over them with nothing leaving your machine. For anyone handling sensitive data, this is the difference between "we promise not to log it" and "it never transmitted."
- The iPhone number is the real signal. 127 tok/s on a phone means on-device AI that actually reasons is now a shipping category, not a demo. If you build mobile products, start prototyping against this now.
- Do not replace your stack — extend it. The right pattern, as we have written about for agent operating systems, is to slot Maple in as the "reasoning engine" alongside a stronger builder model. Keep a cloud model for finals; batch the free local reasoning for triage and rough passes. The Gemini Notebook workflow we covered for SEO content engines is a good example of where local reasoning slots in for idea triage.
The bottom line: Maple-Preview is not the best local model for everything. It is the best local model for one thing — fast, free, on-device reasoning — and that one thing is finally good enough to rely on.
FAQ
Q: Is Maple-Preview free to use commercially? A: Yes. The weights are released under the MIT licence, which permits commercial use, modification, and redistribution. You download the 5.31 GB checkpoint once and own it indefinitely — no per-token fees, no subscription [HF model card].
Q: How fast is Maple-Preview compared to Gemma 4? A: DeepGrove reports 5–16× faster decode than Gemma 4, Qwen 3.5, and gpt-oss at similar reasoning quality. Measured speeds: 218 tok/s on a Mac mini M4, 281.5 tok/s on a MacBook Pro M5 Pro, and 127 tok/s on an iPhone. An independent test confirmed 228 tok/s on an M4 Max [DeepGrove].
Q: Can Maple-Preview write code? A: It can reason about code (LiveCodeBench v6 score: 75.1%) but is not yet a reliable coding model. Independent testing found it produces visually polished code that fails to run — syntax errors and dead interactions. DeepGrove states the preview had minimal agentic post-training. Use it for code reasoning and review, not for shipping production software [HF model card].
Q: What hardware do I need to run Maple-Preview? A: Any Apple Silicon Mac with 16 GB of unified memory is comfortable — peak inference memory is about 7.6 GB. The checkpoint is 5.31 GB on disk. DeepGrove also demonstrated it running on an iPhone at 127 tok/s. On Linux/CUDA you need Triton and FlashAttention for the Transformers path [Benchgen].
Q: Does Maple-Preview support images or audio like Gemma 4? A: No. Maple-Preview is text-only. Gemma 4 (E2B, E4B, and 12B sizes) accepts text, image, and audio input. If your workload needs multimodal understanding, Gemma 4 is the match; if you need pure text reasoning speed, Maple wins [Gemma 4 model card].
Q: When should I pick LFM 2.5-2.6B over Maple-Preview? A: Pick Liquid AI's LFM 2.5-2.6B when your primary need is agentic tasks — tool use, multi-step planning, function calling — at on-device speed (220 tok/s on M5 Max, under 2.5 GB). Pick Maple-Preview when your primary need is deep reasoning and maths. Both released on August 4, 2026 [Liquid AI].
Discussion
0 comments