Backburner: Accelerate Mac LLM Prefill with an iPhone

Backburner runs Qwen3.8-27B on a Mac and assigns some computation to an iPhone connected over USB-C and kept open in the foreground. During prefill, which reads a long prompt, the devices split the model layers. Beyond 64K context, the iPhone holds part of the older context's KV cache³ and helps compute attention⁴. The result comes from an OpenAI-compatible server on the Mac, which can connect to compatible client apps.

While the Mac computes the earlier layers, the iPhone computes the later ones, using both devices' GPUs. The Mac engine also includes a DFlash2 draft model and kernel optimizations. The default configuration processes one request at a time.

Prefill reads the prompt, document, or tool result sent to the model and prepares it to answer. In tests that added a 2,000-token⁵ file or tool result to a saved agent session, the Mac-plus-iPhone setup processed more tokens per second and waited less than the Mac alone as the existing context grew. These results were recorded on October 1, 2026, with a 24 GB M4 Pro, iPhone 17 Pro Max, and Qwen3.8-27B IQ4_XS; each depth was read twice.

Existing context is what was already in the conversation before the new input. At 16K, reading approximately the same 2,000 tokens took 13.1 seconds instead of 18.8—about 5.7 seconds less waiting per read. This matters when a coding agent repeatedly reads files or tool results. New inputs shorter than roughly 512 tokens stay on the Mac.

In the default setup up to 64K, the Mac computes layers 1–40 and the iPhone 17 Pro Max computes layers 41–64. Once context exceeds the Mac's 64K cells, the Mac computes all 64 layers, while the iPhone stores older KV pages and calculates attention over them. The iPhone GPU⁶ and Neural Engine participate in this older-context computation.

The Mac-only long-context configuration uses 4-bit KV. Connecting an iPhone can retain 8-bit KV while storing longer context. Published end-to-end tests reached 128K with 8-bit KV and 140K with 4-bit KV. The 196K–229K capacity shown at startup is calculated from the iPhone's free memory.

Decode generates reply tokens in sequence and mainly benefits from the Mac engine's optimizations. In the published 27K–33K comparison, stock llama.cpp recorded 11.3 tok/s, the Backburner fork on Mac alone 25.0 tok/s, and the fork with iPhone 25.1 tok/s. Within the same fork, adding the iPhone barely changed generation speed. Faster input processing and faster answer generation are separate benefits.

The fork includes optimized Mac kernels and a DFlash2 draft model. Beyond 64K, the iPhone also shares attention over older context; the project recorded 12.6 tok/s at 128K. That long-context result has no Mac-only comparison measured on the same day.

The normal installer targets Apple-silicon Macs with macOS 14 or later and at least 24 GB of unified memory⁷. The phone app supports iPhone 15 Pro or later and M-series iPads; the main published speed tables use an M4 Pro with 24 GB and iPhone 17 Pro Max. iPad performance remains untested. For prefill acceleration, use a USB-C cable rated for 10 Gb/s data transfer rather than the included USB 2 cable.

The Mac downloads about 24 GB of files including the main and draft models. A fresh install can download or create about 28 GB including tools and files for the phone. The installer checks for at least 24 GB of Mac memory and recommends 30 GB of free space on the home disk. The main model file is about 15.5 GB and the draft model about 1.3 GB.

A separate split-decode mode can distribute model layers for an 8 GB Mac. The project tested Qwen3.8-27B IQ2_XS on a MacBook Neo with 8 GB and an iPhone Air at roughly 4 tok/s. This is a different experiment with USB 2 and device-temperature conditions, separate from the 24 GB Mac setup below.

The Mac installer prepares the latest engine, Qwen3.8-27B IQ4_XS, the DFlash2 draft model, the model-layer file for the phone, and a `backburner` command. Download the script as a file and review it before running it instead of piping it directly from the internet into a shell. The path below fetches the current main-branch script from the official repository.

Install the iPhone app either through AltStore with a free Apple ID or through Xcode. The AltStore instructions say free accounts must refresh app signing every seven days and recommend AltStore 2.2 or later for Backburner's memory entitlement. Open the app and keep it in front, then copy the phone-side model file from the Mac once. Running `backburner` starts the server at `http://127.0.0.1:8080/v1`; by default, the port is accessible only from the Mac itself.

The commands below use the default layer-40 split for the iPhone 17 Pro family. For an A18 Pro iPhone 16 Pro, change the install command to `TAIL_L=52 bash "$backburner_setup/install.sh"` to reduce the layers assigned to the phone. The installer does not automatically choose this device-specific split.

Set a compatible client app's server URL to `http://127.0.0.1:8080/v1`. Sending a simple request in Terminal first makes it easier to separate client configuration problems from model-response problems. The server accepts an arbitrary model name, so you can use `backburner-local` as shown.

Leave the server terminal running and send the request below from another terminal. Successful startup shows `split prefill on`, `remote KV on`, and `ANE pages on`. The first run may spend about a minute transferring Neural Engine files and reopening the app. Check for HTTP 200 with `curl -i http://127.0.0.1:8080/health`, then send a chat request.

If the connection drops, reopen Backburner in the iPhone foreground and check the cable. Above 64K, the iPhone holds older KV; locking it or switching apps can stop the server after 15 seconds without a response. Reopen the app and restart the Mac server. Guided Access can help prevent accidental locking during a run.

If the iPhone 17 Pro Max reports an `app budget` near 3,000 MiB instead of approximately 6,000 MiB, check its memory entitlement. Run `scripts/phone-up.sh` from the repository folder to display the value. The official guide recommends AltStore 2.2 or later, while the developers are still verifying entitlement preservation through this path. If the smaller budget remains, review the Xcode route and memory-entitlement settings.

After a Mac reboot, the `backburner` command can request an administrator password to reset the GPU wired-memory limit. This pins memory for the model, so leave headroom for other apps. Use the command below only if running the repository's `scripts/serve.sh` directly fails with a wired-limit error. The 20,480 MiB value is for this guide's 24 GB Mac configuration.

Backburner is pre-release software under the MIT license. The iPhone app must stay open in the foreground to use its GPU. Below 64K, the Mac can resume the work if the connection drops; beyond that, the Mac does not hold the older KV pages kept on the phone. The default single-request setup is also not designed for several simultaneous users.

The Mac server and prompt-cache proxy bind only to `127.0.0.1`. Connect the iPhone with USB-C; Wi-Fi requires pairing over the cable first. Use app 0.0.3 or later, which includes these connection protections.

For an initial test, read the same familiar document at 16K, 32K, and 48K. Record first-input processing time, answer-generation speed, and connection status separately with the Mac alone and the iPhone attached. This shows which wait Backburner reduces in your workflow. Use beyond-64K context only when your work needs it, and account for the phone's memory budget and the time its app must remain in front.

The SSD⁸ prompt cache helps reuse system prompts already processed. Saving a beyond-64K session with KV held on the phone requires app 0.0.4 or later. That save path has only been tested with a Mac loopback substitute, not a real iPhone. Start by comparing reads and connectivity within 64K.