A Reddit thread about Splash 1.7.0, released the day before, sent me to check two things: whether the oMLX server I use daily for Qwen3.8-Flash-Next was out of date, and whether Splash beats it. On my 128GB M5 Max MacBook Pro, upgrading oMLX made generation up to 21% faster for free, and Splash was faster again: about 1.5x the upgraded oMLX on an empty context (130 vs 89 tok/s) and close to 2x with 245K tokens loaded (113 vs 58).

The shape of the Splash line is the interesting part. It stayed above 100 tok/s at every depth I measured, while the upgraded oMLX lost about a third of its speed between an empty context and 245K. Prompt reading (prefill) is somewhat slower on Splash, and quality held on my small test suite.
Upgrading oMLX was the easy win
Before comparing engines, I checked my own. My daily server was oMLX 0.7.1rc1 from mid-October. On the same model and settings, 0.8.0rc1 generates 6 to 21% faster from an empty context up to 128K, and is level at 245K. Prompt reading is 27 to 32% faster. A 245K prompt, about half of it already cached, went from about 71 seconds to about 55 seconds to first token.

Tool calling and agent tasks stayed the same within noise. The upgrade itself was small: download the wheel from the GitHub release, check its sha256 against the digest on the release page, pip install it into a fresh Python 3.12 venv, and point the launcher at the new venv. The final 0.8.0 release shipped the morning after my test, so I haven't benchmarked it.
So simply upgrading oMLX was a big win. If you run oMLX, check your version before you shop for a new engine.

Splash against the upgraded oMLX
Splash is Apache-2.0 licensed, and its first commit was in September, so the project is about two months old.
Prefill goes the other way. At 32K with a cold cache, Splash read the prompt about 6% slower than oMLX. At 245K, again with about half the prompt cached, Splash took 66 seconds to first token against 55 for oMLX.
What Splash does differently
Splash uses speculative decoding with a trained draft model, DFlash2, about 1.2 GB. In 1.7.0 the main model checks the draft as a tree of up to 16 candidate rows per step, and a feature called prompt lookup proposes text copied from earlier in the prompt. The KV cache is 8-bit (INT8) by default, and cached conversation states are kept as 8-bit codes.
On my Mac its memory plan kept the routed experts in RAM, about 61 GiB, and left the model's 27 GiB n-gram embedding table on the SSD behind a small row cache. It allows the full 256K window, and long requests can spill KV to an SSD cache. oMLX does something similar for the n-gram table with its PLE-on-SSD setting. Start to ready took about a minute.

Setup
I installed the Splash CLI from the release tarball. There is also a Homebrew tap: brew install incoai/tap/splash. The model is unsloth's UD-IQ4_XS GGUF, about 94 GB in 3 shards, plus its BF16 vision projector and the draft model. This is what I ran, with local files:
splash serve --model local/qwen38 \
--model-dir Qwen3.8-Flash-Next-UD-IQ4_XS-00001-of-00003.gguf \
--mmproj mmproj-BF16.gguf \
--draft-model Qwen3.8-Flash-Next-DFlash2 \
--max-context 256KGoing by the README's pattern, splash serve --model unsloth/Qwen3.8-Flash-Next-GGUF:UD-IQ4_XS --max-context 256K should download the files for you, though I ran the local-file form. Splash counts a K as 1,024, so its 256K is the same 262,144 tokens as the 262K window on oMLX.
Splash serves an OpenAI-compatible and Anthropic-compatible API plus a chat page. For LAN use there are --host and --api-key, and --idle-release 30m frees memory after 30 idle minutes (the default is 10). The settings that affect speed and memory stayed at their defaults.
The oMLX side is Jundot/Qwen3.8-Flash-Next-oQ4e-mtp, an MLX 4-bit build of about 106 GB, with MTP on, the n-gram table offloaded to the SSD (qwen4_ple_ssd_offload), a 262K window and vision on. The weights are not identical: both are roughly 4-bit quants of the same model, one GGUF and one MLX, and the GGUF is about 12 GB smaller. So some of the difference may come from the quant rather than the engine.
You also don't have to pick one. A reader pointed out that oMLX can run Splash as an external engine. Install the splash launcher with Homebrew, point oMLX at it under Settings, Integrations, External engines, and turn on Use external engine in the model's Advanced settings (GGUF models have it on already). oMLX starts Splash when the model loads, and the model stays in oMLX's model list, API and dashboard like any other. For Flash-Next it needs the GGUF and the DFlash2 draft in one of oMLX's model folders, because its MLX builds don't run on Splash. I moved my daily server to oMLX 0.8.0 with Splash as its engine, and on the same story prompt as my benchmark it decodes at the same speed as Splash on its own.
Method
Same harness for all three servers, timed from the streamed response. Prefill is prompt tokens divided by time to first token. Decode is generated tokens minus one, divided by the time from first token to last.
The context filler is real C++ source, llama.cpp's src/ tree, cut to exact token counts with the model's tokenizer: 32,768, 131,072 and 245,760 tokens, plus an empty context that asks for a short story instead. With filler, the question asks for an explanation of the code in about 400 words. Each run generates 1,024 tokens at temperature 0. Warm-up requests run first, and each depth is repeated non-streamed as a check. The two oMLX versions ran back to back on the same evening, and Splash ran the next morning on the same machine. The vision check reads a serial number off a photo of a sensor label, and all three got it right.
Each deeper prompt starts with the previous one, so the 128K and 245K prompts partly hit the prefix cache. Compare prefill at 32K.
One thing could flatter Splash: the filler is source code and the answer explains it, so prompt lookup has text to copy. My reasoning puzzles have short prompts and fresh text, and Splash was still about 1.5x faster there, 137 vs 92 tok/s overall with thinking on. So the speedup is probably not just copying.

Quality
On my own small suite, Splash and the upgraded oMLX both scored 52 of 54 on reasoning puzzles, and agent tasks against a real metrics server came out the same within noise (26 and 27 of 30).
Tool calling was weaker on Splash, 38 of 48 against 43, and most of the gap is one hard case: building a Prometheus query for a 3-hour average across instances in a single call. oMLX wrote the full query in all 6 runs. Splash did it in 2 of 6, and otherwise sent a simpler query, a plain average or a count, without the time window. In multi-turn agent tasks, where it can follow up, the scores were close.
Caveats
Splash 1.7.0 was a day old when I tested it. I have also not tested several clients at once on it yet, and my assistant, a coding agent and a friend's laptop share this server. Splash batches concurrent requests, and its release notes show decode gains at four lanes along with slower first tokens when four sessions arrive together, but I haven't measured that here.
Verdict
I switched my daily server to Splash for a trial, and now run it as oMLX's engine, with oMLX's own MLX engine one setting away as the fallback. I'm driving it for a while.
I did not expect a two-month-old engine, with a trained draft model and specialized Metal kernels, to make a model this size write close to twice as fast at a quarter-million tokens of context on a laptop. Its speed dropped about 13% from an empty context to 245K, which is the part I keep coming back to. Next I would like to measure it with several clients at once.
Sources
- Splash: github.com/incoai/splash and the 1.7.0 release notes
- oMLX: github.com/jundot/omlx and the 0.8.0rc1 release
- Model GGUF: unsloth/Qwen3.8-Flash-Next-GGUF
- Draft model: incoai/Qwen3.8-Flash-Next-DFlash2
- oMLX model: Jundot/Qwen3.8-Flash-Next-oQ4e-mtp
- Earlier posts: Running Qwen3.8-Flash-Next at Full 262K Context on a 128GB MacBook, Qwen3.8-Flash-Next at 60 Tokens per Second Across Its Full 262K Context, Strata vs oMLX: Qwen3.8-Flash-Next Decodes About 25% Faster at Long Context
Comments
// Comments are reviewed before appearing. No spam. No noise.