Run Gemma 4 26B on a Mac in 2GB RAM: TurboFieldfare

On July 29, 2026, a developer working under the handle drumih released TurboFieldfare, an open-source inference engine that runs Google's Gemma 4 26B language model in roughly 2GB of RAM on any M-series Mac. The project passed 800 points on Hacker News and crossed 1,600 GitHub stars within a day, because it does something that was supposed to be out of reach on an 8GB MacBook Air: it loads and runs a 26-billion-parameter model without a 32GB workstation or a cloud bill.

TurboFieldfare is written in Swift and Metal, released under the Apache 2.0 license, and it works by streaming model experts from your SSD instead of holding all 14.3GB of weights in memory at once. For creators and builders who want private, offline access to a capable open model, it turns a consumer laptop into a usable local AI workstation. Here is what shipped, how the memory trick works, and how to install and run it today.

What Happened

TurboFieldfare targets Gemma 4 26B-A4B, a Mixture-of-Experts variant of Google's Gemma 4 family that carries 26 billion total parameters but activates only about 4 billion of them per token. The engine keeps a 1.35GB core plus the KV cache resident in memory, then streams the specific experts a token needs from disk and releases them afterward. That is how weights that occupy 14.3GB on disk can run inside a 2GB memory footprint.

The launch was a Show HN post that climbed past 800 points and hundreds of comments in its first day, as documented in the Hacker News discussion. Commenters reported the engine running on base-model MacBook Air and Mac mini hardware, the exact machines that previously could not touch a model this size. The repository shows a fast-moving codebase with commits landing through launch day, and the maintainer answering setup questions in real time.

Why It Matters

Until now, running a 26B-class model locally meant either a Mac with 32GB or more of unified memory or aggressive quantization that hurt output quality. TurboFieldfare removes that hardware wall. A base MacBook Air, the most common Mac sold, can now run a frontier-adjacent open model entirely offline. That matters for three groups of creators: writers and researchers who want a private model that never sends prompts to a server, builders prototyping AI features who do not want to pay per-token API costs during development, and anyone in a low-connectivity setting who needs inference without the cloud. Local inference also sidesteps the data-jurisdiction questions that follow hosted APIs, since your text never leaves the machine.

How TurboFieldfare Fits a 26B Model Into 2GB

The engine leans on three techniques working together. First, it exploits the Mixture-of-Experts design of Gemma 4 26B-A4B: because only a small slice of the network fires for each token, the full weight set never needs to be resident at once. Second, it applies 4-bit quantization using Apple's MLX framework, described in the repository as MLX affine 4-bit at group size 64, with an 8-bit router and 4-bit shared and routed experts. Third, it ships custom Metal kernels so the math runs on the Mac's GPU rather than the CPU.

The clever part is streamed expert loading. Instead of memory-mapping the entire 14.3GB file, TurboFieldfare keeps the 1.35GB core weights and the key-value cache in RAM, then reads each required expert from the SSD on demand and evicts it after use. The cost is disk bandwidth rather than memory capacity, which is a trade modern Apple SSDs handle well. This is why a fast internal drive matters more than raw RAM for this workload.

Install and Run Gemma 4 26B on Your Mac

The setup takes about 15 minutes on a fast connection, most of it spent downloading weights. The steps below follow the repository's build instructions.

1. Check your hardware. You need an Apple Silicon Mac (M1 or newer), at least 8GB of unified memory, and roughly 15GB of free SSD space for the model weights.
2. Install the Swift toolchain. Run xcode-select --install to get the command line tools, which include the Swift compiler and Metal support.
3. Clone the repository. Run git clone https://github.com/drumih/turbo-fieldfare and change into the new directory.
4. Build the release binary. Run swift build -c release. The release flag turns on optimizations, which matter a great deal for inference speed.
5. Fetch the weights. Follow the repository README to download the Gemma 4 26B-A4B weights in the expected MLX-quantized format. The model files are governed by Google's Gemma terms, separate from the Apache 2.0 code license.
6. Run the engine. Launch .build/release/TurboFieldfareMac and pass your prompt. The first token takes longer while the initial experts stream in; throughput steadies after warm-up.

Once it runs, you have a fully local Gemma 4 endpoint you can script against for drafting, summarizing, code assistance, or feeding into your own build pipeline.

TurboFieldfare vs Ollama, LM Studio, and llama.cpp

Local inference already had strong tools, so where does TurboFieldfare fit? The short answer: it is the specialist that pushes one specific model onto low-memory hardware, while the incumbents are generalists.

The takeaway is not that TurboFieldfare replaces these tools. It is that streamed expert loading is a new capability none of the generalist runtimes offer out of the box, and it lowers the memory floor for one heavily-used model class by an order of magnitude.

Troubleshooting Common Issues

A slow first response is expected, not a bug: the engine is streaming the first batch of experts from disk. If sustained throughput is poor, confirm you built with the release flag and that the weights sit on the internal SSD rather than an external or network drive, since streaming latency is the bottleneck. If the process is killed under memory pressure, close other heavy apps so the core weights and cache stay resident. If the build fails, update your Swift toolchain, because Metal kernel compilation needs a current version.

What to Do Next

If you have an Apple Silicon Mac, clone the repository and run the six-step setup above to get a private Gemma 4 endpoint on your own hardware. If you build AI features, benchmark TurboFieldfare against your current API-based prototype loop to see how much of your development inference can move on-device and off the metered bill. And if you maintain a local pipeline, watch the repository: an approach that runs a 26B model in 2GB will likely be ported to other Mixture-of-Experts models next.

Frequently asked questions

Is TurboFieldfare free to use?

The engine code is released under the Apache 2.0 license, so it is free to use, modify, and redistribute. The Gemma 4 26B-A4B model weights it runs are governed separately by Google's Gemma terms.

What Mac do I need to run Gemma 4 26B with it?

Any Apple Silicon Mac (M1 or newer) with at least 8GB of unified memory and about 15GB of free SSD space. The whole point of the project is that it runs on the base MacBook Air, not just high-memory machines.

How does it use only 2GB of RAM for a 26B model?

It keeps a 1.35GB core and the key-value cache in memory, then streams individual experts from the SSD as each token needs them and releases them afterward. Combined with 4-bit quantization and the model's Mixture-of-Experts design, that holds the memory footprint near 2GB.

Will it run on an Intel Mac or a Windows PC?

No. TurboFieldfare relies on Apple Silicon and Metal, so it is limited to M-series Macs. Windows and Linux users should look at generalist runtimes such as Ollama or llama.cpp instead.

Is quality reduced by the aggressive quantization?

4-bit quantization introduces some quality loss compared with full-precision weights, but the router and shared components use higher precision to limit the impact. For most drafting, summarizing, and coding tasks the difference is minor, though precision-sensitive work may still favor a hosted full-precision endpoint.

Is my data private when running locally?

Yes. Because inference runs entirely on your Mac, prompts and outputs never leave the machine, which avoids the data-jurisdiction and logging questions that come with hosted APIs.