TL;DR: Meta is back in open weights. Muse Glimmer 30B (released August 10, 2026, Apache 2.0) is a dense 30B multimodal model built for always-on local agents, and it’s aimed squarely at the 24GB card you may already own: the official K-Quant-17GB tier loads on a used RTX 3090 or RTX 4090 with room for a 130K context. The headline 3.1× DFlash speedup is real — but it was measured on a 32GB RTX 5090, and the drafter’s extra 5.11GB is exactly what a 24GB card doesn’t have spare.

	24GB (RTX 3090/4090)	32GB (RTX 5090)	Apple Silicon (M4 Max+)
Quant tier	K-Quant-17GB / Q4_K_M 17.3GB	K-Quant-Dynamic (32GB target)	MLX via Ollama, 17GB-class
Measured speed	75 tok/s decode, 3,100+ tok/s prefill (4090)	74.9 → 233.4 tok/s with DFlash	M4 Max 23.7 → 37.8 tok/s with DFlash
DFlash drafter (+5.11GB)	Tight — cuts your context budget	Fits with headroom	Supported in Ollama’s MLX engine
Context at this tier	130K measured in 19.3GB total	Full 131K + drafter	RAM-dependent
The catch	Drafter + KV + vision encoder compete for ~6GB	The card costs $4,399+	Base speed is a third of a 4090’s

Honest take: if you own a 24GB card, run the base muse-glimmer:30b and skip the DFlash tag until you’ve watched ollama ps — the 17.3GB model plus the 5.11GB drafter leaves almost nothing for cache on 24GB, and a silent CPU spill will cost you more speed than block-diffusion drafting gains. The model itself is the strongest tool-calling open weight at this size; for raw SWE-bench coding, Qwen3.6-27B still edges it.

Meta hadn’t shipped a consumer-runnable open-weight model since the Llama 4 family landed mostly out of reach of single GPUs. Muse Glimmer changes that posture completely: per Meta’s announcement, it’s a 30B-parameter dense model with a dedicated perception encoder for images, a 131K context window, Apache 2.0 license, and quantization tiers Meta itself published with consumer VRAM targets in mind. Before you pull anything, the VRAM calculator will check your exact card against the numbers below.

This guide covers the general GPU-tier math — NVIDIA by tier, Apple Silicon, and where AMD stands. If you’re wiring it into a coding agent, aicoderscope.com covers the tool-side setup.

What Muse Glimmer actually is

Three facts separate it from the 30B crowd, all from Meta’s model card and blog:

• Dense, not MoE — but distilled. It’s a 30B dense causal model distilled from Muse Spark (Meta’s internal frontier line), tuned specifically for tool use, long-horizon tasks, and failure recovery rather than chat benchmarks. Dense means decode speed follows memory bandwidth — the same math as every dense model we’ve benchmarked.
• Multimodal via a separate perception encoder. Interleaved text and images — screenshots, charts, documents — go through a dedicated encoder that sits in VRAM next to the language model. That’s a real budget line, not a rounding error, and it’s why Meta talks about VRAM “envelopes” rather than file sizes.
• DFlash ships in the box. The DFlash drafter is a 5-layer, 5.11GB block-diffusion companion model that proposes 16-token blocks in a single forward pass; the main model verifies them in parallel. Output is identical to normal decoding — it’s lossless speculative decoding, the same family of technique as the llama.cpp setups we covered in July, but with a drafter that reads the target model’s residual stream instead of being a separate small LLM.

The license is plain Apache 2.0 — no user-count clause like Llama’s community license, no regional exclusions like MiniMax H3’s. Per VentureBeat, this is Meta’s first Apache 2.0 model release, full stop.

The VRAM math, tier by tier

Meta published two official GGUF-class quant tiers on meta-models/Muse-Glimmer-30B-GGUF, and the community filled in the rest on bartowski’s repo:

File	Size	Fits fully on	What you give up
K-Quant-17GB (official)	~17GB	24GB cards	Meta’s target config — nothing at this tier
Q4_K_M (bartowski)	17.3GB	24GB cards	Community equivalent of the official tier
Q5_K_M (bartowski)	20.1GB	24GB, thin cache	Context headroom
Q8_0 (bartowski)	29.6GB	32GB cards	Nothing measurable; overkill for most
K-Quant-Dynamic (official)	32GB target	RTX 5090	0.2% accuracy vs full precision, per Meta
IQ2_XS – Q2_K	~9–11GB	12–16GB cards	Enough quality that we don’t recommend it
Full precision	~64GB target	Nothing consumer	—

24GB is the tier this model was designed for. The most useful independent number so far: a single-RTX 4090 bench ran the quantized model with a 130,000-token context in 19.3GB of VRAM total — no KV-cache quantization required. For comparison, Qwen3.6-27B’s cache alone eats about 2GB per 16K tokens on the 24GB tier. Whatever attention scheme Meta used for the KV cache, it’s unusually frugal, and it’s the quiet reason “always-on agent” isn’t marketing: a full-context agent session fits a used 3090 with 4GB to spare.

16GB and below: this isn’t your model. Q4_K_M at 17.3GB doesn’t fit a 16GB card — Ollama will load what fits and silently split the rest to CPU, which on a dense 30B means single-digit tokens per second. The 2-bit quants (~9–11GB, per museglimmer.wiki) technically fit 12–16GB cards, but 2-bit on a 30B dense model is the quality floor. If you’re on 16GB, Gemma 4 26B-A4B QAT and GPT-OSS 20B remain the tier’s real picks.

32GB: where Meta’s headline numbers were measured. The K-Quant-Dynamic tier lines up with the RTX 5090’s 32GB, and the full model + drafter + encoder + cache all fit at once — that’s the configuration behind the 233 tok/s figure below.

The DFlash catch on 24GB cards

Here’s the arithmetic nobody puts in the launch posts. Meta’s official speedups, measured at batch size 1 with greedy decoding (Apple via ExecuTorch, RTX 5090 via llama.cpp):

Hardware	Without DFlash	With DFlash	Speedup
RTX 5090 (32GB)	74.9 tok/s	233.4 tok/s	3.1×
Apple M5 Max	26.6 tok/s	50.2 tok/s	1.8×
Apple M4 Max	23.7 tok/s	37.8 tok/s	1.5×

Now the 24GB budget: 17.3GB (model) + 5.11GB (drafter) = 22.4GB before the KV cache or the perception encoder load. On a 24GB card with ~23.5GB usable, that leaves roughly 1GB — a few thousand tokens of context, no images. The independent 4090 bench above (75 tok/s decode, 3,100+ tok/s prefill) matches Meta’s 5090 base number almost exactly, which tells you it was run without the drafter resident.

So the practical configs are:

• 24GB card: base model, full 130K context, ~75 tok/s on a 4090. A used RTX 3090’s 936 GB/s memory bandwidth is 93% of a 4090’s 1,008 GB/s, so plan on ~65–70 tok/s there — that’s a bandwidth-ratio estimate, not a measurement; no clean 3090 bench has surfaced yet.
• 32GB card: everything at once, 233 tok/s with DFlash. This is the first model where the RTX 5090’s extra 8GB buys a specific, measurable capability instead of just comfort — a point our 32GB tier guide couldn’t make for any model last week.
• 24GB with DFlash anyway: possible if you cap context around 4K and skip image input. For an agent that fires short tool calls all day, that trade can actually make sense — just make it deliberately.

Running it: the version trap, then the commands

The launch had a real gotcha. Ollama shipped muse-glimmer support in two stages: v0.32.7 (August 10) ran it only through the MLX engine on Apple Silicon — with DFlash and image input working day one — while NVIDIA and AMD users who pulled the model got a failed load. v0.32.8 added NVIDIA, AMD, and the remaining platforms a few days later.

The problem and its fix, concretely:

$ ollama run muse-glimmer:30b
Error: llama runner process has terminated: this model is not supported
by your version of Ollama

$ ollama --version   # anything below 0.32.8 on NVIDIA/AMD is the cause
ollama version is 0.32.7

# fix: upgrade, then re-run
$ curl -fsSL https://ollama.com/install.sh | sh
$ ollama run muse-glimmer:30b
>>> 

The library tags as of August 14: muse-glimmer:30b (the 17GB-class default), muse-glimmer:30b-q4_K_M, muse-glimmer:30b-q4_K_M-dflash (drafter bundled), and muse-glimmer:30b-mlx for Apple Silicon. After any long first prompt, confirm residency:

$ ollama ps
NAME                 ID          SIZE     PROCESSOR    UNTIL
muse-glimmer:30b     a91fc03e    20 GB    100% GPU     4 minutes from now

Anything other than 100% GPU in the PROCESSOR column means you’re in the silent-spill regime — on 24GB that almost always means you pulled the -dflash tag; switch to the base tag before touching anything else. The usual spillover fixes apply after that.

Outside Ollama, the launch-day ecosystem is unusually complete: ExecuTorch published verified PTE artifacts for NVIDIA CUDA and Apple Metal — text-only and text+image, with and without DFlash — plus llama.cpp GGUFs, MLX, and vLLM/SGLang for serving. LM Studio lists it too. Meta clearly pre-briefed every runtime the way Google does for Gemma launches.

Benchmarks: where it wins, where Qwen still does

Meta’s positioning is “agent foundation,” and the published numbers back that framing — with honest losses elsewhere. Against Qwen3.6-27B, the model it will be compared to on every 24GB card (compiled from Meta’s card via Data Science in Your Pocket and AIReiter’s coding-bench roundup):

Benchmark	Muse Glimmer 30B	Qwen3.6-27B	Winner
SWE-bench Verified	76.0	77.2	Qwen, narrowly
SWE-bench Pro (less scaffolding)	51.2	50.2	Glimmer
Terminal-Bench 2.1	51.7	60.7	Qwen, clearly
SciCode	43.6	39.8	Glimmer
MCP-Atlas (tool calling)	ahead	—	Glimmer
DeepSearch QA	ahead	—	Glimmer
OSWorld-Verified, SkillsBench	—	ahead	Qwen

Read the pattern, not the rows: Qwen3.6-27B is still the better coding model — it wins the benchmarks where a harness feeds it well-scoped tasks. Glimmer wins where the model has to run the show itself — tool schemas over long workflows, search-and-synthesize, recovering from its own failures. That’s consistent with what Meta optimized for, and it means the right question isn’t “which is smarter” but “who’s driving” — if the model is the agent, Glimmer; if your IDE is, Qwen3.6-27B. And if raw throughput for agent loops is the priority, Qwen3.6-35B-A3B’s 107 tok/s MoE is still the speed king of the 24GB tier — Glimmer’s answer to it is DFlash, which needs the 32GB card.

One more comparison the launch posts skip: multimodality. Glimmer’s perception encoder gives a 24GB card a screenshot-reading agent in one model — the alternative at this tier has been bolting a separate vision model alongside your LLM and swapping.

Which GPU to buy for it (August 2026 prices)

Nothing about this launch changes the buying math — it just gives the 24GB tier its best agent model. Current prices: used RTX 3090 averages $1,248 ($1,202–$1,296 fair range, 374 listings), used RTX 4090 sits around $2,268, and the RTX 5090 starts at $4,399 new, with used cards within 14% of new.

• Already own 24GB: you’re done. This model was built for your card.
• Buying for Glimmer specifically: the used 3090 remains the entry ticket — ~$1,248 for an estimated ~65–70 tok/s is the value play, same as it’s been all year.
• Tempted by the 5090 for the 3.1×: $4,399+ to go from 75 to 233 tok/s is a real capability jump for agent workloads, but it’s also 3.5 used 3090s. Rent one first — a cloud 32GB+ instance on RunPod will tell you in an afternoon whether your agent loop actually feels different at 233 tok/s.
• Apple Silicon: an M4 Max at 37.8 tok/s with DFlash is genuinely usable, and Ollama’s MLX engine had day-one support. Unified memory sidesteps the 24GB drafter squeeze entirely.
• AMD: v0.32.8 lists AMD support, but no ROCm benchmarks have surfaced yet — if you’re on an RX 7900 XTX, you’re in early-adopter territory this week. AMD also published its own Ryzen AI Max hybrid-inference path for this model, which we’ll cover separately.

FAQ

Does DFlash change the model’s output? No — it’s lossless speculative decoding. The drafter proposes 16-token blocks, the main model verifies every token, and rejected tokens are recomputed. Same output, fewer sequential passes. The DFlash paper has the acceptance math.

Can I run it on a 16GB card? Not usefully. The 17.3GB Q4_K_M spills, and the 2-bit quants that fit trade away too much quality on a dense 30B. The 16GB tier’s existing picks are better models at that budget.

Why is the 4090 “only” 75 tok/s when Qwen3.6-35B-A3B does 107 on a 3090? Dense vs MoE. Glimmer reads all 30B parameters per token; the Qwen MoE reads ~3B active. Glimmer’s counter is DFlash — but that needs the VRAM to hold the drafter, which is the whole 24GB-vs-32GB story above.

Is it actually multimodal in Ollama? Yes — image input shipped in the MLX engine at launch and in v0.32.8 on other platforms. Budget VRAM for the perception encoder on top of the language model when you use it.

Muse Glimmer or Qwen3.6-27B on my 24GB card? Both are 17GB-class files; disk is cheap, so pull both. Default to Qwen for editor-driven coding, Glimmer for anything where the model runs multi-step workflows — tool calls, browsing, screenshot handling. Our 24GB tier guide covers the rest of the shelf.

Recommended Gear

• RTX 3090 used — $1,248 average; the cheapest card that runs the official 17GB tier at full context
• RTX 4090 used — 75 tok/s measured, 3,100+ tok/s prefill for long agent prompts
• RTX 5090 — the only consumer card that runs model + DFlash + full context at once (233 tok/s)
• Mac Studio M4 Max — the no-drafter-squeeze path; 37.8 tok/s with DFlash via Ollama MLX

Sources

• Introducing Muse Glimmer: An Open Agentic Model That Runs on Your Device — Meta AI Research
• Meta returns to open source with Muse Glimmer, an Apache 2.0 licensed 30B model — VentureBeat
• Muse Glimmer from Meta Superintelligence Labs is now available — Ollama Blog
• Ollama v0.32.8 release notes (NVIDIA/AMD muse-glimmer support) — GitHub
• Fast, On-Device Agentic AI with Muse Glimmer on ExecuTorch — PyTorch Blog
• Muse-Glimmer-30B-GGUF official quant tiers — meta-models on Hugging Face
• Muse-Glimmer-30B-GGUF community quants (Q4_K_M 17.3GB) — bartowski on Hugging Face
• Single RTX 4090 bench: 130K context in 19.3GB, 3,100+ tok/s prefill, 75 tok/s decode — @analogalok
• DFlash: Block Diffusion for Flash Speculative Decoding — arXiv
• Muse Glimmer 30B vs Qwen 3.6 27B benchmark table — Data Science in Your Pocket
• Muse Glimmer vs Qwen 3.6 27B: Coding Benchmarks Compared — AIReiter
• Muse Glimmer 30B VRAM, GGUF & Local Setup — museglimmer.wiki
• RTX 3090 Used GPU Price & Fair Asking Range ($1,202–$1,296, avg $1,248) — ResalePrices
• RTX 4090 Price Tracker US, Aug 2026 (~$2,268 used) — Best Value GPU
• NVIDIA GPU Price Report, August 2026 (RTX 5090 $4,399+ new) — BuySellRam
• Meta’s new Glimmer AI model offers a hint at Zuckerberg’s personal intelligence vision — TechCrunch

Last updated August 14, 2026. Prices and specs change; verify current rates before purchasing. Tokens/sec figures vary with runtime, quantization, context length, and tuning. The RTX 3090 speed is a bandwidth-ratio estimate, not a measured benchmark; Meta’s DFlash speedups were measured at batch size 1 with greedy decoding.