Executable programs and extensions

Set up Qwen3.8-27B prefill and caching with Splash 1.3.0

The GPU and Neural Engine share long-prompt prefill to reduce time to the first token; the GPU generates the answer.

Splash is a local inference1 server for Apple Silicon Macs. Start it with Qwen3.8-27B and send prompts2 from its browser chat or a compatible app. Version 1.3.0 can split prefill3 for supported long prompts between the GPU4 and Apple Neural Engine5 to reduce time to the first token6; it also manages shared-prefix and SSD7 caches.

Requirements and key details
  • The GPU and Neural Engine share prefill for long Qwen3.8-27B prompts; the GPU generates the answer.
  • The Qwen3.8-27B 4-bit example needs at least 36 GB of unified memory, with 48 GB recommended.
  • Shared-prefix reuse and SSD caching can reduce repeated input work; SSD caching requires --max-cache-disk.

What Splash and Qwen3.8-27B do

Starting Splash with the Qwen3.8-27B model ID prepares the weights and matching DFlash2 drafter. Once ready, it handles questions sent to the local address and returns answers.

When you send long code or a document, the model reads the input before producing its first token. This input-processing stage is called prefill. Decode8 then generates the answer token by token. For supported dense models, Splash 1.3.0 uses the Neural Engine for long prefill; Qwen3.8-27B answer generation runs on the GPU.

If the first token is slow after a long prompt, compare Neural Engine prefill; if the answer streams slowly, inspect decode speed separately. At startup, Splash calibrates for the Mac and model, then adjusts the split by prompt length.

A silver laptop, external SSD, and open notebook
Give Splash a model checkpoint and its local server can answer app prompts.

Install Splash and get a first reply

You need an Apple M3 or newer Mac, macOS 26.4 or later, and Homebrew. The Qwen3.8-27B 4-bit example needs at least 36 GB of unified memory9; 48 GB is recommended. The first run downloads model and draft weights, so allow for disk space and an internet connection.

Install Splash with Homebrew, then start the server in a first Terminal window. Leave the server command running and wait for Ready. Run the API10 check below in a second Terminal window.

When the server terminal prints Ready, open http://127.0.0.1:8000 in a browser. Splash's chat page appears; send a prompt and receive an answer. By default, the server listens on a local address on this Mac. Closing the terminal or pressing Ctrl+C stops it.

Send the API request below from a second terminal to check the model connection. If the returned JSON's choices array contains answer text, the request was processed.

Terminal 1: install and start the server
brew install incoai/tap/splash
splash serve --model mlx-community/Qwen3.8-27B-4bit
Leave this terminal open until it prints `Ready`.
Terminal 2: send the first API request
curl -sS http://127.0.0.1:8000/v1/chat/completions -H 'Content-Type: application/json' -d '{"model":"mlx-community/Qwen3.8-27B-4bit","messages":[{"role":"user","content":"Explain prefill in one sentence."}]}'
The model's answer appears in the response JSON's `choices` array.

Connect Splash as an external engine in oMLX

In oMLX 0.7.1rc1, Splash can do inference while oMLX keeps the model list and API. Install Splash 1.3.0 or later and open Settings → Integrations → External engines. Once the detected launcher path and version appear, prepare the Qwen3.8-27B model directory and the z-lab/Qwen3.8-27B-DFlash2 drafter.

For 1.3.0, use an affine 4-bit, group-64 MLX11 checkpoint12 such as mlx-community/Qwen3.8-27B-4bit. Version 1.3.1 also accepts mixed-bit checkpoints. For the oMLX external engine, select a supported MLX checkpoint rather than an older incoai/*-Splash prebuilt package.

Enable Use external engine in Model Settings → Advanced and select Splash. oMLX manages the loopback port and API key for the separate process. Send a short prompt and check prefill progress and generation speed on the dashboard. If it fails to start, check the launcher path in Integrations, the model format, then the drafter files.

Adjust the memory limit, KV precision, SSD cache and Neural Engine prefill in the Splash integration settings. Splash uses its own DFlash2 and cache settings. Leave Lightning MTP13 or TurboQuant settings for other oMLX models unchanged and compare TTFT14 and completion time for the same document on Splash and the default engine.

Use Neural Engine prefill and read its conditions

When you omit --disable-ane, Splash 1.3.0 can split FFN computation between the GPU and Neural Engine for supported dense targets. At startup it calibrates the split for the Mac and model, chooses prompt lengths that benefit, and remembers the result. If evaluation fails, times out, or produces a non-finite value, it reruns the affected chunk on the GPU.

Splash 1.3.0 published results · Qwen3.8-27B prefill TTFT
MacMLX 4-bit, GPU onlyGPU + Neural Engine
M5 Max14.09 s12.36 s
M5 Pro28.28 s21.57 s

The Splash 1.3.0 release records Qwen3.8-27B measurements comparing prefill and time to first token (TTFT) with MLX 4-bit weights, one request, and a cold 14,096-token prompt. M5 Max took 14.09 seconds on GPU alone and 12.36 seconds with GPU plus Neural Engine; M5 Pro took 28.28 and 21.57 seconds, respectively. TTFT covers input processing through the first token; compare it separately from answer-generation speed.

Prefill splitting uses some memory that could otherwise hold the KV cache15. The context limit for long inputs can be lower than with GPU-only operation, so check the startup summary and /status field maximum_context_tokens on your Mac. Compare decode throughput16 separately for the speed of streaming answers.

A thick stack of documents and stopwatch beside a silver laptop
Measure long-prompt waiting separately from answer generation.

Configure caching for repeated prompts

A follow-up prompt that repeats the same document or instructions may require the model to read the opening again. Splash 1.3.0 can reuse a completed prefill checkpoint across conversations with a long shared prefix, resuming near the point where the second conversation diverges. In a published 19K-token shared-prefix case, the second conversation's TTFT fell from 39.6 to 6.3 seconds, reusing 16,384 tokens.

In that record, one additional reclaimable restore state for the 27B model used 187 MiB. With disk caching enabled, states evicted from memory can be written to the SSD. Set a quota such as --max-cache-disk 16G to use SSD caching for the current server session; add --persistent-cache to keep it across restarts.

Start without disk options and send two conversations with the same long document to check shared-prefix reuse. Add disk caching only if memory remains constrained or states are being evicted, after checking available SSD space. SSD caching does not increase the context limit, and a quota smaller than the working set can cause repeated reads and writes.

How much cache is reused depends on the length of the shared prefix. Send the same model, document, and question twice, then record TTFT for the first and repeated requests separately.

Limit SSD cache to 16 GiB and retain it across restarts
splash serve --model mlx-community/Qwen3.8-27B-4bit --max-cache-disk 16G --persistent-cache
Adjust `16G` to fit available disk space.
An external SSD connected to a laptop beside clipped documents
A prefix cache can reuse shared input in follow-up questions about the same document.

Compare results and fall back to GPU-only

First match prefix and SSD cache reuse conditions. Record TTFT for the same model and long input with GPU plus Neural Engine, restart with --disable-ane, then measure GPU alone. Separate initial and repeated runs in each configuration to identify calibration and compilation costs.

The first Neural Engine startup can take longer due to program compilation and split calibration. In /status, inspect ane_ffn for split state, share, minimum input-chunk size, evaluations, and GPU reruns. For short prompts that do not benefit, Splash can select the GPU-only path automatically.

If the server does not become ready, check the first terminal error and macOS version. If the browser cannot connect, check for Ready and whether port 8000 is available. If the model cannot start because of context length17, inspect the automatic limit in the startup summary and /status, then lower it with --max-context if needed. Use --disable-ane to return to GPU-only prefill if Neural Engine operation is unstable or you need a fixed baseline.

Keep the default path when Neural Engine reduces TTFT for your long prompt and the available context still fits your work. Choose GPU-only with --disable-ane if context becomes too short or results are unstable.

Return to GPU-only prefill
splash serve --model mlx-community/Qwen3.8-27B-4bit --disable-ane

When the first download stalls or the model will not start

The first splash serve downloads the selected Qwen weights and their matching DFlash2 draft weights from Hugging Face. The Qwen3.8-27B 4-bit example can use up to about 21 GB for both downloads. If progress appears stalled, check the last progress line in Terminal and your internet connection before stopping the server. A later start reuses files already downloaded.

If Terminal says it cannot find the model repository, check the value passed to --model. The MLX ID in this guide is mlx-community/Qwen3.8-27B-4bit. Private or gated repositories require you to sign in to Hugging Face or set HF_TOKEN. Correct the model name or access first, then rerun the same command.

If the weights finish downloading but the memory budget check fails, you do not need to download them again. The selected model and context length exceed the Mac's available memory budget. Restart with a lower --max-context; on a 24 GB Mac, choose a smaller supported GGUF18 variant from the model list.

Terminology notes

  1. Inference — The process of using a trained model to compute an output for an input. Here, local inference means running the model on the user’s device.

    Back to the text
  2. Prompt — The input text sent to a model. For generative models it describes the desired result and strongly shapes the output.

    Back to the text
  3. Prefill — The stage where an LLM reads the input prompt and computes representations for its tokens. Longer prompts contain more tokens to process.

    Back to the text
  4. GPU — A processor designed to handle many calculations in parallel. It performs model computations during AI inference.

    Back to the text
  5. Neural Engine — Dedicated hardware in Apple Silicon for neural-network computation.

    Back to the text
  6. Token — A unit into which a model divides input or output for processing.

    Back to the text
  7. SSD — A data storage device that uses flash memory and retains data without power.

    Back to the text
  8. Token decoding — The stage that generates successive output tokens using the input and the response produced so far.

    Back to the text
  9. Unified memory — An architecture where the CPU and GPU share one physical memory pool.

    Back to the text
  10. API — A defined interface that lets other code call a program’s functions.

    Back to the text
  11. MLX — Apple’s machine-learning framework, which runs models using memory shared by the CPU and GPU on Apple Silicon.

    Back to the text
  12. Checkpoint — A file containing saved model weights and related state. Versions or tasks in one model family may use different checkpoints.

    Back to the text
  13. MTP — A training objective or model component for predicting multiple future tokens at once. In speculative decoding, those predictions can be proposed as candidate tokens.

    Back to the text
  14. Time to First Token — The time from sending a request until its first output token arrives.

    Back to the text
  15. KV cache — Memory that stores attention keys and values from earlier tokens for reuse during later token generation. Its size depends on context length and batch size.

    Back to the text
  16. Throughput — The amount of work processed or generated over time. Comparisons need the unit, such as tokens per second or requests per second.

    Back to the text
  17. Context window — The token span of input and generated content a model can handle in one request. The supported limit and memory use depend on the model and runtime settings.

    Back to the text
  18. GGUF — A file format for model data, widely used by llama.cpp-based tools.

    Back to the text

Frequently asked questions

What should you check first in this article?
Splash is a local inference server for Apple Silicon Macs. Start it with Qwen3.8-27B and send prompts from its browser chat or a compatible app. Version 1.3.0 can split prefill for supported long prompts between the GPU and Apple Neural Engine to reduce time to the first token; it also manages shared-prefix and SSD caches.
How much memory does it need?
You need an Apple M3 or newer Mac, macOS 26.4 or later, and Homebrew. The Qwen3.8-27B 4-bit example needs at least 36 GB of unified memory; 48 GB is recommended. The first run downloads model and draft weights, so allow for disk space and an internet connection.