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:
By LLM Hardware team · Methodology ·
Checked 2026-10-13. Author: LLM Hardware team. Amazon prices are not stored or shown on this site.
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.
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.
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
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.
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.
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.
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.
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.
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.
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.
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.
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.