Meta's Muse Glimmer 30B Locally on a 16GB RTX 5080

I've been running models locally for a while now, mostly to keep sensitive code off the network and to see what actually fits in a consumer GPU. The RTX 5080 I have on my desk is a 16GB card — plenty for 14B-class models, tight for 30B. When Meta announced Muse Glimmer 30B on August 10, 2026, I wanted to see if it really ran on this hardware without offload. It does, if you're willing to quantize aggressively.

This isn't a benchmark roundup. It's a field report: I pulled the GGUF, ran it through Ollama, and built something with it. The model itself built a Galaga-style clone in an earlier agent session, and I played it while the model was running. That game is now part of the story.

The model

Muse Glimmer 30B is Meta Superintelligence Labs' open-weight agentic coding model. It's not part of the Llama family — it's the open distillation of Muse Spark. The weights are Apache 2.0, 30B parameters including a ~1.8B vision tower, 131,072-token context, and a Gemma-like architecture with SwiGLU and gated attention.

The hardware-friendly part is the KV cache design. 32 query heads, only 2 KV heads, with a Local/Local/Local/Global attention pattern and a 2,048-token sliding window on local layers. That means the KV cache barely grows with context length. For my rig, that matters more than raw parameter count.

Speculative decoding ships with a DFlash block-diffusion drafter that predicts 16-token blocks in one forward pass. I didn't enable it for these runs — I wanted clean baseline numbers.

Hardware and quant

My workstation: RTX 5080 with 16GB VRAM, 32GB DDR5 system RAM, Windows 11. Ollama with GGUF Q3_K_M and Q4_K_M builds.

Q3_K_M weighs ~13–14GB and fits fully in VRAM. Q4_K_M is ~17–18GB, which spills 2–3GB to system RAM over PCIe. The spill hurts.

I measured steady-state decode on a short prompt with no offload tricks:

Q3_K_M: 41.56 tok/s fully in VRAM
Q4_K_M: 10.5 tok/s spilling to system RAM

The Q3 run felt usable as a local coding copilot. The Q4 run felt like waiting. The difference is the PCIe transfer for the 2–3GB that doesn't fit. For interactive work, Q3 wins.

The game the model wrote

A couple of weeks ago I asked Muse Glimmer to build a Galaga-style arcade game in a single HTML file. It did. The repo lives at the playground path I use for local experiments, and the code is straightforward: canvas rendering, a formation of enemies that shifts left/right, dive-bombing enemies that break formation, player movement with ← → and SPACE to shoot.

I ran it while the model was warm. The screenshots below are from that session.

Start screen — Screenshot 2026-09-11 143501.png — start screen showing Press SPACE to start

Full formation — Screenshot 2026-09-11 143304.png — full enemy formation grid with an enemy breaking formation to dive and orange enemy fire falling

Mid-game action — Screenshot 2026-09-11 141703.png — mid-game action at score 1600 with yellow player shots in flight and a partially destroyed formation

Score 500 — Screenshot 2026-09-11 151017.png — score 500 with two separated enemy formations and shots passing between them

The game is simple, but it's also a good proxy for the model's coding behavior. It wrote clean canvas code, handled input without polling issues, implemented a simple formation shift, and added a dive mechanic with audio beeps. No external dependencies, no build step. That matches what I saw in the earlier GLM-5.2 High green-field project: the model writes code that runs the first time, and it does so in a way that feels native to the medium.

Where it fits

On this hardware, Muse Glimmer Q3_K_M is a viable offline coding assistant. It's not a Claude replacement for complex reasoning, but for local, privacy-sensitive work — reviewing a repo, generating a small script, playing with an agent loop — it's good enough and the latency is acceptable.

The 2-KV-head architecture is the real enabler here. A normal 30B model would choke on KV cache at 128K context. Glimmer's sliding window keeps the cache small, which is why I can keep the whole weight in VRAM at Q3 and still have headroom.

I'd still use cloud models for long-context refactoring or multi-file reasoning across a large codebase. For green-field prototyping and personal tooling, local Muse Glimmer is a solid addition to the stack.

Closing

I didn't expect a 30B model to feel comfortable on a 16GB card. It does, if you accept Q3 quantization. The benchmarks back it up — 41.56 tok/s in VRAM, 10.5 tok/s when you spill. The game the model wrote is still on my desktop, and I still play it when I'm testing a new prompt.

If you're building agentic systems and want to talk about local inference tradeoffs, vendor-agnostic model swapping, or how to make a 30B model fit in 16GB — get in touch. I'm happy to share the Ollama config and the exact quant build I used.