Can DeepSeek V4 Flash 0731 Run on a 128GB Mac Studio? The 96.8GB Reality

Yes, DeepSeek V4 Flash 0731 can run locally on a 128GB Mac Studio. The useful answer is narrower: choose a roughly 91–97GB quant, begin at 64K context, and do not confuse a GGUF that maps into memory with a system that remains responsive.

Evidence cutoff: August 2, 2026. Kingy did not run this article on a 128GB Mac Studio; the available local machine was a 24GB M4 Pro MacBook Pro. We therefore separate repository facts, direct community receipts, project-published measurements and engineering estimates. For the wider platform picture, see our earlier DeepSeek V4 Flash 0731 hardware guide. This article focuses on the new 0731 GGUFs and the 128GB boundary.

The six answers that matter

What “128GB Mac Studio” means in 2026

Apple’s current 128GB Mac Studio is the 16-core CPU, 40-core GPU M4 Max configuration, with 546GB/s memory bandwidth. The M3 Ultra version starts at 96GB and jumps to 256GB; there is no 128GB M3 Ultra option. That matters because an M1 Ultra, M3 Max or M5 Max result can prove a capacity class or bound expectations, but it is not a direct M4 Max speed measurement.

There is also a unit trap in the headline numbers. Hugging Face reports file sizes in decimal gigabytes, while a nominal 128GB memory configuration exposes roughly 128GiB, or 137.44 billion bytes. That is why a “128GB” GGUF is actually about 119.3GiB and technically smaller than physical memory. The file that truly lands at the raw-memory wall is Unsloth’s 136.7GB IQ4, at 127.3GiB.

Raw subtraction is only the first gate. macOS, the runtime, Metal allocations, compute buffers, the KV cache and the prompt-processing workspace all draw from the same unified pool. A file can download, memory-map and even report “model loaded” while the machine is already compressing or swapping. Practical fit means sustained generation with green memory pressure and negligible swap—not merely reaching a server health check.

The complete Unsloth size boundary

The correction to the working premise is important. The 128.1GB files do not literally equal the machine’s byte capacity; they leave about 8.6–8.7GiB. That still makes them unusable as normal resident models, because macOS alone needs most or all of that margin. The 136.7GB IQ4 files are the true near-equality case, leaving less than 1GiB before the runtime starts.

Which quant actually loads?

The strongest direct receipt we found is an exact-checkpoint Unsloth community report: UD-IQ3_XXS, 104.208GB, loaded on a 128GB M1 Ultra Mac Studio after raising the GPU wired-memory limit. The user reported 5–6 token/s in stock LM Studio and 15–16 token/s with an unofficial Metal patch.

That is not a controlled M4 Max benchmark, and an unofficial patch is not a production baseline. It does answer the capacity question. If 104.208GB can become resident on a 128GB Mac, 90.927GB IQ2_M and 96.833GB Q2_K_XL have materially more room. The safer IQ2_M leaves 43.3GiB before overhead; Q2_K_XL leaves 37.8GiB.

Tokens per second: runtime matters as much as the file

There is no honest single speed number for “DeepSeek V4 on a Mac.” The exact quant, runtime, Metal kernels, context depth and whether weights remain resident can move decode speed by multiples.

For planning, 20–30 token/s is a defensible engineering band for an optimized resident run on the 128GB M4 Max Mac Studio. That is an inference from neighboring 128GB Max chips and the M4 Max’s 546GB/s bandwidth—not a benchmark we measured. The direct Unsloth IQ3 report was much slower: 5–6 token/s in stock LM Studio and 15–16 only after an unofficial Metal patch. If the model spills into SSD streaming, expect another, slower operating regime.

DwarfStar is important, but it is not a drop-in accelerator for the Unsloth folder. It uses its own purpose-built 0731 files: an 86.720GB q2-imatrix model and a 97.592GB mixed q2–q4 imatrix model. If maximum Mac speed is the goal, those are currently the more compelling route. If compatibility with llama.cpp, LM Studio and the broader GGUF ecosystem is the goal, use the Unsloth files and accept that the software stack is still catching up.

Time to first token: the missing benchmark

No controlled public test currently reports end-to-end TTFT for Unsloth Q2_K_XL on the 128GB M4 Max Mac Studio. Any article giving one precise number for that combination is either measuring something else or guessing.

We can still set expectations. TTFT includes template processing, prompt ingestion and scheduler overhead; it is not the same as decode speed. DwarfStar’s published M3 Max result processed an 11,709-token prompt at 250.11 token/s. Division gives about 46.8 seconds of prompt evaluation before other overhead. Short prompts should feel much faster, while a cold 64K or 128K ingest can take minutes. Prefix caching changes repeat-turn latency dramatically, so report both cold and cache-hit TTFT when you test.

Realistic context: 64K first, 128K after qualification

DeepSeek advertises a 1,048,576-token context ceiling. That is an architectural maximum, not a recommendation for this machine. DwarfStar estimates roughly 26GB of context memory at 1M, including about 22GB for its compressed indexer, and explicitly recommends a smaller window on 128GB systems. That estimate belongs to DwarfStar’s own model layout and runtime; it cannot be added mechanically to an Unsloth payload. Either way, the remaining operating-system and runtime margin is too narrow for a sensible everyday 1M configuration.

• 64K: the right default. It leaves room to validate stability, agent loops and memory pressure; a current 128GB DwarfStar user ran the exact 0731 mixed quant through 64K.
• 128K: a reasonable second target for IQ2_M or Q2_K_XL after 64K passes with negligible swap.
• 250K–256K: plausible with the smaller Q2 files and a quiet system, but treat it as a measured configuration, not a promise. DwarfStar recommends roughly 100K–300K on 128GB.
• 1M: technically exposed by the model, operationally unwise on this memory tier. Use 256GB or more if million-token work is the requirement.

Context also changes speed. The 128GB M5 Max community result fell from 39.07 token/s at the beginning to 28.11 token/s by 64K. Long-context claims should therefore include both context depth and decode rate at that depth.

Does the two-bit quality loss make this worthwhile?

For fitting the model locally, yes. For claiming full-checkpoint parity, no. The 96.8GB Q2_K_XL label is shorthand for a mixed tensor recipe, not uniform two-bit storage: its GGUF metadata contains a blend dominated by IQ2_XS and IQ3_XXS, with Q8, native MXFP4 and smaller higher-precision components. The useful question is task behavior, not the label.

Kingy has already run an exact-checkpoint comparison of UD-IQ2_M versus UD-IQ3_XXS: 177 executed evaluations per quant on one pinned six-A40 host. IQ2 scored 318/426 decision points; IQ3 scored 320/426. The larger IQ3 cost 13.281GB more for a two-point, 0.47-percentage-point lead. IQ3 led tool calling 234–231, IQ2 led exact-answer reasoning 67–66, both scored 20/30 on strict JSON, and neither produced a scorable patch in the tiny coding sample.

That result makes IQ2_M the evidence-backed default for a 128GB Mac. It does not prove that IQ2 matches the official model or Q8. Both Kingy-tested low-bit quants also showed capped or repetitive outputs in some cases. Validate your own tools, schemas, long generations and code-edit workflows before making the Mac an unattended agent host.

Unsloth has now published a next-token distribution diagnostic for the full quant ladder. Against its Q8 reference, IQ2_M recorded mean KLD 0.48388, perplexity 7.0894 and 76.56% top-token agreement. Q2_K_XL improved those figures to 0.40766, 6.6782 and 78.57%; IQ3_XXS reached 0.30789, 6.1972 and 81.93%. The direction supports calling Q2_K_XL the quality-first 128GB choice. But top-token agreement is not task accuracy, and the post does not supply an equivalent tool-use or coding evaluation.

In other words, the 5.906GB premium for Q2_K_XL buys a measurable improvement in this publisher diagnostic, while Kingy’s task suite gives IQ2_M the stronger practical evidence. Choose based on which evidence matches your workload—and keep IQ3_XXS for cases where its additional distribution fidelity matters more than context margin.

The practical 128GB setup

1. Pick the runtime before the download. For maximum demonstrated Metal speed, use DwarfStar with its own 0731 q2 or q2–q4 file. For broad GGUF compatibility, use Unsloth with a current llama.cpp build.
2. Start with IQ2_M and 64K. Verify a normal conversation, tool calls, a long response and a cold restart before trying Q2_K_XL or more context.
3. Pin the software. Use llama.cpp b10235 or newer; it includes the current V4 support at our cutoff. The Metal Lightning Indexer remained an unmerged pull request, while the dedicated 0731 chat-template correction was also still open. The ordinary API reasoning_effort field may not reach the embedded template in current server builds, so record the exact invocation and use an explicit template argument such as --chat-template-kwargs '{"reasoning_effort":"high"}'.
4. Benchmark target-only first. The current Unsloth GGUF contains the target model, not the separate DSpark draft tensors. Adding speculative support changes memory use and makes attribution harder.
5. Watch the operating system, not just the server log. Keep Activity Monitor’s memory pressure green and swap near zero. Stop if the machine becomes unresponsive; a loaded model is not worth destabilising the workstation.

Final verdict

DeepSeek V4 Flash 0731 is genuinely usable on a 128GB Mac Studio, but the winning configuration is a low-bit model with deliberate headroom—not the largest file that technically maps.

Download Unsloth UD-IQ2_M first. It leaves 43.3GiB of gross margin and, in Kingy’s exact 0731 suite, was effectively tied with the 13.3GB-larger IQ3. Move to UD-Q2_K_XL if you want to spend 5.9GB on its mixed recipe and 64K/128K context remains stable. The 104.2GB IQ3 has a real 128GB Mac Studio load receipt, but its smaller safety margin and runtime sensitivity make it an enthusiast configuration, not the default.

Expect interactive decode only with the right Metal path. Twenty to thirty token/s is a reasonable planning range for an optimized resident run, while current general-runtime reports can be slower. TTFT remains unverified for the exact M4 Max/Unsloth combination, and large cold prompts can take tens of seconds or minutes to ingest. Start at 64K, prove 128K, and leave 1M context to larger-memory hardware.

The 96.8GB reality is not that file size alone decides the answer. It is that 96.8GB buys enough room for macOS, context and buffers while preserving far more model than a 128GB workstation could hold at four or eight bits. That trade is imperfect—but for local DeepSeek V4 on this Mac, it is the trade that makes the project practical.

FAQ

Can DeepSeek V4 Flash 0731 run on a 128GB Mac Studio?

Yes. A 104.208GB Unsloth IQ3 quant has been reported loading on a 128GB M1 Ultra Mac Studio. The recommended 90.927GB IQ2_M and 96.833GB Q2_K_XL files leave more headroom.

What is the best quant for a 128GB Mac Studio?

Start with UD-IQ2_M. It has the strongest exact-checkpoint size/quality evidence and leaves 43.3GiB before runtime overhead. Q2_K_XL is the quality-first ceiling, but it has not been shown to beat IQ2_M on a comparable task suite.

How fast is DeepSeek V4 Flash on the M4 Max Mac Studio?

No controlled exact-combination benchmark is public yet. Based on optimized DwarfStar results from neighboring 128GB Max chips, 20–30 token/s is a reasonable planning band, explicitly an inference. llama.cpp/LM Studio results may be slower until the Metal path matures.

What context length should I use?

Begin at 64K and qualify 128K with your actual workload. Around 256K is experimental. The 1,048,576-token architectural limit leaves too little operational margin on a 128GB system.

Will the 128GB Q3 quant fit?

Not practically. It is about 119.3GiB, leaving under 9GiB for macOS, Metal buffers and context. The 136.7GB IQ4 is even closer to the raw wall at 127.3GiB.

Should I use DwarfStar or llama.cpp?

DwarfStar currently has the stronger demonstrated Mac speed path, but requires its own GGUFs. llama.cpp offers broader ecosystem compatibility and loads the Unsloth files. Choose the runtime first; the downloads are not interchangeable.

Methodology and limitations

• File totals were summed from every shard at Unsloth revision 109848da…; decimal GB and binary GiB are both shown.
• Direct Mac reports are community evidence, not independently reproduced laboratory benchmarks.
• Cross-chip and cross-runtime numbers are never treated as measured M4 Max/Unsloth performance.
• Kingy’s quality comparison ran on six NVIDIA A40 GPUs. Its task scores inform quant choice, not Mac speed.
• Runtime support was changing on the publication date. Pin the build and repeat measurements after upgrades.

Primary sources

• DeepSeek V4 Flash 0731 official checkpoint and model card
• Unsloth DeepSeek V4 Flash 0731 GGUF repository, pinned revision
• Unsloth full-ladder KLD, perplexity and top-token agreement table
• Apple Mac Studio technical specifications
• DwarfStar source, memory guidance and published Metal measurements
• 128GB M1 Ultra Unsloth IQ3 load report
• Exact 0731 DwarfStar context-depth results on Mac
• Kingy’s exact 0731 IQ2_M versus IQ3_XXS task comparison
• llama.cpp b10235 release and 0731 chat-template pull request