license: apache-2.0
pretty_name: Smarty Pants Mac Benchmarks
tags:
- mlx
- apple-silicon
- benchmark
- quantization
configs:
- config_name: results
data_files: results.json
Smarty Pants Mac Benchmarks
Speed and quality for open models on real Apple Silicon Macs, made with our open model factory. Each section is one model on one Mac. The bold row is the base version; the rows marked ↳ are versions we built or tested to make it faster, smaller or smarter, measured the same way on the same Mac.
A version counts as better only if it is faster or smaller and its answers stay as good, or if its answers get better at the same speed. Everything else is listed anyway, so you can see what did not work.
Summary
| Model | Mac | Base speed | Best version | Its speed | Its quality |
|---|---|---|---|---|---|
| Qwen3.5-4B (Smarty) | Apple M5 Pro (Mac mini) | 99.7 tok/s, quality 86.5% | base is still best | ||
| Qwen3.5-4B (Smarty), GSM8K math | Apple M5 Pro, 64 GB (Mac mini) | 99.7 tok/s, quality 89.0% | base is still best | ||
| Qwen3.5-4B (Smarty), draft-ahead decoding | Apple M5 Pro, 64 GB (Mac mini) | 95.9 tok/s, quality 89.0% | base is still best | ||
| Qwen 3.8 27B | Apple M5 Pro (Mac mini) | 35.7 tok/s, quality 90.9% | base is still best | ||
| Qwen 3.8 27B, draft-ahead decoding | Apple M5 Pro, 64 GB (Mac mini) | 17.8 tok/s, quality 91.5% | Standard 4-bit + guess 4 words ahead (test only, off in the app) | 32.2 tok/s | 91.5% |
| Qwen3.6-35B-A3B | Apple M3 Max, 36 GB (MacBook Pro) | 61.4 tok/s, quality – | base is still best | ||
| Qwen3.5-0.8B | Apple M5 Pro (Mac mini) | 120.0 tok/s, quality 7% | Qwen3.5-0.8B + MIT CSAIL's p50c weight edit (reproduced) | 120.0 tok/s | 33% |
Quality means something different per test, so compare it only within one section.
Results
Qwen3.5-4B (Smarty) on Apple M5 Pro (Mac mini)
Measured 2026-10-22.
| Version | Speed (tok/s) | vs base | Peak memory | Quality (top-1 match vs 8-bit) | Perplexity | Checks | Verdict |
|---|---|---|---|---|---|---|---|
| Standard 4-bit (what we serve) | 99.7 | 4.13 GB | 86.5% | 14.60 | 10/10 | base | |
| ↳ MXFP4 (4-bit float) | about 104 | +4% | – | – | about 15.2 | – | no gain: 4% faster but 4% worse quality |
| ↳ 4-bit, finer groups (g32) | about 91 | -9% | – | – | 14.54 | – | slower: slightly better quality, 9% slower |
| ↳ Mixed 3/6-bit | 13-20% faster | 9-13% less | – | +31-36% | – | worse: too lossy | |
| ↳ 3-bit | 13-20% faster | 9-13% less | – | +31-36% | 9/10 | worse: too lossy, 1 wrong answer | |
| ↳ Standard 4-bit + 8-bit attention memory | same | – | – | – | – | no gain: no difference on short chats | |
| ↳ 8-bit copy (quality yardstick, not served) | 57.0 | -43% | – | 100.0% | – | – | reference: more bits, slower |
How it was measured: Speed: output tokens per second on a short chat (median of 3 after a warm-up). Memory: peak during a 4,096-token prompt. Quality: how often the version picks the same next word as a near-lossless 8-bit copy (top-1 match), plus 10 short questions with one right answer.
Takeaway: the standard 4-bit build is still the best tradeoff. Speed tracks how many bits each weight uses, and below 4 bits quality drops sharply. Next to try: DWQ 3-bit.
Entered from the factory report as posted on the day; the full result files are on the Mac mini. Rows marked 'about' will be exact after the next run.
Qwen3.5-4B (Smarty), GSM8K math on Apple M5 Pro, 64 GB (Mac mini)
Measured 2026-11-05.
| Version | Speed (tok/s) | vs base | Peak memory | Quality (GSM8K, 500 problems right) | Paired vs base | Verdict |
|---|---|---|---|---|---|---|
| Standard 4-bit (what we serve) | 99.7 | 4.13 GB | 89.0% | base | ||
| ↳ DWQ 3-bit (tuned to copy the full model) | 120.1 | +20% | 3.62 GB | 83.6% | +14 / -41 (p < 0.001) | worse: faster and smaller, but 2.5 to 8.3 points fewer right |
| ↳ DWQ 4-bit (tuned to copy the full model) | 100.4 | +1% | 4.13 GB | 88.4% | +20 / -23 (p = 0.76) | no gain: same speed, no real difference in right answers |
How it was measured: 500 GSM8K grade-school math problems (openai/gsm8k test, seed 0), the same for every version, served the way Smarty Pants serves Smarty: thinking off, greedy, up to 1,024 tokens. DWQ builds: mlx-lm DWQ, 1,024 samples, group size 64. A version is better only with more right answers at McNemar p < 0.05; faster counts only if the 95% interval of the accuracy change stays above -2 points. Script: scripts/model-factory/benchcheck.py.
Takeaway: neither DWQ build beats the one we serve. 3-bit DWQ is about 20% faster and 13% smaller but gets about 5 points fewer right; 4-bit DWQ is no different. The served build stays. We keep negative results on the page.
Qwen3.5-4B (Smarty), draft-ahead decoding on Apple M5 Pro, 64 GB (Mac mini)
Measured 2026-11-05.
| Version | Speed (tok/s) | vs base | Peak memory | Quality (GSM8K, 500 problems right) | Paired vs base | Verdict |
|---|---|---|---|---|---|---|
| Standard 4-bit (what we serve) | 95.9 | 2.90 GB | 89.0% | base | ||
| ↳ Standard 4-bit + guess 4 words ahead | 105.2 | +10% | 3.43 GB | 88.8% | +4 / -5 (p = 1.0) | no gain: 10% faster, same right answers, but 18% more memory |
| ↳ Standard 4-bit + guess 2 words ahead | 93.2 | -3% | 3.43 GB | 88.2% | +4 / -8 (p = 0.39) | slower: 3% slower and 18% more memory |
How it was measured: draft-ahead (speculative) decoding: a small guesser model, mlx-community/Qwen3.5-0.8B-MLX-4bit, proposes 2 or 4 words and Smarty checks them in one pass. Same 500 GSM8K problems and served settings as above (thinking off, greedy, up to 1,024 tokens); the standard build was timed again in the same sitting. Guesses accepted: 85% (2 at a time), 76% (4 at a time).
Takeaway: no win yet. Guessing 4 ahead is 10% faster with the same right answers, but it needs 18% more memory, and our rule allows at most 5% more. Guessing 2 ahead is slower.
Qwen 3.8 27B on Apple M5 Pro (Mac mini)
Measured 2026-11-02.
| Version | Speed (tok/s) | vs base | Peak memory | Quality (top-1 match vs 8-bit) | Perplexity | Checks | Verdict |
|---|---|---|---|---|---|---|---|
| Standard 4-bit (mlx-community) | 35.7 | 18.26 GB | 90.9% | 7.95 | 10/10 | base | |
| ↳ Mixed 3/6-bit | slower | – | – | – | – | worse: slower and lower quality | |
| ↳ Standard 4-bit + 8-bit attention memory | same | – | – | – | – | no gain: no difference on short chats | |
| ↳ 8-bit copy (quality yardstick, not served) | – | – | 100.0% | 7.67 | – | reference: quality yardstick |
How it was measured: Speed: output tokens per second on a short chat (median of 3 after a warm-up). Memory: peak during a 4,096-token prompt. Quality: how often the version picks the same next word as a near-lossless 8-bit copy (top-1 match), plus 10 short questions with one right answer. mlx 0.32.4.
Takeaway: the standard 4-bit build runs well on a 32 GB+ Mac; neither tested change helped.
Entered from the factory report as posted on the day; the full result files are on the Mac mini. Rows marked 'about' will be exact after the next run.
Qwen 3.8 27B, draft-ahead decoding on Apple M5 Pro, 64 GB (Mac mini)
Measured 2026-11-06. Important: this gain was measured greedy with thinking off. When our Mac app served it live at its default settings (temperature 0.6, thinking on), we did not see the speed-up, so the app has draft-ahead turned off again while we find out why. Do not expect this speed from Smarty Pants today.
| Version | Speed (tok/s) | vs base | Peak memory | Quality (GSM8K, 200 problems right) | Paired vs base | Verdict |
|---|---|---|---|---|---|---|
| Standard 4-bit (mlx-community) | 17.8 | 15.80 GB | 91.5% | base | ||
| ↳ Standard 4-bit + guess 4 words ahead (test only, off in the app) | 32.2 | +81% | 16.31 GB | 91.5% | +1 / -1 (p = 1.0) | better: 81% faster, same right answers, 3% more memory (in this test setup; not yet in the live app) |
How it was measured: draft-ahead (speculative) decoding: the small mlx-community/Qwen3.5-0.8B-MLX-4bit guesses 4 words at a time and Qwen 3.8 27B checks them in one pass; 76% of guesses were kept. 200 GSM8K problems, the same for both, measured with mlx-lm in Python, greedy, thinking off, up to 1,024 tokens. The standard build was timed again in the same sitting, with serving paused (this sitting's standard speed is lower than the 35.7 tok/s chat test above, which used a different prompt and length).
Takeaway: draft-ahead made Qwen 3.8 27B 81% faster with the same right answers and only 3% more memory, the first speed-up to beat a standard build on this page.
Qwen3.6-35B-A3B on Apple M3 Max, 36 GB (MacBook Pro)
Measured 2026-09-08.
| Version | Speed (tok/s) | vs base | Peak memory | Quality | Perplexity | Checks | Verdict |
|---|---|---|---|---|---|---|---|
| Standard 4-bit (mlx-community) | 61.4 | 21.52 GB | – | – | – | base |
How it was measured: speed only: one request at a time, 500 to 4,096-token prompts, 128 tokens out, mlx-vlm 0.7.0. With 8 requests at once the Mac produced 193 tok/s in total. No quality test yet.
Qwen3.5-0.8B on Apple M5 Pro (Mac mini)
Measured 2026-11-04.
| Version | Speed (tok/s) | vs base | Peak memory | Quality (MATH-500, 30 problems) | Finished | Verdict |
|---|---|---|---|---|---|---|
| Qwen3.5-0.8B, original | 120.0 | 2.22 GB | 7% | 7% | base | |
| ↳ Qwen3.5-0.8B + MIT CSAIL's p50c weight edit (reproduced) | 120.0 | same | 2.19 GB | 33% | 60% | better: finished 60% of answers (was 7%), ended in a loop 3% (was 87%) |
How it was measured: 30 MATH-500 math problems (seeded random pick), thinking on, up to 32,768 tokens, MIT's sampling settings, 1 answer per problem, graded with math-verify 0.9.0 by MIT's rule. Runs on MLX in bfloat16 rather than vLLM, so single answers are not comparable one to one with MIT's.
Takeaway: the edit changes 0.016% of the weights. On our Mac it cut loops from 87% to 3% and raised correct answers from 7% to 33%, with no change in speed or memory. Problem by problem, the edited model got 8 right that the original missed and lost none (sign test p ≈ 0.008). MIT reports 7.9% to 48.1% on all 500 problems with 4 answers each.
Credit: this is a reproduction of MIT CSAIL's published edit (Takehi, Teoh, Zhang and Khattab, weight-space programming, edit and evaluation code from RikiyaT/lm_understand-logs). Smarty Pants did not make this edit; we rebuilt it bit for bit, hash-checked it and measured it on a Mac.
Use these models without a Mac
Smarty Pants serves models from Macs like these at https://smartypants.network/v1 (OpenAI-compatible). Smarty (smartypants/smarty) is the Qwen3.5-4B standard 4-bit above; see https://smartypants.network for which models are open and their prices.
Data
results.json holds every number on this page, one entry per section, rebuilt by scripts/model-factory/benchmarks.py after each factory run. No prompts, answers or machine identifiers are included.