Can I Run Muse Spark Open Locally? (2026): 256GB Minimum

Bottom Line

• You need 256GB or more. The smallest GGUF, Unsloth’s UD-IQ1_S, is 163.58 GiB. No 128GB machine loads any file.
• 256GB means 1 or 2 bits. A 256GB Mac Studio M5 Ultra holds UD-IQ2_XXS (210.08 GiB) with a 131K context. Unsloth confirms the 2-bit file “will fit on 256GB”.
• One 512GB Mac holds 3 bits. UD-Q3_K_XL (373.91 GiB) or the MLX 3-bit build (406.19 GiB). Meta’s 4-bit NVFP4 (496.41 GiB) does not fit one Mac.
• The cache is small. Only 16 of 62 layers keep the full context. Our estimate is 64 KiB per token: 2.4 GiB at 32K, 64 GiB at the full 1M.
• The cheapest full 4-bit box is an EPYC server. 512GB of DDR4 plus a 24GB GPU holds UD-Q4_K_XL (470.79 GiB), but expect single-digit tokens per second.
• Ollama is cloud-only. Use llama.cpp or MLX.
• No single-machine speed is published. The only measured speeds are Apple’s, on two and four Macs.

Ready to buy? See the tested hardware list with current prices.

What Muse Spark Open Is

Only 42B parameters work on each token, but all 816B must sit in memory. The next token can use different experts. So the speed depends on the 42B, and the memory depends on the 816B.

Read the licence before you build on it. Meta says the terms are “limited commercial”. Glimmer, Meta’s small model, is Apache 2.0. Spark Open is not.

Every File Size, in Bytes

We summed every file in each Hugging Face repo through the API. GiB is what your memory limit counts.

The vision file is separate. Unsloth’s mmproj-Q8_0.gguf adds 2.03 GiB if you want image input.

Meta and Apple quote the same NVFP4 file differently. Meta says “about 530 GB”. Apple says “about 493GB”. The file is 533.01 GB, which is 496.41 GiB.

Why the Cache Costs So Little

The model keeps the full context in only 16 of its 62 layers. The other 46 layers look back 2,048 tokens only. We read these values from the mlx-community 4-bit config: 16 key-value heads, head size 64.

• Full-attention layers: 16 layers x 16 heads x 64 x 2 (key and value) x 2 bytes = 64 KiB per token at 16-bit.
• Sliding layers: a fixed 368 MiB, whatever the context.

This is our estimate. Check the cache line in your llama-server log. An 8-bit cache halves it.

Fit Table by Hardware

Mac rows use a raised GPU memory limit. PC rows use VRAM plus system RAM, minus about 8 GiB for the OS. We add a 2 GiB compute buffer. Every row is our arithmetic.

256GB is the floor that makes sense. UD-IQ2_XXS (210.08 GiB) + 8.4 GiB cache + 2 GiB buffer is about 220 GiB. That is under 240 GiB. Raise the limit first with sudo sysctl iogpu.wired_limit_mb=245760. That leaves macOS 16 GiB.

One 512GB Mac holds 3 bits with room for a long context. UD-Q3_K_XL + 8.4 GiB cache + 2 GiB buffer is about 384 GiB. Raise the limit to leave macOS about 16 GiB. UD-Q4_K_XL (470.79 GiB) also loads on paper at 32K, but then macOS has almost nothing left. We would not plan on it.

Two DGX Sparks are untested. The 117.2 GiB per Spark is the usable figure from a community card we used on our Beam 1.0 page. llama.cpp RPC splits the layers over the network link. We found no Muse Spark Open run on two Sparks.

The GPU plus RAM route works because most of the model is experts. Put the experts in system RAM and keep attention on the GPU. Our —n-cpu-moe guide shows how. Neither Meta nor Unsloth publishes offload settings for this model.

How Fast Will It Be?

Only Apple has published speeds, all on M5 Ultra Mac Studios, with an 8,192-token prompt:

Nobody has published a single-machine number yet. Here is the bandwidth ceiling, which real runs never reach:

• One 512GB Mac at 3 bits: about 42B active x ~3.7 bits = ~19 GB read per token. 1.2 TB/s / 19 GB = about 60 tok/s at most. Expect much less.
• EPYC with 8-channel DDR4-3200: 204.8 GB/s. At 4 bits, about 24 GB per token. That is about 8 tok/s at most, before the GPU takes its share. For scale, a similar 461.81GB DeepSeek-R1 file ran at 4.2 tok/s on one 8-channel EPYC 7K62 (user report on our EPYC page).

These are ceilings, not predictions. Measure before you buy.

Software Support, Checked 31 October 2026

• llama.cpp: Unsloth’s card runs it with llama serve -hf unsloth/Muse-Spark-Open-816B-A42B-GGUF:UD-Q4_K_XL. Change the tag to the file that fits. The card does not name a minimum build, so update first.
• MLX: mlx-community has 3-bit and 4-bit builds. Apple’s multi-Mac numbers used MLX distributed inference over Thunderbolt 5.
• Ollama: muse-spark-open:cloud only. That runs on Ollama’s servers, not on your machine.
• vLLM and SGLang: for GPU servers. Meta says the NVFP4 checkpoint serves on four Blackwell Ultra GPUs or eight H200s.

Unsloth’s settings: temperature 1.0, top_p 1.0, top_k off. Reasoning effort is low, medium, high or xhigh.

What to Buy

If you already own 256GB, try the 2-bit file. Do not buy 256GB for it. A smaller model at 4 bits on the same box is the safer daily driver. Our M5 Ultra 256GB guide lists what runs well.

For 4 bits in VRAM, you need a rack. Four RTX PRO 6000 96GB cards hold only the 3-bit IQ3_XXS file. Meta’s NVFP4 needs Blackwell Ultra or H200 servers.

The cheapest full 4-bit box is a used EPYC server. An ASRock Rack ROMED8-2T board has eight memory slots, so 512GB means eight 64GB DDR4 RDIMMs. Add a used RTX 3090. It loads UD-Q4_K_XL. It is slow. Our EPYC MoE page has the build.

Plan the disk too. The files run from 176 GB to 506 GB. A 4TB NVMe drive holds two quants and the rest of your library.

If you want Meta’s own setup, it is two 512GB Mac Studios. We priced it at $44,598 and did the break-even math in Two Mac Studios for Muse Spark Open.

Test it on the API first. Aggregators list it at $1.25 per million input tokens and $4.25 per million output. A few dollars tells you if it does your work.

Honest Caveats

1. We did not run the model. Every fit row is arithmetic from file sizes and the config.
2. The cache figure is our estimate from the mlx-community config. Meta’s own config repo needs a login.
3. The 2 GiB compute buffer is a budget. We did not measure it.
4. The DGX Spark memory figure is second-hand. It comes from a community card for another model.
5. The speed ceilings are arithmetic. Real decode is lower.
6. Meta’s page shows two numbers for the smallest GGUF route, a 256 GB llama.cpp row and about 300 GB in the Unsloth section. Unsloth’s own page says the 2-bit UD-IQ2_XXS fits 256GB, and the file sizes agree with that.

Sources

• Meta: Build with Muse Spark Open: parameters, context, NVFP4 and BF16 sizes, Mac and GPU setups, GGUF note, licence, release date
• Meta Research: Muse Spark Open: licence terms
• File trees for unsloth GGUF, mlx-community 3-bit, mlx-community 4-bit, Meta NVFP4 and Meta BF16: byte sizes, read 31 October 2026
• mlx-community 4-bit config.json: layers, layer types, heads, head size, sliding window, context, experts per token
• Unsloth Muse Spark Open guide: memory table, “fits on 256GB”, settings, offload note
• Unsloth GGUF card: run commands
• Apple Machine Learning Research: MLX distributed inference: 2- and 4-Mac speeds, single Mac cannot run NVFP4
• Ollama library: muse-spark-open: cloud tag only
• pricepertoken.com: API price (aggregator)
• Our Beam 1.0 page: M5 Ultra wired limit, the 117.2 GiB Spark figure

See Also

• Two Mac Studios for Muse Spark Open: the real cost: Meta’s setup priced, and the break-even against the API
• Can I run Muse Glimmer 30B locally?: Meta’s open model for a normal GPU
• Can I run Mistral Large 4 locally?: the other 1T-class model this month
• Can you run Kimi K3 locally?: another 1T-class open model
• Best local LLM for a Mac Studio M5 Ultra 256GB: what to run on the 256GB box instead
• EPYC server CPU inference for MoE models: the 512GB DDR4 build
• —n-cpu-moe explained: how to put experts in system RAM