Meta Muse Glimmer 30B Local Hardware Guide (VRAM, Quants, Agent Stacks)

By LLM Hardware team · Methodology ·

Key facts

Model
30B, Apache-2.0, local. Distinct from the Muse app.
Q4 formula
20 GB. Meta K-quant language model about 17 GB.
Q8 formula
38 GB. Full precision: Meta says over 55 GB; formula sketch is 74 GB.
Checked
2026-10-13

Checked 2026-10-13. Author: LLM Hardware team. Amazon prices are not stored or shown on this site.

Citeable facts

Key fact: Muse Glimmer is a 30B Apache-2.0 model for local agents, not the consumer Muse app.

How we got it: Meta research post, 10 August 2026, and the Hugging Face card meta-models/Muse-Glimmer-30B.

Checked:

Key fact: Site-formula Q4 for 30B is 20 GB. Meta’s own K-quant language model is about 17 GB and is aimed at a 24–32 GB envelope once KV, perception, and the drafter are included.

How we got it: 30 × 0.5 × 1.2 + 2 = 20. Meta’s post: 4-bit language-model weights under 20 GB, K-Quant-17GB called out by name, full precision over 55 GB.

Checked:

Key fact: Q8 for the same 30B is about 38 GB. That is a 48–64 GB unified-memory tier, not a 24 GB GPU.

How we got it: 30 × 1.0 × 1.2 + 2 = 38.

Checked:

Key fact: As of 30 October 2026, Ollama lists muse-glimmer (Text and Image input, 128K window) and LM Studio lists meta/muse-glimmer with a minimum system memory of 26GB. Meta's deploy page requires Ollama 0.32.7 or later.

How we got it: ollama.com/library/muse-glimmer and its tags page; lmstudio.ai/models/meta/muse-glimmer; dev.meta.ai/docs/muse-glimmer/deploy.md. Read 2026-10-30. Listed, not run by this site.

Checked:

Key fact: With image input and the DFlash model at a 32,768-token context, Muse Glimmer at Q4 needs about 23.4 GB, which leaves 8.6 GB on a Mac Studio M5 Max 36 GB.

How we got it: 27.8B language model (29.6B card total minus the 1.8B encoder) x 0.5 x 1.2 + 2 = 18.7 GB; plus the 1.4 GB mmproj and 1.6 GB DFlash files (Meta deploy page); plus 32,768 x 53,248 bytes of f16 cache = 1.74 GB (52 layers, 2 KV heads, head_dim 128, config.json). 32 GB usable after a 4 GB macOS reserve.

Checked:

Key fact: Per token of f16 KV cache, K2-Horizon-32B needs 262,144 bytes, Qwen3.8-27B 65,536 and Muse Glimmer 53,248.

How we got it: config.json for each: 64 layers x 8 KV heads x 128; 16 full-attention layers x 4 KV heads x 256; 52 layers x 2 KV heads x 128; each x 2 for keys and values x 2 bytes. Read 2026-10-30.

Checked:

Methodology explains the VRAM formula, the bytes per weight at each quantization, and the full source list.

Muse Glimmer is Meta’s open-weight agent model: 30 billion parameters, Apache-2.0, built for tool use, failure recovery, screenshots, and local coding. Weights are on Hugging Face. This is not consumer Muse. That product stays on a cloud VM and is powered by Muse Spark. Buying a GPU does not install the Muse app, and installing the Muse app does not put Glimmer on your disk.

What Meta actually promised about memory

The 10 August 2026 research post says full precision for a 30B model is over 55 GB, which is already past any single consumer GPU. They compress the language-model weights to about 4-bit, under 20 GB, and they name a K-Quant around 17 GB. The working set they describe is that language model plus KV cache, a perception encoder for images, and a small DFlash drafter. Their envelope for all of that is 24 GB or 32 GB. They say they measured that 17 GB quant with the drafter on an M4 Max, an M5 Max, and an RTX 5090. The speeds are theirs. This page does not retype a speed table from that post, so it prints no tokens per second. The local-models guide quotes the model card’s speed table if you want those figures attributed.

Meta's August post said llama.cpp, MLX and ExecuTorch integrations, and the Ollama, LM Studio and Unsloth paths, would follow "in the coming days". By 30 October 2026 they are listed. Ollama's library has a muse-glimmer model with Text and Image input and a 128K window, and Meta's deploy page says it needs Ollama 0.32.7 or later. LM Studio's catalog lists meta/muse-glimmer with a minimum system memory of 26GB. Meta's deploy page also documents llama.cpp, SGLang, ExecuTorch and vLLM. Its vLLM path loads the bf16 weights and needs about 72 GB of VRAM, so it is a multi-GPU or data-center setup, not a single consumer card.

Run it today

From Meta's deploy page and Ollama's library page, read on 30 October 2026. With Ollama 0.32.7 or later:

ollama run muse-glimmer

On Apple silicon, Meta's deploy page gives the MLX build instead:

ollama run muse-glimmer:30b-mlx

Ollama's tags for the model, with the sizes its library lists:

Tag Listed size Note
muse-glimmer:30b (also latest) 18GB Same listed size as muse-glimmer:30b-q4_K_M
muse-glimmer:30b-q4_K_M-dflash 20GB 2 GB more than the plain q4_K_M tag
muse-glimmer:30b-mlx 19GB MLX engine, Apple silicon
muse-glimmer:30b-nvfp4 17GB MLX engine
muse-glimmer:30b-q8_0 31GB 8-bit
muse-glimmer:30b-bf16 57GB 16-bit

Ollama does not explain the -dflash suffix on its page. Meta ships a DFlash speculative-decoding model with Glimmer, and each -dflash tag is listed 2 GB larger than the matching plain tag.

In LM Studio, Meta's deploy page says to download Muse Glimmer in LM Studio Bionic under Settings, Explore, then start the OpenAI-compatible server, which listens on port 1234 by default. If a request returns "model not found", query /v1/models and use the exact ID it lists.

lms server start

Quant table: their number and ours

Two numbers can both be honest. Meta measured a specific K-quant. Our VRAM formula is a planning estimate that does not know their exact quantization recipe: params × bytes × 1.2 + 2. Use the vendor file size when you have it, and the formula when you are comparing Glimmer to Qwen3.8-27B or K2-32B. Check a context length on the VRAM calculator.

Mode Figure Box that matches
Q4, VRAM formula 30 × 0.6 + 2 = 20 GB 24 GB GPU, or 32 GB unified, before a long chat
Meta K-quant LM About 17 GB language model. Under 20 GB at 4-bit. 24–32 GB once KV, vision, and the drafter join
Q5 30 × 0.625 × 1.2 + 2 = 24.5 GB 32 GB, tight. 36 GB unified is calmer.
Q8 30 × 1.2 + 2 = 38 GB 48–64 GB unified
BF16 / FP16 Formula 30 × 2.4 + 2 = 74 GB. Meta: over 55 GB at full precision. Not a 24 GB or 32 GB card. Quote Meta’s 55 GB for their weights; use 74 GB only as the formula’s overhead-inclusive sketch.

A 16 GB gaming card is below the target Meta published. Do not buy one “for Glimmer.” A 12 GB card is a 7B machine: K2-Horizon-7B at Q4 is 6.2 GB. Different job.

Context beside the weights: a worked example

The quant table covers weights. A running agent also holds the image encoder, the optional DFlash model and the KV cache for its context. Each piece, from the model card, Meta's deploy page and the site formula:

Piece Size Where the number comes from
Language model at Q4 18.7 GB The card lists 29.6B parameters including a 1.8B vision encoder, which leaves 27.8B. 27.8 × 0.5 × 1.2 + 2 = 18.7 GB.
Perception encoder, for image input 1.4 GB Meta's mmproj-Muse-Glimmer-30B-Q4_K_M.gguf file. llama.cpp loads it with the text model; --no-mmproj skips it for text-only work.
DFlash speculative-decoding model, optional 1.6 GB Meta's dflash-Muse-Glimmer-30B-Q4_K_M.gguf file.
KV cache, f16 53,248 bytes per token config.json: 52 layers, 2 KV heads, head_dim 128, so 2 × 52 × 2 × 128 × 2 bytes. That counts every layer. 39 of the 52 layers use a 2,048-token sliding window, so a runtime that caps those layers needs about 0.52 GB at 32,768 tokens instead of 1.74 GB.

Totals below add the two files at their published sizes and the full-layer cache:

Context Text only With images Images and DFlash
32,768 tokens (cache 1.74 GB) 20.4 GB 21.8 GB 23.4 GB
131,072 tokens, the native window (cache 6.98 GB) 25.7 GB 27.1 GB 28.7 GB

On named machines:

One cross-check from Meta: its deploy page puts the Q4_K_M build at about 24.1 GiB (25.9 GB) in LM Studio at one request and a 16K context, and says to leave room for the OS and the app. That is 3.3 GB above this page's 22.6 GB for the same context with images and DFlash. On the 36 GB Mac Studio, Meta's figure still leaves 6.1 GB. It is over 24 GB, so on a 24 GB card use Ollama or llama.cpp with the 4-bit build and run ollama ps: the Ollama FAQ says 100% GPU means the model loaded entirely on the GPU.

Muse Glimmer vs Qwen3.8-27B vs K2-Horizon-32B

All three are open-weight models that a 24 to 36 GB machine can hold at Q4. Figures are from each model card and config.json, read on 30 October 2026, and the site formula. Cache figures are f16.

Muse Glimmer 30B Qwen3.8-27B K2-Horizon-32B
Maker Meta Qwen IFM
License Apache-2.0 Apache-2.0 Apache-2.0
Parameters 29.6B, dense, including a 1.8B vision encoder 27B, dense; 48 linear-attention and 16 full-attention layers 32B, dense; Hugging Face counts 35B
Input Text and images Text and images; the card calls it a native vision-language model Text; the card lists text generation only
Native context 131,072 tokens 262,144 tokens 524,288 tokens
Q4 weights, formula 19.8 GB 18.2 GB (18.8 GB on the Hub's 28B) 21.2 GB (23.0 GB on the Hub's 35B)
Cache per token 53,248 bytes, all 52 layers 65,536 bytes, the 16 full-attention layers 262,144 bytes, all 64 layers
Cache at 32,768 tokens 1.7 GB 2.1 GB 8.6 GB
Q4 plus 32,768 tokens 21.5 GB 20.3 GB 29.8 GB
Ollama muse-glimmer, 18GB qwen3.8:27b, 18GB No official Ollama library page on 30 October 2026 (user uploads exist under other namespaces; check who published one before using it); the card shows vLLM, SGLang, Transformers and Docker Model Runner

Job fit, by memory. For a screenshot agent on a 24 GB card, Glimmer and Qwen3.8-27B both take images and both leave room for 32,768 tokens of context. Qwen3.8-27B's linear-attention layers keep a fixed-size state that does not grow with context, so only its 16 full-attention layers add cache per token. For long text-only context, K2-Horizon-32B costs 4 to 5 times the cache per token of the other two, so at 32,768 tokens it is already past a 24 GB card and needs the 36 GB Mac Studio or the 32 GB RTX 5090. Meta describes Glimmer as an agentic model; this page does not rank the three on output quality. The Glimmer row uses the card's 29.6B total, which includes the encoder.

Agent stack around the weights

Glimmer is the brain. It still needs a scaffold. Meta says it works with OpenClaw and other orchestration patterns, and they show an OpenCode demo. This guide does not deep-link OpenClaw; the project URL was not re-confirmed in this pass. What this guide points to:

Screenshot tasks use the perception encoder, so they sit in the 24–32 GB envelope Meta described, not in the 17 GB language-model file alone. Text-only tool calls can be leaner. Do not plan the vision agent on the language-model number.

What to buy

The single-user machine in this catalog is the Mac Studio M5 Max 36 GB. With images and DFlash at 32,768 tokens it leaves 8.6 GB, and Meta's own LM Studio figure leaves 6.1 GB. The NVIDIA GeForce RTX 5090 32 GB holds the same stack with the same room and no macOS share; it was listed as unavailable at our last catalog check, so it has no link here. The RTX 4090 this page linked before was also listed as unavailable. For Q8, where the language model alone is 35.4 GB, or for Glimmer beside a second model, the Mac Studio M5 Max 64 GB is configured at Apple and has no Amazon listing in our catalog.

Mac Studio M5 Max 36 GB on Amazon

ASIN B0HGKSQMX6. Amazon Associates link. The live price is on that page, not locked in here.

Sources

Questions

Can I run Muse Glimmer in Ollama today?

Yes. On 30 October 2026 Ollama's library lists muse-glimmer, and Meta's deploy page gives ollama run muse-glimmer for Ollama 0.32.7 or later, or ollama run muse-glimmer:30b-mlx on Apple silicon. The default tag is listed at 18GB.

How much memory does the image encoder add?

Meta's encoder file for the Q4_K_M build, mmproj-Muse-Glimmer-30B-Q4_K_M.gguf, is about 1.4 GB. The model card puts the encoder at about 1.8B of the model's 29.6B parameters. In llama.cpp, --no-mmproj skips it for text-only work.

Is a 24 GB card enough for Muse Glimmer?

By our formula, the 4-bit language model and the encoder come to 20.1 GB, which leaves room for about 73,600 tokens of cache on 24 GB, and Meta aims its 17 GB build at 24 GB of VRAM. Meta's own LM Studio figure, about 24.1 GiB at a 16K context, is over 24 GB, so on a 24 GB card use Ollama or llama.cpp and check ollama ps. A Mac Studio M5 Max 36 GB leaves 6.1 GB even at Meta's LM Studio figure.

Which is lighter on memory at long context, Glimmer, Qwen3.8-27B or K2-Horizon-32B?

Glimmer and Qwen3.8-27B. At 32,768 tokens their f16 caches are about 1.7 GB and 2.1 GB, against 8.6 GB for K2-Horizon-32B, because K2 keeps a full-size cache on all 64 layers.

A correction or a hardware question goes to the contact page.