Mac mini 32GB Local AI Engines: Splash JSON 69.3 vs 8.5 Baseline Tokens

On the same Mac mini M6 32GB, with the same Qwen 27B and the same JSON question, llama.cpp with speculation turned off ran at 8.5 tokens per second and Splash at 69.3. This is a record of eight local AI engines (llama.cpp, mlx_lm, MTPLX, Rapid-MLX, Splash, LM Studio, Strata and Sushi) measured on one Mac mini with the same questions. Every number is speed only, and the model files differ between engines, so the gaps are not purely the engine's effect. The reference date is the video's publication date, 2026-10-17.

The short version

1. English, code and JSON got much faster. The speculation-off baseline was 8.4-8.6 tokens per second, while Splash reached 22.2 for English, 52.4 for code and 69.3 for JSON [our measurement].
2. Korean writing improved by less. The best result was Rapid-MLX at 13.6 tokens, 1.6x the baseline [calculation], and Splash was 11.2 [our measurement].
3. The 66.4GB Flash-Next left few engine choices. On the 32GB Mac mini only Strata, Sushi and llama.cpp on CPU ran; Rapid-MLX, Splash and LM Studio could not [our measurement]. The model is different, so we did not rank these speeds against the Qwen 27B ones.

What kinds of numbers these are

• Our measurement: one Mac mini with Apple M6 and 32GB, macOS 27.2. The server was restarted for each configuration, with the median of 3 runs, chat mode, thinking off, temperature 0 and at most 256 tokens.
• Calculation: ratios and percentage differences computed from our own measured values.
• Maker's documentation: things such as Rapid-MLX's pack size and Splash's minimum memory (not measured by us).
• Quoted from the 10-11 video: quantization quality (KL), which we did not measure again this time.

The four questions were Korean writing, English writing, code and a JSON inventory list, the same as in the October 11 video. That video's "fastest combination" did not include Splash, so this time we measured it with the same questions.

Qwen 27B 4-bit: the winner changed with the question

The baseline is llama.cpp UD-Q4_K_XL with speculative decoding turned off, and it ran at 8.4-8.6 tokens for all four questions. Speculative decoding guesses a few next tokens in advance and checks them all at once; MTP and DFlash2 are of this kind. Splash is a setup where a DFlash2 draft is attached automatically.

Generation speed (tok/s, median of 3 runs, 2026-10-17, our measurement):

• Splash was first for English, code and JSON. For Korean the order was Rapid-MLX 13.6, MTPLX 13.3, then llama.cpp with MTP on UD-IQ4_XS at 12.4 tokens.
• The speedup of each question's top configuration over the baseline was 1.6x for Korean, 2.6x for English, 6.2x for code and 8.2x for JSON [calculation]. The baseline is a different file, so this is not purely the engine's effect.
• Looking at JSON among engines that use the same MLX 4-bit weights: mlx_lm with speculation off 9.7, Rapid-MLX with MTP 24.7 and Splash with DFlash2 69.3 tokens.
• In llama.cpp, DFlash2 barely helped Korean. The byteshape file ran at 10.9 with speculation off but 8.9 with DFlash2 on. The share of tokens DFlash2 guessed correctly was 6.7% for UD-Q4_K_XL Korean and 86.2% for code. We could not determine whether that is the reason.

The byteshape file, second for code and JSON, is the smallest of the llama.cpp files, but in the October 11 video its KL against UD-Q6_K (Korean/English) was larger: UD-Q4_K_XL 0.0068/0.0236, UD-IQ4_XS 0.0226/0.0621 and byteshape 0.0507/0.1146 (a larger value means further from the UD-Q6_K distribution). We did not measure the quality of the MLX and MTPLX files.

LM Studio was slower than llama.cpp run directly on the same file

We ran the same GGUF file with llmster, the version without a window, and MTP was on in its default settings. It gave 9.5 for Korean, 10.6 for English, 16.5 for code and 18.5 tokens for JSON, which is 16.4-19.8% slower than llama.cpp with MTP run directly on the same file [calculation]. With speculation off it matched the baseline. We could not isolate the cause. The MTP acceptance rate in the LM Studio log was 35% for Korean, 43% for English, 86% for code and 99% for JSON, and we could not turn on the DFlash2 draft.

One line per engine

• The ones with a separate app that can start without the command line are LM Studio, MTPLX and Rapid-MLX. The others are installed and started as a server from the command line.
• MTPLX, Rapid-MLX, Splash, Sushi and strata-mlx are Mac only. LM Studio is closed source and llama.cpp is MIT open source.
• Splash's official minimum is 36GB, so this 32GB Mac mini is outside the range, and we ran Qwen 27B unofficially [maker's documentation].
• Sushi's 32GB example command contains a sudo command that changes system settings, so we did not use it. The Strata here is not the original but strata-mlx, an unofficial Mac port.

The large model, Flash-Next 66.4GB

Flash-Next Q2_0 is 66.4GB, so it does not fit in 32GB of memory and runs by reading from the SSD. The five questions were prose, code, reasoning, editing and Korean, with the median of 3 boots. The measurement dates differ between configurations, so we did not rank them against each other.

Generation speed (tok/s, our measurement):

• Sushi was measured on a day when Chrome was running and could not be re-measured, so it is a contamination candidate. It was 5-25% lower than in the earlier video, and we could not isolate why.
• What could not run: Rapid-MLX's maker documentation lists a pack of about 99-105GB (it differs between documents), so we did not try it on 32GB [maker's documentation]. Splash's installed support list did not include Flash-Next. LM Studio refused to load in 3 seconds, saying it needed 65.56GB, and we did not lift its guardrail.

By use (a direction under these conditions, not a winner)

• For English, code and JSON, Splash's numbers were the highest, but they were measured outside its official 36GB minimum [our measurement].
• For Korean writing, switching engines gained the least, and Rapid-MLX and MTPLX led in the 13-token range [our measurement].
• If you already use LM Studio, it was 16-20% slower than llama.cpp run directly with the same MTP, and the same with speculation off [calculation].
• For the large Flash-Next, Strata and Sushi were the ones that ran.

Limits and what we could not confirm

• These are speed-only tables. File makers and quantizations (UD-Q4_K_XL, UD-IQ4_XS, byteshape, MLX 4-bit) are mixed, so the gaps are not purely the engine's effect.
• Measuring the baseline at the start and the end showed 0.8-1.4% drift. Against the October 11 video's values, 28 of 36 cells were within 3% and the largest difference was 8%; we could not isolate the cause.
• We could not isolate why LM Studio was slower, why DFlash2 is weak on Korean, or why the Sushi values were lower. These are values from one machine and 3 runs, so other Macs or files may differ.

Reference date

Measurements were taken on 2026-10-16 and 10-17, with these versions: llama.cpp 8bb3cf0, mlx_lm 0.31.3, MTPLX 2.12.2, Rapid-MLX 0.16.1, Splash 1.3.1, Sushi 1.2.3, strata-mlx 2f9d1ab and LM Studio llmster 0.0.25+1. As of the video's publication date, the official pages showed newer versions for every engine except MTPLX and LM Studio (by its install script), and we could not confirm whether the measured ones were the latest at the time. Versions may have changed since, and we have not checked current speeds.