TurboFieldfare: Run Gemma 4 26B on an 8GB Mac (Complete Install Guide)

Yes — a 26-billion-parameter AI model can now run on an 8 GB MacBook, and the tool that makes it possible is real, open-source, and free. It is called TurboFieldfare, and it runs Google's Gemma 4 26B-A4B in about 2 GB of RAM by keeping only the model's shared core in memory and streaming the rest from your SSD as each token is generated. This guide covers where to get it, how to install it, how to run it, and the honest limits you should know before you start.

What TurboFieldfare actually is

TurboFieldfare is a custom inference engine written in Swift with Metal kernels, built only for Apple Silicon — the package is arm64-only, with no Intel fallback. It is not a wrapper around MLX or llama.cpp, and it is not a general model runner. It runs exactly one pinned checkpoint: the instruction-tuned Gemma 4 26B-A4B, repacked into the project's own .gturbo file layout. A native Mac app, a command-line interface, and an experimental loopback OpenAI-compatible server all share that same installed model.

The headline needs one important qualification, because it is the whole reason the trick works. Gemma 4 26B-A4B is a mixture-of-experts (MoE) model: it has about 26 billion parameters in total, but only around 3.88 billion of them activate for any given token. Per token, the router picks 8 of 128 small routed experts plus one shared expert. A dense 26B model could never be streamed this way — every parameter would be needed for every token, which no consumer SSD could sustain. The MoE design turns "read 14 GB per token" into "read a few hundred megabytes per token," and that is what makes SSD paging viable at all.

How it fits a 26B model into 2 GB of RAM

Instead of loading the whole model into memory, TurboFieldfare keeps a small resident core and treats the SSD as a warehouse:

• Resident (~1.35 GB shared core): embeddings, attention weights, routers, and shared experts, plus the FP16 KV cache. Together with the cache, resident memory during inference is about 2 GB.
• Streamed per token: only the routed experts the current token actually needs, pulled from SSD through a small per-layer LFU expert cache. Expert choice is sticky — the project measured roughly 40% of experts repeating on the next token — so the cache keeps the GPU fed.
• On disk (~14.3 GB): the text model at MLX affine 4-bit weights (group 64, 8-bit router, 4-bit shared and routed experts). An optional vision pack adds about 1.1 GB.

The installer is memory-bounded too: it streams byte ranges from the pinned Hugging Face revision and repacks them directly into the .gturbo layout as they arrive, so it never materializes the full source checkpoint on your disk. The completed install is accepted only after its manifest and file hashes validate.

Speed is honest, not magic. The project reports 5.1–6.3 tokens per second on an 8 GB M2 MacBook Air and 31–35 tokens per second on a 24 GB M5 Pro, and its own README calls those figures a reference point, not a ceiling — prompt length, generated length, page-cache state, and hardware all move the number. On the base Air, 5–6 tokens per second is usable for writing and analysis, not fast chat. The gap to the M5 Pro mostly tracks storage latency (about 83 ms per expert read on the M2 Air versus 12 ms on the M5), not GPU power.

Requirements: check before you download

• An Apple Silicon Mac. The validated target is an 8 GB M2 MacBook Air; M1 Macs can run the text model, but the vision pack needs M2 or newer.
• macOS 26 with Metal 4, plus Apple Command Line Tools or Xcode with Swift 6.2+ and the macOS 26 SDK or newer. Older macOS and Metal versions are not supported.
• About 15 GB of free disk space for the first install (14.3 GB installed), plus about 1.1 GB more if you want image support.
• An internet connection for the first model install only. After that, everything runs offline.

Where to get it

The only source you should use is the project's own GitHub repository: github.com/drumih/turbo-fieldfare. It is released under Apache 2.0. Do not download "TurboFieldfare" builds from random mirror sites — the installer hash-checks the pinned Hugging Face checkpoint, and an unofficial build would bypass exactly that protection. The model weights themselves come from Google's Gemma 4 family, which is also Apache 2.0.

How to install it, step by step

Step 1 — Clone the repository. Open Terminal and run:

git clone https://github.com/drumih/turbo-fieldfare.git
cd turbo-fieldfare

Step 2 — Build the release version. This builds the Mac app and its sibling decode-service executable. On the first run, Swift Package Manager downloads and builds the Swift packages the tokenizer needs, so the first build takes a while:

swift build -c release
.build/release/TurboFieldfareMac

Step 3 — Download the model inside the app. When the app opens, choose Download Model and let it fetch and repack the pinned model — about 15 GB transferred, 14.3 GB installed. Network speed and Hugging Face response times vary, so this can take a while. If you already have a model folder, choose Use Existing Model… and select its .gturbo folder instead. New installs default to scratch/gemma4.gturbo in the checkout, and the app remembers a location you choose.

Step 4 — Load it and generate. Choose Load Model, type your prompt, and press Generate (or Command+Return). The app treats what you type as an instruction and handles Gemma's chat formatting automatically. Send another message to continue the conversation, or choose New Chat to start over. The status bar shows generation progress, decode speed, and memory use.

Optional — Build a double-clickable app. From the repository root, run Scripts/build_app.sh. It creates dist/TurboFieldfare.app, which you can double-click or move to Applications (add --install to copy it to ~/Applications). The bundle uses ad-hoc signing, so no Apple developer account is required. Settings and chats live in ~/Library/Application Support/TurboFieldfare/.

Optional — Add image support. The vision tower installs as a companion pack beside the text model (gemma4.vision.gturbo next to gemma4.gturbo), about 1.1 GB, from the app's Image Support section or from the command line. Without it, the app simply says image support is unavailable, and the text runtime is untouched. Remember: vision needs an M2 or newer Mac.

Command-line and local server setup

If you prefer the terminal, the CLI uses an existing .gturbo installation. Install from the command line with:

swift run -c release TurboFieldfareRepack \
  --output scratch/gemma4.gturbo \
  --overwrite

Resume an interrupted download with --resume, and verify an install without loading the model with --verify-install --input-gturbo scratch/gemma4.gturbo. For a chat from the terminal, put your messages in a JSON file and run:

swift run -c release TurboFieldfareCLI \
  --model scratch/gemma4.gturbo \
  --messages-file messages.json

The CLI response limit defaults to 1,024 tokens (--max-new); the Mac app can generate until the selected context window is full. Generation defaults are temperature 0.2, Top-K 64, Top-P 0.95 — set temperature to 0 for deterministic output. For app-style access from your own tools, build the experimental server with swift build -c release --product TurboFieldfareServer and run it against your model; it listens on http://127.0.0.1:8080/v1 with Chat Completions and streaming. Keep it on loopback — it has no remote authentication or TLS — and note that the server only returns model-produced tool calls; your client must authorize and run every tool call itself.

Honest limitations (read before you rely on it)

• One model only. This runs the pinned Gemma 4 26B-A4B instruction-tuned checkpoint and nothing else. It will not run your other downloaded models.
• Usable speed, not fast speed. 5–6 tokens per second on a base M2 Air is fine for drafting and analysis; it is not a snappy chatbot experience.
• The 2 GB figure has conditions. It covers weights plus a 4K-context KV cache. Longer contexts grow resident memory, and the model can still repeat itself or give incorrect answers — the project says so itself, so check important results.
• Quality is unbenchmarked for this build. The published record covers throughput (103 measured experiments across kernels, caching, I/O, prefill, and decode), not quality scores for the 4-bit quantized model.
• SSD traffic is real. Streaming experts is a read workload — the .gturbo file is written once at install and then only read — but if memory pressure pushes macOS into heavy swapping, that swapping writes. Before a run, close memory-heavy apps, check memory_pressure -Q, and run only one TurboFieldfare process at a time.
• Platform lock-in. macOS 26, Metal 4, Swift 6.2, arm64-only. If your Mac cannot run macOS 26, this tool cannot run on it at all.

Local or cloud: which should you pick?

Local wins on privacy and cost: your prompts and documents never leave the device, there is no subscription, and after the one-time download you can work offline. The cloud still wins on raw speed, model choice, and quality at the top end — a hosted frontier model will out-write and out-reason a 4-bit 26B MoE, and you never maintain anything. The right answer depends on the job: private drafting, coding help, and document analysis on your own files favour local; the hardest reasoning and the biggest models still favour the cloud. TurboFieldfare is interesting precisely because it moves the local option from "small models only" to "a genuinely capable 26B-class model on the cheapest Mac Apple sells."

Frequently asked questions

Will it work on my Intel Mac? No. TurboFieldfare is Apple Silicon only (arm64), and it needs macOS 26 with Metal 4.

Do I need 16 GB of RAM? No — 8 GB is the validated target. Just close memory-heavy apps first and run only one TurboFieldfare process at a time.

Is it really the full 26B model? The full 26B weights are on your disk at 4-bit, but only about 3.88B parameters activate per token. You are getting a very good sparse model, not a dense 26B — that distinction is exactly why the memory trick works.

Is my data sent anywhere? Your prompts and generations stay on your device. The only download is the model itself from Hugging Face during the first install.

Can it run other models I already have? No. It is deliberately single-model: this one pinned Gemma 4 checkpoint, in its own .gturbo format.

Sources: TurboFieldfare README and docs (github.com/drumih/turbo-fieldfare); Google Gemma 4 model card and docs; Amazon Bedrock Gemma 4 26B-A4B model card (25.2B total parameters, 3.8B active per token, 256K context).