CanItRun Logocanitrun.

Muse Glimmer 30B

Muse Glimmer 30B needs roughly 19.2 GB VRAM at Q4_K_M quantization (62.5 GB at FP16). 78 GPUs we track can run it fully in VRAM at 8k context.

78 GPUs run this natively · 21 with CPU offload

Meta27.8B params128k contextApache 2.0Commercial use ok
Q4_K_M total
19.2 GB
at 8k context
Smallest GPU
24 GB
NVIDIA RTX 4090, at Q4_K_M
KV cache, full context
1.8 GB
13 of 52 layers grow with context, 39 capped at 2,048 tokens
Inputs
Text · Image
Apache 2.0, released August 2026
Attention pattern
3 local : 1 global
2,048-token sliding window
Vision encoder
~1.8B ViT-G/14
separate mmproj file, not merged

Muse Glimmer 30B is a 27.8B parameter dense model developed by Meta. Released 10 August 2026 under Apache 2.0 — Meta's first model built specifically for always-on local agent workflows rather than general chat, distilled from the larger, unreleased Muse Spark via logit distillation, long-context agentic data, and reinforcement learning. Dense, not MoE: all 27.8B text-backbone parameters run on every token. Its 52 attention layers repeat a 3-local/1-global sliding-window pattern (2,048-token window, 32-query/2-KV-head grouped-query attention, or GQA), and a separate ~1.8B-parameter ViT-G/14 perception encoder adds image input (Meta's own "30B" branding is the ~29.6B combined total). Context is 131,072 tokens natively.

To run Muse Glimmer 30B locally: Q4_K_M's real total is about 19.2GB at 8k context and 21.0GB at the full 131,072-token window — both with real headroom under a 24GB card's usable ceiling, since only 13 of the 52 layers actually grow their KV cache with context. A 24GB card (RTX 4090, RTX 3090, RTX 5090) comfortably holds the entire native context window at Q4_K_M. On 16GB, Q3_K_M's real total (15.2GB at 8k context) just clears the card's ~15.2GB usable ceiling with no headroom to spare, so Q2_K or a partial CPU offload is the safer real-world floor there. Ollama's launch-day tag, muse-glimmer:30b-mlx, is Apple Silicon (MLX) only — llama.cpp against Unsloth's or Meta's own GGUF builds is the cross-platform route until NVIDIA/AMD Ollama support lands.

Meta's own launch comparison reports SWE-bench Pro 51.2, SWE-bench Verified 76.0, Terminal-Bench 2.1 51.7, and GPQA Diamond 83.5 — ahead of Gemma 4 31B on most of those, and edging past Meta's own measurement of Qwen 3.6 27B on SWE-bench Pro (50.2 in Meta's harness, though Alibaba's own self-reported figure for the same benchmark is 53.5). Meta did not report classic MMLU-Pro, MATH, or IFEval scores for this release.

Three sliding-window layers for every one full-attention layer

Muse Glimmer's text backbone is dense — all 27.8 billion parameters run on every token, with no MoE routing keeping any of them idle (a separate ~1.8B vision encoder rounds Meta's own branding up to "30B" but ships as its own file, outside this count). What's unusual is that its 52 attention layers aren't all the same shape: the stack repeats a block of three sliding-window layers followed by one full-attention layer, thirteen times over. A sliding-window layer can only look back across the most recent 2,048 tokens, however long the conversation gets; a full-attention layer can look all the way back to the first token. Both keep a real KV cache — the difference is how far back each layer is allowed to look.

Sliding-window attention2,048-token window, 2 KV heads × 128 dimFull attentionwhole context, 2 KV heads × 128 dim
layer 13:1 pattern × 13layer 52

13 of 52 layers keep a KV cache that grows with the full context. 39 more cap their cache at a fixed 2,048-token window, no matter how long the context gets.

Once a conversation passes 2,048 tokens — well within the first exchange — the 39 sliding-window layers stop growing; only the 13 full-attention layers keep accumulating. Combined with a narrow 32-query/2-KV-head grouped-query attention (GQA) ratio of 16:1 — one of the tightest tracked on this site — that keeps the whole KV cache under 2 GB even at the full 131,072-token context — small enough that, unlike most 30B-class models, the download size alone is almost the entire VRAM bill, and context costs next to nothing on top of it.

What the full 131,072-token context actually costs: almost nothing

On most dense models this size, the KV cache is the line that grows out of control as context fills up, forcing a trade between context length and how much of the card is left for the model itself. Muse Glimmer's narrow 2-KV-head attention and its 3:1 local:global split attack that from two directions at once — narrower cache entries, and three-quarters of the layers capped at a 2,048-token window.

024688k64k128k128k2,048-token window1.8 GBMuse Glimmer 30B7.0 GBno split
Muse Glimmer 30B — 13 of 52 layers grow with contextThe same 30B if every layer used full, uncapped attention

KV cache only, at FP16. Weights and activation overhead sit on top of these figures.

Filling the entire 131,072-token window costs about 1.8 GB of KV cache, versus 7.0 GB for the same stack without the local:global split — a real difference, but a small one next to the 16.9 GB of Q4_K_M weights sitting underneath either way. Add those together with activation overhead and the full-context total is about 21.0 GB, against the no-split hypothetical's 26.8 GB. The practical upshot: on this model, the quantization you pick decides your VRAM budget far more than how much context you actually use — a 24 GB card holds Q4_K_M at the entire native context window with real headroom to spare (21.0 GB against a real ~22.8 GB ceiling), which isn't true of most other 30B-class dense models on this site.

VRAM at each quantization

Muse Glimmer 30B natively supports a longer context window, but the table below is capped at 8k for comparability — its hybrid attention stack keeps KV cache growth well below linear.

QuantWeightsKV cacheTotal
FP32111.2 GB0.19 GB124.8 GB
BF1655.6 GB0.19 GB62.5 GB
FP1655.6 GB0.19 GB62.5 GB
Q8_029.6 GB0.19 GB33.3 GB
Q6_K22.8 GB0.19 GB25.8 GB
Q5_K_M19.8 GB0.19 GB22.4 GB
Q4_K_Mrec16.9 GB0.19 GB19.2 GB
Q3_K_M13.4 GB0.19 GB15.2 GB
Q2_K10.6 GB0.19 GB12.1 GB
NVFP4cuda13.9 GB0.19 GB15.8 GB

Shown at 8k context with FP16 KV cache. NVFP4 needs a CUDA GPU to run. Toggle TurboQuant in the calculator to view compressed KV cache numbers.

Benchmarks

GPQA Diamond
83.5
SWE-bench Verified
76
SWE-bench Pro
51.2
Terminal-Bench 2.1
51.7

SWE-bench Pro: a 30B model near the frontier MoE pack

SWE-bench Pro is the benchmark where Meta's own launch comparison draws the clearest line: run through Meta's evaluation harness, Muse Glimmer's 51.2 beats both Gemma 4 31B (36.9) and Qwen 3.6 27B (50.2). That Qwen figure is lower than Alibaba's own self-reported 53.5 for the same benchmark elsewhere on this site — a reminder that SWE-bench Pro scores move with whichever harness ran them, not just the model. Plotted by parameter count against every other model tracked here that reports this benchmark, Muse Glimmer sits close to MiniMax M3 (59.0) and MiMo V2.5 Pro (57.2) — MoE models fifteen to thirty-five times its total parameter count.

4553.56210B100B1T10TTotal parameters (log scale)Qwen 3.6 27BStep 3.7 FlashMiMo V2.5 ProMiniMax M3Muse Glimmer 30B
SWE-bench Pro, as reported by each model's own publisher. Scaffolding and harness differ between vendors, so read the gaps as approximate rather than a ranking.

GPUs that run Muse Glimmer 30B natively (78)

Show 73 more
Plus 21 GPUs that run it with CPU offload (slower)

Notes

Distilled from Meta's larger, unreleased Muse Spark via logit distillation, long-context agentic data, and reinforcement learning — built for always-on local agent workflows (coding, tool use, autonomous failure recovery) rather than general chat. The ~1.8B-parameter ViT-G/14 perception encoder that provides image input ships as a separate mmproj file, not merged into the main GGUF, and isn't counted in the parameter total above — Meta's own "30B" branding refers to the combined ~29.6B including that encoder. Meta also publishes an optional DFlash speculative-decoding drafter (5 layers, block size 16) alongside the base weights. Benchmark figures are Meta's own, measured against Gemma 4 31B and Qwen 3.6 27B on an Artificial Analysis-style agentic suite rather than the classic MMLU-Pro/MATH/IFEval set, which Meta did not report for this release. Ollama's only tag at launch, muse-glimmer:30b-mlx, runs exclusively on Apple Silicon via the MLX engine; NVIDIA and AMD support was still rolling out as of release day.

Hugging Face ↗Ollama ↗Released 2026-08-10

Compare Muse Glimmer 30B with other models

How to run Muse Glimmer 30B locally

816244880160320

Q4_K_M needs 19.2 GB — fits a single high-end consumer GPU (24 GB).

llama.cpp (Meta's recommended sampling)

./llama-server \
  -hf unsloth/Muse-Glimmer-30B-GGUF:UD-Q4_K_XL \
  -c 131072 -ngl 99 \
  --temp 1.0 --top-p 0.95 --top-k 64

Ollama

# Apple Silicon only at launch (MLX engine) — NVIDIA/AMD support was still rolling out on release day
ollama run muse-glimmer:30b-mlx

llama.cpp

# Vision needs the projector file alongside the weights
./llama-server \
  -hf unsloth/Muse-Glimmer-30B-GGUF:UD-Q4_K_XL \
  --mmproj mmproj-BF16.gguf \
  --temp 1.0 --top-p 0.95 --top-k 64

LM Studio: Search for 'Muse Glimmer' — if LM Studio hasn't indexed it yet, point 'Load from folder' at a downloaded UD-Q4_K_XL file from Unsloth's GGUF repo directly. Load the separate mmproj file alongside it for image input.

Why this quantization? UD-Q4_K_XL puts the weights at roughly 16.9 GB, and because only 13 of the 52 layers keep a KV cache that actually grows with context, the total barely moves as the context window fills: about 19.2 GB at 8k context and 21.0 GB at the full 131,072-token window, both with real headroom under a 24 GB card's real ~22.8 GB ceiling. That flatness is unusual for a 30B-class model — most dense models this size force a trade between context length and VRAM headroom, and here that trade barely exists. Step down to Q3_K_M only below 24 GB, and don't expect much slack even there on a 16 GB card — its own real total (15.2 GB at 8k context) just clears a 16 GB card's usable ceiling with no headroom left over.

Who is Muse Glimmer 30B for?

Owners of a single 24 GB GPU (RTX 4090, RTX 3090, RTX 5090) or 32 GB+ Apple Silicon who want a coding- and tool-use-focused local agent that holds its entire 131,072-token context without trading context for VRAM headroom the way most 30B-class models do.

Best for

  • Local coding agents that read a repository, edit files, and run commands autonomously
  • Long-running agent sessions where a nearly-flat KV cache matters more than squeezing out a bigger context window elsewhere
  • LLM-as-a-judge and evaluation workflows Meta specifically tuned this release for
  • Screenshot and diagram understanding via the perception encoder
  • Replacing a paid coding-agent API on a single workstation

Not ideal for

  • 16 GB GPUs, where even Q3_K_M's real total runs past what the card can hold
  • NVIDIA or AMD users on Ollama specifically — the launch-day tag is Apple Silicon (MLX) only; use llama.cpp or vLLM directly instead
  • Anyone who needs classic MMLU-Pro, MATH, or IFEval scores to compare against older models — Meta didn't report them for this release
  • Anyone who needs benchmark claims independently verified before adopting a model — this released the same day as this page was written

So should you run it?

On a single 24 GB card — an RTX 4090, RTX 3090, or RTX 5090 — this is a clean fit: Q4_K_M totals about 21.0 GB even at the full 131,072-token context, with real headroom to spare against the card's real ceiling, and no CPU offload needed anywhere in that window. That's unusual for a model this size; most 30B-class dense models force a trade between context length and headroom, and here the trade barely exists because the KV cache stays under 2 GB no matter how full the context gets. On 16 GB, Q3_K_M just clears the ceiling at 8k context (15.2 GB against the card's ~15.2 GB usable ceiling) with no headroom left for anything else, so Q2_K or a partial offload is the safer real-world choice there. The bigger catch is platform support at launch: Ollama's only tag, muse-glimmer:30b-mlx, runs exclusively through the MLX engine on Apple Silicon, so NVIDIA and AMD users need llama.cpp or vLLM directly against Unsloth's or Meta's own GGUF builds until Ollama ships non-Mac support. And treat every benchmark on this page as Meta's own number until an independent leaderboard reproduces it — that caveat applies to any same-day model launch, not just this one.

Explore

Browse all guides →Browse all models →Browse all GPUs →

Frequently asked questions

What are the VRAM requirements for Muse Glimmer 30B?
Muse Glimmer 30B requires approximately 19.2 GB of VRAM at Q4_K_M quantization, 33.3 GB at Q8, and 62.5 GB at FP16. These numbers assume 8k context window; its hybrid attention stack caches far fewer than all layers, so VRAM grows much slower than linearly with context.
How many parameters does Muse Glimmer 30B have?
Muse Glimmer 30B has 27.8 billion parameters.
Can Muse Glimmer 30B run on a 16 GB GPU?
No. At Q4_K_M, Muse Glimmer 30B needs 19.2 GB of VRAM — more than 16 GB. You will need a 24 GB GPU like the RTX 4090 or RTX 3090.
Can Muse Glimmer 30B run on a 24 GB GPU?
Yes. Muse Glimmer 30B fits in a 24 GB GPU at Q4_K_M, requiring 19.2 GB VRAM. GPUs with 24 GB include the RTX 4090, RTX 3090, and RTX 3090 Ti.
What is the smallest quantization for Muse Glimmer 30B that fits in 24 GB of VRAM?
At NVFP4, Muse Glimmer 30B needs 15.8 GB — the highest-quality quantization that fits in 24 GB of VRAM.
What GPU do I need to run Muse Glimmer 30B locally?
A 24 GB GPU is the minimum. At Q4_K_M, Muse Glimmer 30B needs 19.2 GB VRAM. Good options: RTX 4090 (24 GB), RTX 3090 (24 GB).
Does Muse Glimmer 30B support image input?
Yes, through a separate ~1.8B-parameter ViT-G/14 perception encoder distributed as its own mmproj file rather than merged into the main GGUF — llama.cpp and LM Studio both need that file loaded alongside the weights to use it. Output is text-only; there's no image or audio generation.
Can Muse Glimmer 30B run with Ollama?
Only on Apple Silicon at launch. The single tag published so far, muse-glimmer:30b-mlx, runs through Ollama's MLX engine and needs a Mac; NVIDIA and AMD support was announced as coming within days but wasn't live on release day. Until then, llama.cpp or vLLM against Unsloth's or Meta's own GGUF builds is the cross-platform route.
How does Muse Glimmer 30B compare to Qwen 3.6 27B?
Both are dense, roughly 30B-class, Apache 2.0-licensed local coding models released within a few months of each other, and both use a hybrid attention design to keep the KV cache cheap — Qwen through linear-attention DeltaNet layers, Muse Glimmer through a Gemma-style sliding-window cap. On Meta's own comparison table, Muse Glimmer's SWE-bench Pro (51.2) edges past the 50.2 Meta measured for Qwen 3.6 27B, though that's below Alibaba's own self-reported 53.5 for the same benchmark — a reminder these scores move with whichever harness ran them. Hardware-wise they land in a similar place: both fit comfortably on a single 24 GB card at Q4_K_M.
What is Muse Spark, and is it available too?
Muse Spark is the larger model Meta distilled Muse Glimmer from, but Meta hasn't published Muse Spark's own weights — only Muse Glimmer is openly released. Treat Muse Spark as the teacher model behind this release's training, not a separate download.