Key Takeaways
- TurboFieldfare (github.com/drumih/turbo-fieldfare) is a free, open-source, native Swift/Metal runtime β not a wrapper around llama.cpp or MLX
- Apache 2.0 licensed, confirmed via the GitHub repository's LICENSE file
- Runs exactly one model family: the instruction-tuned Gemma 4 26B-A4B (26B total parameters, about 3.88B active per token)
- Achieves roughly 2 GB RAM use by keeping a 1.35 GB shared core plus a 4K-token KV cache resident, and streaming the remaining mixture-of-experts weights from SSD via
preadcalls during generation - Ships three ways to use it: a native SwiftUI/AppKit Mac app, a command-line interface (TurboFieldfareCLI), and an experimental loopback OpenAI-compatible server (TurboFieldfareServer)
- Requires an Apple Silicon Mac, macOS 26 with Metal 4, and Xcode 26 with Swift 6.2 or newer to build from source β the package is arm64-only
- Over 6,750 GitHub stars and 430+ forks as of this review
π In One Sentence
TurboFieldfare is a free, open-source (Apache 2.0), native Swift-and-Metal runtime for Apple Silicon Macs, with over 6,750 GitHub stars, that runs Google's Gemma 4 26B-A4B model using about 2 GB of RAM by streaming most of its mixture-of-experts weights from SSD instead of loading the full 14.3 GB model into memory.
π¬ In Plain Terms
TurboFieldfare is a free app you build from source on a Mac with an Apple Silicon chip. It lets you run a large (26-billion-parameter) AI model locally even on a Mac with only 8 GB of RAM, because it only keeps a small "core" of the model in memory at once and reads the rest from your disk as needed β no cloud, no subscription, and no other model besides Gemma 4 26B-A4B.
πNote: This review is the deep-dive companion to TurboFieldfare's entry in the Local LLM Software Directory β see that page for how TurboFieldfare compares at a glance to dozens of other local AI tools.
What Is TurboFieldfare?
TurboFieldfare is a model-specific local inference runtime for Apple Silicon Macs, built to run one model β Gemma 4 26B-A4B β within a strict memory budget rather than to support arbitrary models like a general-purpose engine. Its own GitHub README describes it plainly: "Gemma 4 26B-A4B inference in about 2 GB of RAM. A custom Swift + Metal runtime for any Apple Silicon Mac, even the 8 GB ones."
- Product type: a native Swift/Metal runtime, CLI, and Mac app β not a wrapper around llama.cpp or MLX, per its own README
- Scope: model-specific, running only Gemma 4 26B-A4B (instruction-tuned), not a multi-model engine
- Repository: github.com/drumih/turbo-fieldfare, created July 17, 2026
- License: Apache 2.0 for the source code; model weights are governed by Google's own Gemma terms and downloaded separately from Hugging Face
- Scale: over 6,750 GitHub stars, 430+ forks, and 26 open issues as of this review
- Disambiguation: several near-identical repository names and descriptions exist under other GitHub accounts; drumih/turbo-fieldfare is the original, highest-star repository and the one this review covers
TurboFieldfare's Project History and Version Milestones
TurboFieldfare's GitHub repository was created in July 2026, a comparatively recent project, and has shipped several releases since, most recently adding local conversation history to its Mac app.
- 1Repository created β July 17, 2026
Why it matters: TurboFieldfare's canonical GitHub repository (drumih/turbo-fieldfare) was created, per GitHub's repository metadata. - 2v0.7.2 β prior release
Why it matters: The release immediately preceding v0.8.0, referenced in that release's changelog comparison link. - 3v0.8.0 β September 8, 2026: Local conversation history
Why it matters: Per the official release notes, the Mac app began saving conversation history locally, letting users search, rename, delete, and reopen past chats β including saved text and images β from the sidebar. This release is explicitly marked "source-only" with no prebuilt binary assets attached.
What Does TurboFieldfare Actually Do?
TurboFieldfare's feature set centers on making one specific large model usable on modest Apple Silicon hardware. Here is what each part actually does, per its own GitHub README and documentation.
- Streaming expert weights from SSD β instead of loading the full ~14.3 GB Gemma 4 26B-A4B model into memory, TurboFieldfare keeps a 1.35 GB shared core and an FP16 key-value cache resident, and streams only the mixture-of-experts weights needed for each token from disk via
preadcalls, with an LFU (least-frequently-used) eviction policy for SSD-backed expert caching - Custom Metal kernels β hand-written Metal kernels handle quantized GEMV, attention, mixture-of-experts routing, normalization, and sampling, rather than relying on a general-purpose ML framework
- Chunked prefill β a chunked prefill strategy reduces time-to-first-token while keeping memory use bounded, per the project's system design documentation
- Three interfaces, one model store β a native Mac app, a command-line interface (TurboFieldfareCLI), and an experimental loopback OpenAI-compatible server (TurboFieldfareServer) all read from the same
.gturbomodel directory, though only one model-owning process should run at a time - Optional vision tower β image input is supported through a separately installable vision-tower companion pack (about 1.1 GB), which requires an M2 or newer Mac; text-only inference remains available on M1
- No tool execution in the app/CLI β the Mac app and CLI support user/model messages and optional system guidance but do not expose or execute tools; the loopback server accepts function-tool declarations and returns model-produced tool calls for the client to execute, per the README
- Not audio/video capable β per its own documentation, TurboFieldfare does not support audio or video input
Usage Examples: Three Ways to Use TurboFieldfare
These are concrete workflows built from TurboFieldfare's own documented README β not hypothetical use cases.
Install TurboFieldfare
TurboFieldfare has no prebuilt installer β you build it from source using Swift Package Manager, and its source code is on GitHub. Per its own README, the install sequence is: git clone https://github.com/drumih/turbo-fieldfare.git, then cd turbo-fieldfare, then swift build -c release, then run .build/release/TurboFieldfareMac.
Source | Link |
|---|---|
| GitHub repository (source code, Apache 2.0) | github.com/drumih/turbo-fieldfare |
| System design docs (how the runtime works) | docs/SYSTEM_DESIGN.md |
| Benchmarks | docs/BENCHMARKS.md |
| Releases (tagged versions) | github.com/drumih/turbo-fieldfare/releases |
Building requires an Apple Silicon Mac on macOS 26 with Metal 4, plus Xcode 26 and Swift 6.2 or newer β the package is arm64-only, so Intel Macs and other platforms are not supported. On first run, Swift Package Manager downloads and builds required tokenizer packages, and the app then downloads about 15 GB of model weights before you can generate text; confirm the current requirements on the repository README before starting, since they can change between releases.
TurboFieldfare Pricing: Is TurboFieldfare Really Free?
Yes β TurboFieldfare has no paid tier. The source code is Apache 2.0 licensed and free to build and run; there is no subscription, account, or usage limit imposed by the project itself.
- No subscription, no paid tier, no usage limits imposed by TurboFieldfare itself
- No account or sign-up required to build or run the app, CLI, or server
- The Gemma 4 26B-A4B model weights are downloaded once from Hugging Face and are governed by Google's own Gemma model terms, separate from TurboFieldfare's Apache 2.0 source license
- The only ongoing cost is your own hardware and disk space: about 14.3 GB for the text model, plus about 1.1 GB more if you install the optional image-input vision tower
TurboFieldfare vs. Ollama
TurboFieldfare and Ollama solve different problems: Ollama is a general-purpose local model runner that supports a large, growing catalog of open-weight models across macOS, Windows, and Linux, while TurboFieldfare is a single-model, Apple-Silicon-only runtime optimized specifically to fit Gemma 4 26B-A4B into about 2 GB of RAM.
Model support
- TurboFieldfare vs. Ollama:
- TurboFieldfare runs only Gemma 4 26B-A4B; Ollama runs a wide, regularly updated catalog of open-weight models.
Platform
- TurboFieldfare vs. Ollama:
- TurboFieldfare is Apple Silicon macOS only (arm64, macOS 26+); Ollama supports macOS, Windows, and Linux.
Install method
- TurboFieldfare vs. Ollama:
- TurboFieldfare is built from source via Swift Package Manager; Ollama ships a prebuilt installer/binary per platform.
Memory approach
- TurboFieldfare vs. Ollama:
- TurboFieldfare streams most expert weights from SSD to fit an 8 GB Mac; Ollama loads models per your hardware's available RAM/VRAM, typically needing more memory for a comparably large model.
Engine basis
- TurboFieldfare vs. Ollama:
- TurboFieldfare is a custom Swift/Metal runtime, not built on llama.cpp; Ollama is built on llama.cpp (GGML) as its inference core.
If your priority is running one specific, large model on RAM-constrained Apple Silicon hardware, TurboFieldfare's narrow focus is the point. If your priority is flexibility across many models and platforms, Ollama is the broader general-purpose tool β see the Ollama review for full details. Verify current feature details on each project's own site before deciding.
Who Should Use TurboFieldfare?
Whether TurboFieldfare fits depends on whether you specifically want to run Gemma 4 26B-A4B on a memory-constrained Apple Silicon Mac, rather than needing a general-purpose local model runner.
Competitors and Alternatives
TurboFieldfare is most often compared to Ollama and LMDeploy in the local-inference-engine space β its main differentiator is being a narrowly scoped, model-specific runtime rather than a general-purpose engine supporting many models.
Tool | Best known for | Link |
|---|---|---|
| Ollama | General-purpose local model runner with a large model catalog, macOS/Windows/Linux | Ollama review |
| LMDeploy | Toolkit for compressing, deploying, and serving LLMs, with a focus on inference throughput | LMDeploy review |
This list reflects tools commonly compared to TurboFieldfare in the local-inference-engine space, not an independent PromptQuorum ranking β see the Local LLM Software Directory for the full, regularly updated catalog, including TurboFieldfare's own directory entry. Verify each tool's current platform and model support before choosing.
Common Mistakes When Evaluating TurboFieldfare
Most confusion about TurboFieldfare comes from expecting general-purpose engine features it deliberately does not have, or assuming a different repository under the same name.
Frequently Asked Questions
What is TurboFieldfare?
TurboFieldfare (github.com/drumih/turbo-fieldfare) is a free, open-source (Apache 2.0), native Swift-and-Metal runtime for Apple Silicon Macs that runs Google's Gemma 4 26B-A4B model using about 2 GB of RAM.
Is TurboFieldfare free?
Yes, TurboFieldfare's source code is free and Apache 2.0 licensed, with no paid tier. The Gemma 4 26B-A4B model weights are downloaded separately from Hugging Face under Google's own Gemma model terms.
How do I install TurboFieldfare?
Clone the repository, run swift build -c release, then launch .build/release/TurboFieldfareMac. There is no prebuilt installer β TurboFieldfare must be built from source via Swift Package Manager.
What models does TurboFieldfare support?
Only Gemma 4 26B-A4B (instruction-tuned). It is a model-specific runtime, not a general-purpose engine that supports arbitrary models.
How does TurboFieldfare run a 26B model in 2 GB of RAM?
It keeps a 1.35 GB shared core and a small KV cache resident in memory, then streams the model's remaining mixture-of-experts weights from SSD as needed during generation, using custom Metal kernels and an LFU eviction policy for the SSD-backed expert cache.
What hardware does TurboFieldfare require?
An Apple Silicon Mac (M1 or newer for text-only; M2 or newer for the optional vision tower), macOS 26 with Metal 4, and about 14.3 GB of free storage for the text model. Building it requires Xcode 26 and Swift 6.2 or newer.
Does TurboFieldfare support Windows or Linux?
No, the package is arm64-only and requires macOS 26 with Metal 4 β it does not support Windows, Linux, or Intel-based Macs.
Does TurboFieldfare support images?
Yes, through a separately installable vision-tower companion pack (about 1.1 GB), which requires an M2 or newer Mac. Without it, text-only inference still works, including on M1 Macs.
Does TurboFieldfare support tool calling?
The native Mac app and CLI do not expose or execute tools. The experimental loopback OpenAI-compatible server accepts function-tool declarations and returns model-produced tool calls for your client code to execute.
How is TurboFieldfare different from Ollama?
TurboFieldfare runs only Gemma 4 26B-A4B on Apple Silicon Macs via a custom Swift/Metal runtime; Ollama is a general-purpose, cross-platform model runner built on llama.cpp supporting a much wider model catalog. See the TurboFieldfare vs. Ollama comparison above.
Has PromptQuorum independently tested TurboFieldfare's claims?
This review is based on TurboFieldfare's own GitHub repository, README, and documentation, rather than hands-on benchmarking by PromptQuorum.