Maple-Preview is an open-source 20-billion-parameter reasoning model from DeepGrove that runs at 218 tokens per second on a Mac mini M4 — fast enough for real-time interactive use, entirely offline, with no API costs. Released August 4, 2026 under the MIT license, it uses an architecture called ternary weights (storing each weight as just -1, 0, or +1) combined with a mixture-of-experts design that activates only 1.49 billion of its 20.2 billion parameters per token. The result: competition-level math reasoning from a 5.31 GB checkpoint that fits in consumer RAM.
Last verified: 2026-08-08
- 20B-A1B ternary-weight MoE: 20.2B total params, 1.49B active per token
- 218 tok/s on Mac mini M4; 127 tok/s on iPhone; 281.5 tok/s on MacBook Pro M5 Pro
- 5.31 GB checkpoint, 131,072-token context window, MIT license
- Benchmarks: 87.5% AIME 2026, 78.8% HMMT 2026, 75.1% LiveCodeBench v6, 73.5% GPQA-Diamond
- Limitation: minimal agentic post-training — strong at reasoning, not yet for tool-use chains
- Pricing/limits change often — last checked 2026-08-08.
What Is Maple-Preview and Why Does It Matter?
Maple-Preview is a reasoning-focused large language model built by DeepGrove and released on Hugging Face on August 4, 2026. It combines two architectural innovations — ternary weights and sparse mixture-of-experts — to deliver reasoning capability at speeds previously impossible for a model this large on consumer hardware. The full checkpoint is 5.31 GB, the context window is 131,072 tokens, and the license is MIT (free for commercial use).
What makes this release significant is that it challenges the assumption that serious reasoning requires cloud infrastructure. DeepGrove reports the model solves IMO-level (International Mathematical Olympiad) problems locally on a Mac mini, with no internet connection. If you've been paying per-token to a reasoning API for math, coding, or analytical tasks, Maple-Preview represents a credible free alternative that runs on hardware you may already own.
How Do Ternary Weights Work?
Ternary weights are the core innovation behind Maple-Preview's speed and small size. Standard AI models store their internal parameters (weights) as 16-bit or 32-bit floating-point numbers — think of each weight as a high-resolution photograph with millions of color values. Maple stores each weight using only three possible values: -α, 0, or +α (where α is a learned scale factor per row). This is sometimes called "2-bit" precision, because three values fit in two bits.
The practical effect is dramatic. A model that would normally require ~38 GB in full precision (BF16) compresses to a 5.31 GB checkpoint. Operations on ternary values can be performed with simple addition and sign-flip rather than expensive floating-point multiply-accumulate, which is why the model runs 5–16× faster than comparable efficient models like Gemma 4, Qwen3.5, and gpt-oss on the same hardware.
Critically, DeepGrove trained Maple natively at ternary precision from scratch rather than quantizing an existing model afterward. Post-hoc quantization (compressing a trained model) typically degrades reasoning quality. Native ternary training avoids this by building the model's knowledge directly in the low-precision format, which is why Maple retains competition-level math ability despite its extreme compression. For a deeper technical breakdown of how this relates to other compression techniques, see our guide on how LLM quantization actually works in 2026.
What Is the Mixture-of-Experts Architecture in Maple-Preview?
Maple-Preview uses a mixture-of-experts (MoE) design where the 20.2 billion total parameters are distributed across 256 specialist sub-networks (experts), but only 8 experts are activated for any given token. This means each forward pass uses approximately 1.49 billion parameters — the "A1B" in "20B-A1B."
The architecture spans 24 transformer layers with a 3:1 ratio of sliding-window attention (512-token window) to global attention. Every four layers, one layer uses full global attention while the other three use sliding-window attention. This hybrid design bounds the KV-cache memory growth, which is how the model can support a 131,072-token context window without exhausting RAM.
The MoE routing means that different types of reasoning activate different expert clusters. A math problem wakes up a different set of 8 experts than a strategic planning prompt. You get the knowledge capacity of a 20 billion parameter model with the inference cost of a 1.5 billion parameter one.
How Fast Is Maple-Preview on Consumer Hardware?
DeepGrove's benchmarks, confirmed by the model card on Hugging Face and the mlx-lm-deepgrove GitHub repository, report the following decode speeds:
| Hardware | Decode Speed | Prefill Speed | Peak Memory |
|---|---|---|---|
| Mac mini M4 (exact head) | 169 tok/s | 1,075 tok/s | 6.51 GB |
| Mac mini M4 (--flash-head) | 218 tok/s | 1,075 tok/s | 6.69 GB |
| MacBook Pro M5 Pro (exact head) | 359 tok/s | 3,773 tok/s | 6.73 GB |
| MacBook Pro M5 Pro (--flash-head) | 395 tok/s | 3,857 tok/s | 6.92 GB |
| iPhone | 127 tok/s | — | — |
Source: DeepGrove mlx-lm-deepgrove README, benchmark table. All figures are vendor-reported. The --flash-head flag enables a k-means clustering optimization that reduces the vocabulary-head computation overhead.
For context, 218 tokens per second means the model generates roughly 160+ words per second — faster than most people can read. At that speed, waiting for a response feels instantaneous, and you can iterate on prompts in real time without the latency typical of cloud APIs.
The comparison to other efficient models is where this gets interesting. DeepGrove reports Maple-Preview runs 5–16× faster than Gemma 4, Qwen3.5, and gpt-oss in comparable scenarios. The 13× speedup over comparable 1-bit/ternary models (like 1-bit Bonsai 27B) is particularly notable because it shows the native-ternary training approach outperforms post-hoc quantized models at the same precision level.
How Well Does Maple-Preview Reason?
DeepGrove benchmarked Maple-Preview against four standard reasoning and coding evaluations. All scores are as reported by DeepGrove and have not yet been independently verified by a third party.
| Benchmark | Maple-Preview Score | What It Tests |
|---|---|---|
| AIME 2026 | 87.5% | American Invitational Mathematics Examination |
| HMMT 2026 | 78.8% | Harvard-MIT Mathematics Tournament |
| LiveCodeBench v6 | 75.1% | Competitive programming |
| GPQA-Diamond | 73.5% | Graduate-level science reasoning |
| Average | 78.7% | Across all four |
Source: DeepGrove launch page and Hugging Face model card, August 2026.
For comparison, Qwen3.5 35B-A3B — a larger model with 3 billion active parameters — achieves an 82.9% average across the same benchmarks, edging out Maple-Preview primarily on GPQA-Diamond (84.2% vs 73.5%). Maple-Preview is within a few points of every comparison model in DeepGrove's table while having by far the smallest active parameter count and the fastest on-device speed.
The honest caveat: this is a preview release. The model card explicitly warns that Maple-Preview "received minimal post-training for agentic tasks and only small-scale general reinforcement learning." In other words, pure reasoning (math, coding analysis) is strong, but complex tool-use chains and agentic workflows may not hold together reliably yet.
How to Run Maple-Preview Locally on a Mac
Running Maple-Preview on Apple Silicon takes five commands and about 10 minutes (the 5 GB download is the slow part). Here is the verified setup from DeepGrove's official GitHub repository:
Prerequisites
- Any Apple Silicon Mac (M1 or later) with at least 16 GB of RAM
- uv (the Python package manager)
Step 1: Clone the runtime
git clone https://github.com/deepgrove-ai/mlx-lm-deepgrove.git ~/maple-mlx
cd ~/maple-mlx
DeepGrove ships a fork of mlx-lm (Apple's ML framework for text models) that understands Maple's ternary weight format.
Step 2: Set up the environment
./setup.sh
source .venv/bin/activate
This creates a virtual environment and installs the forked mlx-lm as an editable package.
Step 3: Download the model weights
huggingface-cli download deepgrove/maple-preview-2bit-mlx --local-dir maple-2bit-mlx
The 2-bit MLX checkpoint is 5.31 GB. This is the coffee-break step — let it download while you do something else.
Step 4: Generate your first response
python -m mlx_lm generate --model ./maple-2bit-mlx --trust-remote-code \
--flash-head --prompt "Write a haiku about a grove." \
--temp 1.0 --top-p 0.95 --top-k 20
The --flash-head flag is a free speed boost — it runs a ~2-minute k-means clustering step on the vocabulary head on first launch, then restricts exact logit computation to the top 512 clusters. Keep it on.
Step 5: Start an interactive chat
python -m mlx_lm chat --model ./maple-2bit-mlx --trust-remote-code \
--max-tokens -1 --temp 1.0 --top-p 0.95 --flash-head
Step 6 (optional): Serve it as a local API
python -m mlx_lm server --model ./maple-2bit-mlx --trust-remote-code \
--flash-head --port 8124 --host 127.0.0.1
This gives you a local OpenAI-compatible endpoint at http://127.0.0.1:8124/v1. Any tool that accepts an OpenAI base URL — scripts, agent frameworks, editors — can now use Maple for free local reasoning. For guidance on wiring local models into a broader AI stack, see our guide on building an agentic operating system in 2026.
How to Run Maple-Preview on Non-Apple Hardware
The MLX runtime is Apple Silicon only. For other platforms, DeepGrove provides several options:
CUDA (NVIDIA GPUs): The Transformers implementation requires Triton and FlashAttention in a compatible CUDA environment. You can load it with:
from transformers import pipeline
pipe = pipeline("text-generation", model="deepgrove/maple-preview", trust_remote_code=True)
pipe([{"role": "user", "content": "Who are you?"}])
You can also serve it via vLLM or SGLang, both of which provide OpenAI-compatible API endpoints.
Docker: docker model run hf.co/deepgrove/maple-preview pulls and runs the model in a container.
Browser (WebGPU): A free demo is available on Hugging Face Spaces, running the model entirely in your browser via WebGPU. This is a good way to test the model before committing to the 5 GB download.
llama.cpp / Ollama / LM Studio: Community quantizations are available on Hugging Face (look for models tagged base_model:quantized:deepgrove/maple-preview).
What Are the Best Use Cases for Maple-Preview?
Based on the model's strengths (fast local reasoning, math, coding) and its stated limitations (minimal agentic post-training), here are the use cases where Maple-Preview shines today:
1. Offline reasoning and math
Competition-level math and analytical reasoning is the model's strongest suit. If you're a student, researcher, or developer working through complex problems, you can get step-by-step reasoning at 200+ tok/s with no internet connection — on a plane, in a dead zone, or in a secure environment where cloud APIs aren't allowed.
2. Private data analysis
Because nothing leaves your machine, Maple-Preview is suitable for reasoning over sensitive documents — contracts, financials, client strategy, medical notes — where sending data to a cloud API is a compliance or confidentiality risk. This also makes it useful for open-source AI models in 2026 where trust and control matter.
3. Free idea triage
Batch your rough thinking — outlines, first-draft analysis, brainstorming — through Maple locally at $0 cost, and reserve cloud API credits only for final polish where a frontier model's extra quality matters.
4. Local API for your tool stack
The OpenAI-compatible server mode means you can point existing tools, scripts, and agent frameworks at http://127.0.0.1:8124/v1 and get free reasoning behind the scenes. For teams building open-source AI agent tools, this eliminates a significant per-token cost line item.
5. On-device prototyping
If you're building an app that needs a reasoning model and you want it to work offline on consumer devices (including iPhones at 127 tok/s), Maple-Preview is the first credible open-source option for that use case.
What Are Maple-Preview's Limitations?
Being honest about what it can't do yet is important — this is a preview release, not a finished product.
No agentic reliability yet. DeepGrove explicitly warns the model had "minimal post-training for agentic tasks." Multi-step tool use, long agent chains, and complex instruction following may break down even where pure reasoning holds. If your workflow needs autonomous AI agents that take real-world actions, use a frontier cloud model for now.
Text only. Maple-Preview handles text input and output only. No images, no audio, no multimodal reasoning.
Vendor-reported benchmarks. All speed and quality numbers come from DeepGrove's own testing (except the mlx-lm benchmark table which is reproducible from the public repo). No independent third-party benchmark has been published yet. The benchmark scores should be treated as vendor claims until verified independently.
Preview, not full release. DeepGrove plans a full Maple release with scaled agentic training, extended RL, and an on-device learning feature. The preview is a research checkpoint, not a production-ready system.
Not for building/coding agents. The model reasons well but has not been trained for the agentic coding workflow pattern (read repo → edit → test → iterate) that modern coding agents use. It can analyze code and solve algorithmic problems, but should not be your primary coding agent.
What Is On-Device Learning and Is It Available Yet?
One of the most ambitious features DeepGrove has demonstrated (but not fully shipped in this preview) is on-device weight adaptation, which they call "dreaming." The concept: the model observes interactions, identifies facts or patterns worth remembering, and then during idle time, fine-tunes its own weights on a small locally-generated dataset to absorb those preferences into the model itself — not into a context window or a separate memory file.
This is different from how "personalization" works today, which typically means loading a large context window and hoping the model remembers. The "dreaming" approach adapts at the parameter level. The model literally changes to become more tuned to your patterns and preferences over time, on your own hardware, with no data touching a server.
DeepGrove has demoed an early version of this, but it is not fully built out in the preview release. The full Maple release is expected to include this feature. This is a direction worth watching because it represents a fundamentally different model of personal AI — one that adapts to you privately rather than learning from you centrally. For teams thinking about how to use an agent operating system with shared memory, this on-device adaptation approach could eventually replace context-window strategies for long-term personalization.
Maple-Preview vs Other Local AI Models: How Does It Compare?
| Model | Total Params | Active Params | Weights | Checkpoint | Speed (M4 Mac mini) | License |
|---|---|---|---|---|---|---|
| Maple-Preview | 20.2B | 1.49B | Ternary (2-bit) | 5.31 GB | 218 tok/s | MIT |
| Gemma 4 | ~12B | 12B (dense) | BF16 | ~24 GB | ~14–40 tok/s* | Gemma (permissive) |
| Qwen3.5 9B | 9B | 9B (dense) | BF16 | ~18 GB | ~20–30 tok/s* | Apache 2.0 |
| gpt-oss 20B | ~20B | ~3.4B | INT4/MoE | ~10 GB | ~15–25 tok/s* | Apache 2.0 |
| Qwen3.5 35B-A3B | 35B | 3B | BF16/MoE | ~70 GB | Not practical on M4 | Apache 2.0 |
Speeds for non-Maple models are estimated comparisons as reported by DeepGrove; actual speeds vary by runtime and quantization. These are not independent benchmarks.
The comparison to Qwen3.5 35B-A3B is the most interesting because it's the one model that edges Maple on quality (82.9% average vs 78.7%), but it's a 70 GB model that won't run comfortably on a Mac mini. Maple gets within 4.2 points of a model more than 3× its total size while running dramatically faster.
What This Means for You
If you're a developer, researcher, or small business owner who has been paying per-token for reasoning API calls, Maple-Preview presents a concrete opportunity to cut costs on the reasoning-heavy 80% of your workload. Set up the local server, point your scripts at it, and let the cloud API handle only the final 20% where a frontier model's extra quality matters.
If you're building AI-powered products, the existence of a credible reasoning model that runs on consumer hardware (including phones) opens up product categories that were previously impossible: fully offline AI assistants, privacy-first analysis tools, and apps that embed reasoning without a per-user API cost.
If you're evaluating open-source AI for your organization, Maple-Preview is worth a hands-on test even if you don't deploy it immediately. The ternary-weight approach is early, but if it delivers on its promise of "big model quality at tiny model cost," other labs will follow, and the economics of hosted reasoning APIs will shift. Understanding the architecture now will help you evaluate what comes next.
The one thing not to do: treat this preview as a drop-in replacement for a production reasoning API. It's not there yet. Use it for what it's strong at — local, fast, private reasoning — and keep your cloud model for agentic workloads until the full release.
FAQ
Q: Is Maple-Preview free to use commercially?
A: Yes. Maple-Preview is released under the MIT license, which permits commercial use with no restrictions. You can download it, modify it, and ship it in a product without paying anyone. There are no per-token API costs because the model runs on your own hardware.
Q: How much RAM do I need to run Maple-Preview?
A: You need at least 16 GB of RAM on an Apple Silicon Mac. The model peaks at 6.92 GB of memory usage on a MacBook Pro M5 Pro with the --flash-head optimization enabled. Any M-series Mac with 16 GB is comfortable; 8 GB machines may struggle with the full 131K context window.
Q: Can Maple-Preview replace my ChatGPT or Claude subscription?
A: Not for everything. Maple-Preview excels at reasoning, math, and coding analysis, but it's a text-only model with minimal agentic training. If your workflow depends on tool use, web browsing, image handling, or complex multi-step agent chains, you still need a cloud model. Think of Maple as a free, private accelerator for the reasoning-heavy tasks you do most.
Q: Who made Maple-Preview?
A: Maple-Preview was built by DeepGrove, an AI company. They announced the model on August 4, 2026 and published the weights on Hugging Face under the MIT license. The Apple Silicon runtime is available on GitHub.
Q: What does "20B-A1B" mean?
A: "20B-A1B" means 20 billion total parameters with approximately 1 billion active parameters (officially 1.49B in the model card). The model uses a mixture-of-experts architecture with 256 expert sub-networks, only 8 of which activate for any given token. You get the knowledge capacity of a 20B model with the inference cost of a ~1.5B model.
Q: What are ternary weights and why do they matter?
A: Ternary weights store each model parameter as one of three values (-α, 0, or +α) instead of the standard 16-bit floating-point number. This makes the model file dramatically smaller (5.31 GB vs ~38 GB in full precision) and the math dramatically faster, because operations on ternary values use simple addition instead of complex floating-point multiplication. DeepGrove trained the model natively at ternary precision (rather than quantizing an existing model), which preserves reasoning quality.
Q: When will the full Maple release come out?
A: DeepGrove has not announced a specific date. The preview is focused on raw reasoning quality. DeepGrove says the full release will include scaled agentic training, extended reinforcement learning, and the on-device weight adaptation ("dreaming") feature. Until then, the preview is best used for reasoning tasks, not agentic workflows.
Every claim here is traced to a primary source, dated, and listed under Sources. Research and drafting are AI-assisted; editing, verification and publication are human decisions, and a person is accountable for what appears on this page. How we work →
Discussion
0 comments