TurboFieldfare Review 2026 — Run Gemma 4 26B in ~2GB RAM on Any Apple Silicon Mac
✅ Pros
- • Runs a 26B-parameter model in just ~2GB of RAM — works on entry-level 8GB MacBook Air, not just high-end Pro machines
- • Custom Swift + Metal implementation is highly optimized: 103 measured experiment results documented in the repo
- • M2 decode at 5.1-6.3 tok/s, M5 Pro at 31-35 tok/s — genuinely usable generation speeds even on modest hardware
- • Includes native Mac app, CLI, and OpenAI-compatible server — flexible deployment options
- • SSD-streamed routed experts keep memory usage bounded without sacrificing model quality
- • Apache 2.0 license with transparent experiment records — full reproducibility
⚠️ Cons
- • macOS 26 + Metal 4 required — no support for older macOS versions or Intel Macs
- • ~14.3GB model download on first run — requires significant free storage and bandwidth
- • Text-only inference: no image, audio, or video support currently
- • Model-specific (Gemma 4 26B only) — not a general-purpose local LLM runtime like llama.cpp or MLX
- • Tool calling requires client-side authorization — not fully autonomous
- • Early-stage project with a single maintainer; community contributions still limited
Apple Silicon Mac users who want to run a capable open-source LLM locally without expensive hardware upgrades, especially developers testing model behavior, writing agents, or privacy-sensitive workflows
Free (open source, Apache 2.0)
Quick Verdict
TurboFieldfare is the most impressive local LLM runtime I’ve tested on Apple Silicon. It solves the exact problem that’s been frustrating Mac users since the RAM price hike: running serious models on modest hardware. By streaming experts from SSD instead of keeping them all in memory, it runs Gemma 4 26B-A4B in roughly 2 GB of RAM — about 15% of what a naive load would require.
At a 7-8/10 overall, it earns Silver tier. The core innovation is real and well-executed, but the macOS 26 requirement, single-model limitation, and early-stage ecosystem keep it from Gold.
What Is TurboFieldfare?
TurboFieldfare is a custom Swift + Metal inference runtime purpose-built for running Google’s Gemma 4 26B-A4B instruction-tuned model on Apple Silicon Macs. It uses expert streaming — loading only the active routed experts from SSD per token — to keep memory usage at about 2 GB instead of the model’s full 14.3 GB footprint.
Created by Andrey Mikhaylov, an iOS and Metal engineer, the project is named after the fieldfare bird. The repository documents 103 measured experiments across kernel optimization, caching strategies, I/O patterns, prefill, and decode.
How Expert Streaming Works
Gemma 4 26B uses a Mixture-of-Experts (MoE) architecture: while it has 26 billion total parameters, only about 3.88 billion are active per token. The model has a shared 1.35 GB “core” (attention + shared experts) and routed experts that get swapped in as needed.
TurboFieldfare’s key insight: keep the shared core and FP16 KV cache in memory, then stream only the top-8 routed experts from SSD per layer. An LFU (Least Frequently Used) cache holds 16 expert slots per layer to minimize repeated SSD reads for common patterns.
| Component | Memory |
|---|---|
| Shared weights + Router | ~1.35 GB |
| KV Cache (4K context) | ~0.5 GB |
| Expert cache (16 slots/layer) | ~0.3 GB |
| Total | ~2.0 GB |
Installation Walkthrough
The build process is straightforward but requires the latest Apple developer tools:
git clone https://github.com/drumih/turbo-fieldfare.git
cd turbo-fieldfare
swift build -c releaseThe full release build takes about 2 minutes on an M-series Mac and produces six executables. On first launch of the Mac app, you choose Download — it fetches about 15 GB from Hugging Face using range requests, repacking directly into the .gturbo format without staging the full checkpoint on disk.
# Launch the Mac app
.build/release/TurboFieldfareMac
# Or use the CLI
swift run -c release TurboFieldfareCLI \
--model scratch/gemma4.gturbo \
--prompt "Explain the difference between MoE and dense transformers" \
--max-new 256Performance Benchmarks
TurboFieldfare’s published benchmarks are measured on real hardware:
| Hardware | Decode Speed | Memory Used |
|---|---|---|
| M2 MacBook Air (8GB) | 5.1–6.3 tok/s | ~2.1 GB |
| M3 MacBook Pro (16GB) | 12–15 tok/s | ~2.1 GB |
| M4 Pro (24GB) | 22–26 tok/s | ~2.1 GB |
| M5 Pro (24GB) | 31–35 tok/s | ~2.2 GB |
The 5 tok/s on an 8GB M2 Air is genuinely usable for chat — it’s about the speed of reading a dense paragraph. The M5 numbers are competitive with cloud-hosted compact models.
Prefill performance varies by chunk size: the runtime uses chunks of up to 128 tokens so one fetched expert set can serve multiple positions. Long-context prefill got a significant speedup in the 0.3 release (Apple10 optimization, July 29).
Mac App Experience
The native Mac app is built with SwiftUI and AppKit, with a one-shot decode service process handling the Metal workload. The interface shows:
- Composer — Type prompts, press Cmd+Return to generate
- Status bar — Generation progress, decode speed (tok/s), memory pressure
- Right pane — Sampling controls (temperature, Top-K, Top-P), context length, expert cache slots
- Output view — Streaming token-by-token display with stop/escape to end early
The app handles Gemma’s chat formatting automatically, so you just type instructions. Temperature defaults to 0.2, Top-K to 64, and Top-P to 0.95.
OpenAI-Compatible Server
The loopback server at http://127.0.0.1:8080/v1 supports Chat Completions, streaming, and function tool declarations. The client must authorize and run each tool call — the server won’t execute anything autonomously.
import openai
client = openai.OpenAI(base_url="http://127.0.0.1:8080/v1")
response = client.chat.completions.create(
model="gemma-4-26b-a4b",
messages=[{"role": "user", "content": "Write a Python function to merge two sorted lists."}]
)
print(response.choices[0].message.content)This makes TurboFieldfare usable as a drop-in local backend for tools that support OpenAI-compatible APIs, such as OpenCode, Continue.dev, or custom agent pipelines.
Pricing
TurboFieldfare is completely free and open source under the Apache 2.0 license. Model weights from Google are governed by Gemma 4’s terms but are freely downloadable via the installer. The only cost is storage (~14.3 GB) and compute time.
What the Community Says
On Hacker News, the project hit 594 points on its launch day with overwhelmingly positive discussion. The top comments focused on the engineering quality (“103 experiments documented is proper science”) and the practical value (“finally something that makes the 8GB MacBook Air useful for local LLMs”).
The GitHub repository has rapidly accumulated 913 stars and 27 forks within two weeks of public release. The active issue tracker shows engaged discussion around GPU kernel improvements and future features.
Pros and Cons
Pros
- Memory efficiency is genuine — 2GB for a 26B model is not marketing fluff, the expert streaming is well-engineered
- Polish matters — native Mac app feels better than any web wrapper or Electron shell
- 103 documented experiments — this isn’t a hack, it’s a methodically optimized runtime
- OpenAI-compatible API — integrates with existing tools without custom adapters
- Apache 2.0 — no restrictions on commercial use or modification
Cons
- macOS 26 only — if you’re on macOS 15 Sequoia or earlier, you can’t run it
- Single model — unlike llama.cpp or MLX, this runs only Gemma 4 26B
- No multimodal — text generation only, no vision or audio
- 15GB download — the model installation requires significant bandwidth
- Single maintainer — bus factor is a concern for long-term viability
Alternatives
| Tool | TurboFieldfare | llama.cpp | MLX | LM Studio |
|---|---|---|---|---|
| Models | Gemma 4 26B only | 1000+ models | 200+ models | 500+ models |
| Memory | ~2 GB | Varies by model | Varies by model | Varies by model |
| Hardware | Apple Silicon only | CPU/GPU/Apple | Apple Silicon | CPU/GPU |
| UI | Native Mac + CLI + API | CLI + API | Python API | Desktop app |
| macOS version | 26+ | Any | Any | Any |
| License | Apache 2.0 | MIT | MIT | Proprietary |
TurboFieldfare wins on memory efficiency for its specific model, but loses on flexibility. If you need to run multiple models, llama.cpp or LM Studio are better choices.
Who Should Use TurboFieldfare
Buy it if: You have an Apple Silicon Mac with at least 8GB RAM, want to run a capable local LLM privately, and don’t mind the single-model constraint.
Skip it if: You need multimodal capabilities, prefer running multiple models, or are on macOS 25 or earlier.
FAQ
Q: Does TurboFieldfare work on Intel Macs? No. The Metal 4 requirements and ARM64-only binaries mean it only runs on Apple Silicon (M-series) Macs.
Q: How fast is generation on an 8GB M1 MacBook Air? Official benchmarks haven’t been published for M1 yet, but community contributions are welcome. Expect slightly slower than the M2’s 5.1-6.3 tok/s.
Q: Can I use TurboFieldfare as a drop-in for OpenAI API in my apps?
Yes. The loopback server exposes an OpenAI-compatible Chat Completions endpoint. Your app only needs to change the base_url.
Q: How do I update the model when a new version is released?
Re-download via the installer. The .gturbo format allows partial updates, but the current installer re-fetches the full model.
Q: Does it support function calling / tool use? The loopback server accepts tool declarations, but the client must authorize each tool call. The model itself doesn’t execute tools.
Verdict
TurboFieldfare is a genuinely impressive engineering achievement that solves a real problem: running large MoE models on memory-constrained Apple Silicon hardware. The 103 documented experiments, native Mac app, and thoughtful design choices show a maturity rare for a 2-week-old project.
For Mac users priced out of the 48GB+ workstation market, this is the most practical local LLM option available today — as long as you only need the one model it supports.
Overall: 8.0/10 — Silver