Muse Glimmer VRAM Requirements: Three Files, Not One

How Much VRAM Does Muse Glimmer Need?

About 17.1 GB for the Q4 weights and a short context, and about 21.9 GB if you want vision, the speculative decoding drafter and the full 128K context at the same time. Muse Glimmer is a 29.6B dense multimodal model from Meta Superintelligence Lab, published as meta-models/Muse-Glimmer-30B on August 10, 2026 under Apache 2.0. It was built to fit a 24 GB card and it does, with roughly two gigabytes spare even with everything switched on.

The figure circulating on launch day is 18 GB. That is one file. The release ships three, and they compete for the same card.

All four together is 20.74 GB before the runtime takes its own cut. Adding llama.cpp’s overhead, which we model as a fixed 0.75 GB plus 2% because most of it is CUDA context and compute buffers that do not scale with the model, gives 21.9 GB. That fits a 24 GB card with about two gigabytes to spare.

The 18 GB Figure Is One File Out of Three

Unsloth’s guide says Muse Glimmer “runs on 18GB RAM/VRAM setups”, and that number holds up. Our own arithmetic lands at 17.1 GB for the Q4 weights, an 8K cache and llama.cpp’s overhead. The figure is right about what it covers.

What it covers is one file. llama.cpp ships multimodal projectors as a separate download and always has, and Unsloth’s own llama.cpp walkthrough points at mmproj-BF16.gguf, which is 3.85 GB on its own. Even the small kquant projector adds 1.40 GB. Meta then ships a speculative decoding drafter on top, which Unsloth’s page does not mention anywhere.

The failure mode with the projector is quiet, which is what makes it worth writing down. You pull the Q4 file, it loads, it answers questions, and you conclude it works. Then you paste a screenshot and it has nothing to say about it. Nothing warns you. It is a quoted price with the delivery charge left off: not a lie, just not what arrives at your door.

On a 16 GB card this stops being a nuisance and becomes the whole decision. Q3_K_XL text-only lands at about 14.6 GB, which fits. Add the projector and it is 16.0 GB, which leaves a card that is also driving a display nowhere to stand. Nothing at 3-bit or above gets Muse Glimmer’s vision onto a 16 GB card with working headroom. You can force it: Unsloth publishes UD-IQ2_XS at 11.51 GB, which leaves the projector room to spare at 14.1 GB total. Whether a 2-bit 28B is still the model you wanted is a different question, and on a card this size the honest answer is that text-only at Q3 is the better trade.

Meta Published Its Own Target Hardware, and It Is Worth Reading Closely

The model card carries a table most launch coverage skipped:

Target hardware and degradation are Meta’s. The file sizes are not in Meta’s table: those are the published files in the safetensors and GGUF repositories, read on August 10. Degradation is described as an average across 15 common benchmarks. Take it as the vendor’s number, because that is what it is.

The card is explicit that the 24 GB envelope has to hold four things at once: the compressed model, the KV cache, the perception encoder and the drafter. At Meta’s own 16.76 GB build, all four components with the full 128K context comes to 22.8 GB after llama.cpp overhead, and at 32K it is 21.5 GB. The target is met, including at maximum context.

The odd part is that Meta’s 24 GB build is not the smallest one available. Unsloth’s UD-Q4_K_XL is 15.88 GB against Meta’s 16.76 GB, and swapping it in takes the same four components at 32K down to 20.6 GB. The community quant is smaller than the one the lab shipped for the card it names.

So the 24 GB target is real and it holds at full context, which is a better result than the spec sheet promises. The catch is not the arithmetic. It is that hitting it requires knowing there are three files to download.

Why 128K Context Costs 1.8 GB Instead of 7

This is the part that makes the model fit at all, and nobody quoted it.

The config.json carries a layer_types array. Of 52 layers, 39 are sliding_attention with a 2,048-token window and 13 are full_attention, in a repeating three-to-one pattern that Meta’s card describes as “[Local, Local, Local, Global] repeating”. The sliding layers never cache more than 2,048 tokens however long the conversation runs. Only the 13 global layers grow.

Picture a long meeting where three quarters of the room only remember the last ten minutes, and a quarter took notes the whole way through. The room still has the full record. It just is not paying twelve people to keep it.

Add 2 key-value heads against 32 query heads, a 16:1 grouped-query ratio, and the cache stays small at any length.

Going from a short context to the full 128K costs 1.64 GB. A calculator that applies a flat percentage derate for long context gets this wrong by roughly a factor of four, which is why our calculator carries Muse Glimmer with the 13 and 39 layer split rather than one attention profile.

Meta’s Own Speed Numbers, and What They Cost

Meta published measured throughput in the model card. These are vendor figures, batch size 1, greedy decoding, using the K-Quant-17GB build with the quantized DFlash drafter.

DFlash proposes blocks of 16 tokens at a time and the main model verifies them in parallel, so the speedup is real rather than a change in sampling. Meta states output quality is identical.

One other party has published numbers, and it is not a neutral one either. AMD measured up to 24 tok/s on a Ryzen AI Max+ 395 and up to 53 tok/s on a single Radeon AI PRO R9700 with DFlash, on Windows through llama.cpp’s Vulkan backend at --spec-draft-n-max=4. AMD calls the build preliminary and expects the numbers to move. Two vendors measuring their own hardware is still not independent verification, but it is the only cross-check that exists on day one, and the shapes agree.

Here is the part that connects back. That 3.1x needs the 1.63 GB drafter resident, on top of the projector and the cache. On a 24 GB card all three fit at 21.9 GB, which is the whole argument for this model: vision, maximum context and the speedup, on a card people already own. Leave one out by accident and you have paid for something you are not using.

What Meta’s Benchmark Table Actually Says

The card compares Muse Glimmer-30B in high reasoning mode against Gemma 4 31B and Qwen3.6-27B in thinking mode, across 22 benchmarks plus two safety rows. Launch-day posts have summarised this as Muse Glimmer beating both.

Counting the rows Meta itself marks as the best result: Muse Glimmer takes 12 of 22, Qwen3.6-27B takes 8, and Gemma 4 31B takes 2. A lead, and a real one. Not a sweep.

The pattern is legible. Muse Glimmer leads on agent orchestration, long-context retrieval and maths. Qwen3.6-27B leads on most multimodal benchmarks and on the two best-known coding evaluations. For a model whose pitch is autonomous agentic work on your own hardware, that split is arguably the right one to have won.

Two caveats worth carrying. These are the vendor’s own evaluations, and nobody has re-run them. Hugging Face reproduced the same table in its launch-day post and labelled it “scores are reported as published”, which is honest and is also not independent verification. And a 27B being competitive with a 30B on multimodal is the kind of result that gets revisited when Qwen 3.8 lands, which is expected within days. We covered that field in Chinese open-weight models.

Our Calculator Says 17.9 GB. The File Says 16.76. Both Are Right.

This one is worth walking through, because the obvious reading of it is that our tool is 7% wrong, and we nearly published that ourselves.

Our generic Q4_K_M profile assumes 4.85 bits per weight. Against Meta’s stated 29.6B that predicts 17.9 GB. The file you actually download is 16.76 GB. Seven percent is not a rounding error, and a VRAM calculator that runs 7% high is telling people their card will not fit something it will.

Except the two figures describe different objects. Meta’s 29.6B includes the perception encoder. The GGUF weight file does not. Hugging Face’s launch post splits it as a 2B encoder plus a 28B text decoder, and Hugging Face’s own repository listing agrees: the safetensors repo is tagged 30B, the GGUF repo is tagged 28B. The encoder ships as the separate projector, so the weight file is the decoder alone.

Count the same components on both sides and the disagreement evaporates. Meta’s 16.76 GB text file plus its 1.40 GB projector is 18.16 GB for the whole model. Our profile predicts 17.9 GB. That is 1.2% low, not 7% high.

The BF16 side confirms it from the other direction, because the safetensors do contain the encoder: 59.55 GB of real files against 59.2 GB predicted from 29.6B at two bytes each.

So the lesson is not that anyone’s arithmetic is broken. It is that on a multimodal model, “parameter count” and “the thing you download” differ by about a gigabyte and a half, and every comparison has to say which one it means. The rule this site runs on still decides what gets published: observed beats theoretical. Where a real file exists, quote the file.

What Fits On Your Card

These are the tightest fits in any table we have published, so read the context column as a constraint rather than a suggestion. A 32 GB Mac reserves roughly a third of unified memory for the system by default, about 21 GB, so the full stack needs sudo sysctl iogpu.wired_limit_mb raised before it will load. That figure is community-documented rather than something Apple publishes.

The interesting row is the 24 GB one, because it is the card most people reading this already own, and because it is the only row where you have to choose. If you are sizing a purchase around this model, our GPU buying guide covers the used 3090 case, and the 8 GB gap to a 5090 buys you the thing this article is about.

Fine-Tuning It Is a Different Budget Entirely

Running a model and training one are not the same question, and the gap here is wide enough to be worth its own table. Hugging Face published hardware requirements from its own TRL experiments, run in BF16 on 80 GB Hopper-class cards. These are Hugging Face’s figures from their own runs, not Meta’s.

Read the first two rows together and the shape of it is clear. The card that runs this model at Q4 costs a few hundred dollars used. The card that LoRA fine-tunes it in BF16 is an H100. Inference and training are different products that happen to share a filename.

Note also that these are BF16 figures. Nothing in Hugging Face’s table covers 4-bit training, which is the route most people reading this would actually take. Expect community QLoRA recipes to land well below these numbers, and treat the table as the ceiling rather than the requirement.

The License Is Actually Apache 2.0

Worth checking rather than repeating, because Meta’s previous open releases were not. The LICENSE file is the unmodified standard Apache License 2.0 text and the model card’s metadata declares license: apache-2.0. A separate USAGE_POLICY.md sets acceptable-use terms. It sits outside the licence file and adds no conditions to the Apache text itself, which is the part that governs what you may do with the weights.

That is a real change of posture from the Llama Community License, and it puts Muse Glimmer on the same permissive footing as the Chinese releases it is being measured against.

Check what your own GPU fits, or size Muse Glimmer directly in the calculator, which now carries it with the real 13 and 39 layer split. If you are squeezing it onto a smaller card, our llama.cpp flags guide covers the KV quantization and offload options that buy back a few gigabytes.

FAQ

How much VRAM does Muse Glimmer need?

About 17.1 GB for the UD-Q4_K_XL weights and an 8K context including llama.cpp overhead. With the vision projector, the DFlash drafter and the full 128K context it is about 21.9 GB. The Q4 weight file alone is 15.88 GB.

Does Muse Glimmer fit on a 24GB card?

Yes, and Meta targets exactly that card with its K-Quant-17GB build. Vision, the speculative decoding drafter and the full 128K context together come to about 22.8 GB on Meta’s build, or 21.9 GB on Unsloth’s slightly smaller UD-Q4_K_XL. The constraint is not memory. It is remembering to download all three files.

Does Muse Glimmer fit on a 16GB card?

Text comfortably, vision only if you go low. UD-Q3_K_XL is about 14.6 GB at 8K, which fits. Adding the 1.40 GB vision projector takes it to roughly 16.0 GB, which does not leave room to work on a card that is also driving a display. No build at 3-bit or above fits both. The 2-bit quants do: UD-IQ2_XS plus the projector lands near 14.1 GB, at a quality cost you will notice.

What are the mmproj and dflash files?

mmproj-kquant.gguf is the perception encoder, 1.40 GB, needed only for images and video. dflash-kquant.gguf is the DFlash speculative decoding drafter, 1.63 GB, needed only for the faster generation. Both are separate downloads in Meta’s GGUF repository and the model runs without either, as a text model at standard speed, with no warning that anything is missing.

How fast is Muse Glimmer?

Meta’s own published measurements, at batch size 1 with greedy decoding on the K-Quant-17GB build: 74.9 tok/s on an RTX 5090 without speculation and 233.4 tok/s with the DFlash drafter, a 3.1x speedup. On an Apple M5 Max it is 26.6 and 50.2, and on an M4 Max 23.7 and 37.8. Apple figures used ExecuTorch, the RTX used llama.cpp. These are Meta’s own numbers. The only other measurements published so far are AMD’s, which reports up to 24 tok/s on a Ryzen AI Max+ 395 and up to 53 tok/s on a Radeon AI PRO R9700 with DFlash, measured on Windows in llama.cpp with the Vulkan backend at --spec-draft-n-max=4, on what AMD calls a preliminary version of the model. Nobody neutral has re-run any of it.

Why does Muse Glimmer’s KV cache stay so small at long context?

Because 39 of its 52 layers use sliding-window attention capped at 2,048 tokens and only 13 use full attention, in a repeating local-local-local-global pattern. Combined with 2 key-value heads against 32 query heads, the full 131,072-token context costs about 1.83 GB in F16 rather than the roughly 6.98 GB a uniform-attention model of the same shape would need.

Does Muse Glimmer actually beat Gemma 4 and Qwen3.6?

On Meta’s own comparison table it wins 12 of 22 benchmarks, Qwen3.6-27B wins 8 and Gemma 4 31B wins 2. Muse Glimmer leads on agentic orchestration, long-context retrieval and maths. Qwen3.6-27B leads on most multimodal benchmarks and on SWE-Bench Verified and TerminalBench. These are the vendor’s own evaluations.

How many parameters is Muse Glimmer?

29.6B by Meta’s count, including the perception encoder, and dense rather than a mixture of experts. The BF16 safetensors total 59.55 GB across two shards. The language model has 52 layers, a hidden dimension of 6,656, SwiGLU feed-forward at 19,968 and a 202,048-token vocabulary. The encoder is roughly 1.8B parameters, a ViT-G/14 with 50 layers, which Hugging Face rounds to a 2B encoder plus a 28B text decoder.

What VRAM do I need to fine-tune Muse Glimmer?

Far more than to run it. Hugging Face published figures from its own TRL experiments in BF16: one 80 GB H100 for LoRA SFT with microbatch 1 and gradient checkpointing, eight 80 GB H100s for a full SFT with FSDP or ZeRO-3, and for full fine-tune GRPO it says eight GPUs is usually insufficient. Those are BF16 numbers and do not cover 4-bit training, so community QLoRA recipes should land well below them.

How do I run Muse Glimmer in llama.cpp?

Support shipped day-0. Hugging Face’s launch post gives llama serve -hf meta-models/Muse-Glimmer-30B-GGUF to start a server with the built-in WebUI on port 8080. To enable the DFlash drafter, add --spec-type draft-dflash. Hugging Face’s post notes the drafter was trained with a block size of 16, one anchor token plus 15 proposed, so any --spec-draft-n-max above 15 is clamped to 15.

What license is Muse Glimmer under?

Apache 2.0. The repository ships the standard Apache 2.0 text and the model card declares license: apache-2.0, with a separate usage policy covering acceptable use. This differs from the Llama Community License used for Meta’s earlier open releases.

Can Ollama run Muse Glimmer?

Yes as of v0.32.7, released August 10, 2026. Ollama’s release note describes initial support through its MLX engine on Apple Silicon, with NVIDIA, AMD and other platforms described as coming. llama.cpp had day-0 support per Hugging Face’s launch post, and cut three builds on August 10 alone. Both move quickly after a launch, so check the current release before assuming your platform is covered.

What is Muse Spark, and are its weights available?

Muse Spark is the larger Meta model that Muse Glimmer was distilled from. Mark Zuckerberg’s announcement on August 10, 2026 said weights for Muse Spark 1.2 would follow soon, without a date. There is no public repository for it as of publication: the meta-models organisation holds four repositories and all four are Muse Glimmer.