> ## Content Index > Fetch the complete content index at: https://computefit.dev/llms.txt > Use this file to discover other available public pages before exploring further. # Muse Glimmer on Your GPU: What the Official Tags and File Sizes Actually Require - URL: https://computefit.dev/muse-glimmer-30b-tags-file-sizes-fit/ - Published: 2026-08-21T02:34:51.000Z - Updated: 2026-08-22T17:09:24.000Z - Description: Meta Superintelligence Labs' new open model for local deployment lands with a real footprint. We map Muse Glimmer 30B's official quantization ladder against your card tier and Ollama tags, using exact file sizes. - Author: Alex Vale - Tags: Local AI, 24GB Lab, Muse, Local LLM, AI Models, Open Source AI, Ollama ## 1\. The short answer Muse Glimmer is Meta Superintelligence Labs’s new open model for local deployment, published August 2026 under Apache 2.0 \[official model card\]. If your question is *“which Muse Glimmer tag can I actually run?”*, here are the direct answers: - **A 24 GB card fits at least one official 4-bit quant of the weights.** Meta publishes exactly two 4-bit-class builds against consumer tiers — `K-Quant-17GB` aimed squarely at the 24 VRAM tier, and `K-Quant-Dynamic` “XL” as it appears in its GGUF filename — targeting the 32 GB tier \[vendor model card\]. The 17 GB build's weights are 16.76 GB (official file size: 16,756,683,904 bytes) \[derived — exact byte count from Meta's official Hugging Face repository\]; Ollama's listing shows the Q4\_K\_M tag as an 18 GB download once files and packaging are counted \[Ollama official listing\]. - **The image capability and the speed-up drafter ship as extra files with different routes per surface.** In Meta’s official raw GGUF repo, each is a separate file: a vision projection (mmproj, 1.40 GB) that enables image input alongside text, and an optional DFlash draft model (1.63 GB) for speculative decoding \[derived — exact byte sums from Meta’s official repo files\]. Ollama’s default `:latest` / `:30b-q4_k_m` row is a Text + Image-capable tag whose single ≈18 GB download bundles the projector; DFlash arrives only with its separate `-dflash` rows \[Ollama official listing\]. What VRAM those companions actually occupy at runtime was not measured for this article. - **The context window is long and the same across every quant.** The official model card puts it at 131,072+ tokens; every Ollama tag row for this model shows a 131,072-token window. Running near that upper end on a full-spec card means KV cache — separate from the quant's disk size — grows to fit your prompts \[vendor-stated numbers; per-model memory behavior is inference as usual\]. When memory gets tight, long contexts are typically the first thing you have to shed. **If you keep only three things:** 1. Pick your tag by card tier and budget (section 3) — the default `muse-glimmer:latest` row in Ollama points to an 18 GB quant build, not something near full precision. 2. Vision & speed-up have separate routes on each surface: bundled by default inside Ollama’s 18 GB Text + Image tags, a standalone companion file in Meta’s raw GGUF repo; DFlash is the optional add-on either way (section 3). 3. The full-precision weights (59 GB by exact file count from Meta's repo; Ollama lists the BF16 tag at 57–59 GB) are a different hardware class entirely — high-capacity desktop or workstation GPUs / unified-memory machines, not your typical laptop GPU \[official file sizes + Ollama listing\]. *Scope:* this article walks through the Muse Glimmer-30B quantization ladder (what each file actually is and what it costs in VRAM), where it lands on typical consumer hardware, and who should consider switching from a model they already run — e.g., many of our readers currently driving Qwen 3.8 locally. ## 2\. What Muse Glimmer actually ships as The model card defines the thing you're downloading; it's easy to get lost when "30B" and several quantization names appear across marketing copy, Ollama tags, and Meta's own repos. Everything below comes from the official Hugging Face model card and file repositories — nothing in here is Local Frontier telemetry. | Item | Official position \[source: model card / repo\] | | ----------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | Total parameters | ≈29.6B (the "30B" in the name is a round-ness label) | | Vision encoder | Dedicated frozen ViT-G/14 at ≈1.8B params — *included* inside that 29.6B figure, not added on top \[model card table\] | | Architecture class | Dense causal transformer (not MoE) | | LICENSE / license | Apache–2.0\. No Llama-style MAU threshold appears in the Apache-2.0 license; users should also review Meta’s separate Muse Glimmer Usage Policy (a distinct USAGE\_POLICY.md ships alongside the model files in the official repo \[verified present, 5,230 bytes via official repo tree — not fully summarized here\]). | | Max context | 131,072+ tokens (model card); every Ollama tag row reconfirms 131,072 \[Ollama library listing\] | | Vision input budget per image | Up to 4,096 visual tokens per image; video is handled as individual frames (not a native video modality) | | Languages | Trained on more than 100 languages | | Where it was trained to shine | Agentic scaffolding: task completion across turns, tool-call schema fidelity, and explicit failure-recovery behavior (a model that retries when a function call errors rather than stalling) | ### The companion files are not optional "extras" — they're how features turn on/off A single large `.gguf` with two small companions in the same official GGUF repo: - **Main weights**: this is what any tag like `muse-glimmer:30b-q4_k_m` is fundamentally pointing at. The card reports accuracy against full precision across its 15-benchmark accuracy panel as a “minimum to no degradation” on agentic tasks for both 4-bit builds it ships (K-Quant-Dynamic reported at \~0.2% average drop, K-Quant-17GB at \~1.0%, its own table wording) \[vendor-stated figures\]. - **Vocabulary / tokenizer basics you may see referenced**: 202,048 total vocabulary with a ≈200K-token BPE core plus special tokens; the model uses local-attention sliding windows at 2,048 tokens repeating into global attention layers (GQA at 16:1 Q:KV ratio) \[vendor-stated architecture table\]. - **mmproj file (≈1.4 GB)**: the projection bridge that lets vision pass through into the model's context (up to 4,096 visual tokens per image \[vendor-stated\]). Confirmed routes: a standalone companion file in Meta’s official raw GGUF repo, and — on Ollama’s Text + Image tags (`:latest` / `:30b-q4_k_m`) — bundled inside that single download row \[Ollama official listing\]. How much VRAM it actually occupies at runtime was not measured for this article. - **DFlash drafter file (≈1.63 GB)**: a small speculative-decoding companion trained to propose blocks of tokens the model then verifies in one pass — this is how Meta's reported 5090 figure (233 tok/s with DFlash vs a 74.9 baseline) exists \[vendor-measured table\]. Ollama lists it as its own download suffix (`-dflash` tags). ## 3\. The quant ladder: what each tag actually requires The left column is an **Ollama official library listing row at time of writing**; the right frames it in your hardware. Ollama rows and our byte sums from Meta's repos differ slightly — that’s packaging vs raw weight bytes, both legitimate views of the same artifact. | Ollama tag (official listing) | Listed download size | Practical fit\* | | --------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | muse-glimmer:latest, :30b, :30b-q4\_k\_m (same digest, one download row in the listing) | ≈18 GB, one download figure shown per listed tag (“rows” here = that per-tag size column) | The default pull lands on Q4\_K\_M-class weights. Meta’s model card places its K-Quant-17GB build against the 24 GB VRAM target tier \[vendor-stated mapping\], so this is the row a 24-card reader should start from — treat listing sizes as download bytes, not VRAM (see below) | | :30b-q4\_k\_m-dflash | ≈20 GB | Same 24–32 GB tier plus the DFlash drafter (speculative-decoding speed-up head, not a separate model) | | :30b-nvfp4 / \-dflash | ≈17–21 GB across variants | A distinct Ollama-listing surface in 4-bit class — it is not one of Meta’s two official raw-GGUF 4-bit builds (which are K-Quant-17GB-Q4\_K\_M and K-Quant-Dynamic-Q4\_K\_XL). Scope: these rows sit in MLX-family architecture context per the listing — verify which hardware actually ships them before assuming parity with Q4\_K\_M. | | :30b-q8\_0 / \-dflash | ≈31–33 GB | Roughly 48+ GB of GPU memory territory in practice (inference from file size + standard runtime headroom for KV/compute) | | :30b-mxfp8 / \-dflash | ≈33–35 GB listed | In the Q8\_0-class tier — \~48+ GB territory (inference from listing size) | | :30b-bf16 / \-dflash | ≈57–59 GB listed (Meta’s own BF16 safetensors is 59.58 GB by exact byte sum) | High-capacity desktop/workstation or unified-memory machines well above that figure | | :30b-mlx family (Apple MLX rows, separate architecture context in Ollama’s listing) | ≈21 GB quantized entry up to ≈65–80 GB in the BF16 + drafter rows per listing at time of writing | Apple Silicon: lower numbers sit comfortably on Macs with unified memory well above them (unified-memory sizing logic, inference) | \* “Fits” describes the downloaded weight bytes per row. Runtime VRAM after KV cache and compute buffers is still required on top of that — a 24 GB card hosting an 18–20 GB model isn’t idle headroom. ### Sanity-checking the right tag for your hardware (no benchmark required) 1. Start with `:30b-q4_k_m` — it aligns with Ollama’s own default row and Meta’s 24 GB target \[both vendor sources\]. 2. If your card is under \~16–18 GB VRAM in the GPU-class side (leave 3–4 GB minimum headroom you can reason about), expect context trimming pressure — long multi-turn state is what hits OOM/swap first (general runtime behavior, *not* a specific measured figure for Muse Glimmer). 3. Add the DFlash drafter (`-dflash` tag) only if you want lower perceived latency: its companion adds roughly 1.63 GB of file/download footprint in the official repository, and its exact runtime memory overhead was not measured here (see section 5 for Meta’s reported numbers). 4. If nothing fits comfortably, look to the Apple MLX row or wait for a smaller sibling quant if one ships — don’t start from Q8\_0 / BF16 on hardware sized for 4-bit. ## 4\. Where it actually lands on real hardware you might own This is the table we'd hand to a friend, with Meta's reported tier mapping in the middle column. | Your card / machine | Meta’s stated target for each 4-bit build \[vendor model card\] | What that means at the tag level | | ----------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | 24 GB NVIDIA or AMD GPU (laptop or desktop) | Meta’s model card targets the K-Quant-17GB build at exactly this 24 GB VRAM tier — and states its \~4-bit compression leaves headroom for KV cache, the perception encoder, and the speculative-decoding drafter running simultaneously within a 24 or 32 GB envelope \[vendor-stated\] | muse-glimmer:30b-q4\_k\_m is the default row here (Ollama lists it at an ≈18 GB download figure). Note the card’s “under 20 GB” number scopes to the language model weights alone — encoder and drafter sit in their own slice of that envelope \[vendor-stated scope\]. | | 32 GB GPU (e.g. RTX-class or Radeon reference-tier desktop cards) | The build Meta’s table explicitly maps to this tier is K-Quant-Dynamic-Q4\_K\_XL (the “XL” in its official GGUF filename), 19,653,960,832 bytes by exact repo file size \[derived\], with a 0.2% average accuracy degradation across its 15-benchmark panel versus full precision \[vendor-stated metric\] | Start from the K-Quant-17GB / Q4\_K\_M row and gain more KV headroom — or step up to the XL build if top-end precision accuracy matters, whichever Ollama tag delivers it. The higher :30b-q8\_0 / :30b-mxfp8 rows sit 31–35 GB in listed bytes, at or above this card’s ceiling — on a 32 GB card that leaves room for KV/compute only in tight cases, so runtime overhead and offloading may be needed (inference from file sizes; not tested). | | 16 GB consumer GPU | The model card’s stated tiers start at 24 GB \[vendor table\] — nothing below it has a declared target mapping. | Pulling the raw main-weight file alone — an exact byte sum of 16,756,683,904 (\~16.8 GB decimal) for this quant family's "17GB" build \[derived from Meta’s official GGUF repo\] — plus encoder/drafter companion files leaves little comfortable budget on a 16 GB card, even before KV cache is accounted for; expect a heavily CPU-offloaded or reduced-context run if it loads usefully at all \[inference from exact file sizes + standard runtime headroom reasoning\]. | | Apple Silicon Mac with unified memory (current-gen, upper end) | The MLX row family exists in Ollama’s official listing as a dedicated path for this machine class; the card-side tiering is presented cross-platform against 24/32 GB framing \[Ollama listing + vendor table wording\] | Pick quantized-MLX-class builds that sit comfortably below your unified total, keeping plenty of headroom for OS and sidecar tools; BF16-class MLX rows (60–65 GB listed at fetch time) assume machines sized toward 96+ GB unified — a general memory-sizing heuristic here, not measured on any specific Mac \[inference\]. | | M3/M4-class Macs in the \~16–32 GB unified-memory range | (carries over the inference logic above) | If a quantized-MLX build plus working headroom fits inside your unified budget without aggressive swapping, it can work for moderate sessions — treat very long history as the first thing to trim if anything starts thrashing. (General unified-memory sizing logic; nothing in this row is local measurement.) | ### The nuance the tag page’s “18 GB” hides from you An 18 GB download does *not* mean an 18/24 GB VRAM slot is all your model needs at runtime. 1. KV cache and compute buffers are separate allocations that grow with context length (long multi-turn conversations inflate them — general inference runtimes behavior, not a specific number). 2. If you enable the mmproj side (text+image interleaved), expect that side to reserve its own slice of loaded memory per image it processes through a run. This article confirms only that the 1.40 GB file must be present for image input (standalone in Meta’s raw GGUF repo, bundled into Ollama’s ≈18 GB Text + Image download); how much VRAM it actually occupies at runtime was not measured here \[route facts: derived from official repo tree + Ollama listing\]. 3. DFlash speculative verification adds a second small model head whose state must be kept live alongside your main weights while it is loaded; its exact runtime VRAM overhead was not measured here \[the companion file is ≈1.63 GB in Meta’s official repository, and the Ollama -dflash variant carries an extra download footprint\], so near the top end of your VRAM headroom it is a factor to verify on your own machine before relying on it. The bottom line: treat Ollama’s row size as *“download bytes.”* Size your prompt history and concurrency accordingly — a 24 GB card hosting an 18 GB model still needs to know what its own KV budget is going to be before asking it to hold a two-hour working session. ## 5\. The speed-up headline, in context “3.1×” is the number that keeps circulating for Muse Glimmer — and it does come from Meta's model card, which measures DFlash speculative decoding on three machines: | Device \[vendor-reported\] | Baseline (no speculation), tok/s | Average with DFlash, tok/s | Speedup per the card | | ---------------------------------------------- | -------------------------------- | -------------------------- | ------------------------------------------------------------------------------------------------------- | | NVIDIA RTX 5090 | 74.9 | 233.4 | 3.1× | | Apple M4 Max (unified memory) | 23.7 | 37.8 | 1.5× per the card — running that division ourselves gives ≈1.6, a minor rounding difference on our side | | Apple M5 Max (newer unified-memory generation) | 26.6 | 50.2 | 1.8× per the card (≈1.9 recomputed, same story) | Source: model card. A detail worth knowing before you compare these to anything else: the card's own footnote says it measured Apple runs with ExecuTorch and the RTX run with llama.cpp (batch size 1, greedy decoding) — so this table is cross-runtime in nature even within Meta's own numbers \[vendor-reported\]. These are not Local Frontier telemetry: your GPU is probably none of these three chips, so read them as what DFlash bought on *those* setups (inference about elsewhere). ### What you can actually control from your side - The tag decides whether the drafter ships at all: pull a non-`-dflash` row for base weights only, or the `-dflash` row to bundle it — Ollama’s own listing shows that as a separate download size (the 18 GB vs ≈20–21 GB rows in this family) \[Ollama listing, derived delta\]. - Whether verification is active by default inside a plain tag: the sources we checked do not state this. Check what your loaded session reports rather than assuming \[scope noted so this isn't read as vendor-confirmed\]. - Budget its download side concretely: about 1.63 GB of file footprint for the drafter in Meta's repository (exactly ≈1.63 GB by byte sum); its exact runtime memory overhead was not measured here, so treat any load-time cost as unconfirmed — against a speed benefit that scales with your silicon — closer to 3× on flagship-class hardware than further away (inference on where you sit in that range). ## 6\. Should you switch to it? A practical read-out We’ve covered three Qwen 3.8-27B runs in depth on this site ([the upgrade decision guide](https://computefit.dev/qwen3-8-27b-upgrade-guide/), [which quant fits your GPU](https://computefit.dev/qwen3-8-27b-which-quant-fits-your-gpu/)). If that’s the model you currently run, here is what actually changes if you swap in Muse Glimmer — framed on things each vendor states explicitly. - **The default you get at a 24 GB pull is the same tier shape as before:** a single \~18–20 GB 4-bit build with long-ish context — the difference shifts to what Meta emphasizes in training: agent-task completion, schema-faithful tool calls, and an explicit failure-recovery loop (retry on error rather than stall). \[vendor model card\] - **Context framing:** 131,072 tokens per the official card / listing, versus 262k-class windows you may now be used to — check this against what your actual multi-turn sessions need (we’ll show how the Qwen comparison numbers line up in a future head-to-head when enough read-backs exist). - **Vision scope is narrower by design:** images work natively at up to \~4k visual tokens per image, but video is processed frame-by-frame — not first-class continuous-ingest. If your workload leans on native / continuous video, verify this meets it before swapping (our [Qwen 3.8-27B vision cost](https://computefit.dev/qwen3-8-27b-vision-local-costs/) piece is the concrete baseline for that comparison). - **License posture:** Apache 2.0 per the released materials we checked on this date — no monthly-active-user cap or similar condition appears in them (scope of statement: the official artifacts fetched). That frees you from usage-restriction wording you may have had to keep track of with Llama-style models elsewhere \[vendor license file\]. - **Agent scaffolding as the design goal:** Ollama’s own release-note lead for this model is agent-run instructions (Claude Code, Codex, Pi, or a personal-assistant scaffold via `ollama launch ... --model muse-glimmer`), not just plain chat — if you already run an agentic loop that swaps in a local backend, the bar for trying this is basically "does it load on your card" (section 3). ### When it’s a “no, stay with what you have”‑ If your current setup is 16 GB or smaller GPU-class, if video (not just still images) is core to your workload, or if the multi-turn context ceiling of your model already clears your actual session lengths — then there isn’t a strong pull here. The file size alone at ≈18–20 GB on disk makes it a hard fit below that card class without aggressive offloading. ### If you do want to try it ``` # start small, single 4-bit build aligned to your tier ollama pull muse-glimmer:30b-q4_k_m ollama run muse-glimmer # plain text interaction loop first # add speculative speed-up (optional; separate download cost) ollama pull muse-glimmer:30b-q4_k_m-dflash ``` We’d start with `num_ctx` modest (say a few thousand default tokens you know work well on your setup before this swap); grow it only if your session histories genuinely need the headroom — that’s where the KV-cache side of things gets real, and it’s still worth re-checking on your machine once you load. *Sources we pulled this from:* Meta’s official Hugging Face model card + the two `meta-models/Muse-Glimmer-30B` repos (BF16 & GGUF file listings, byte-level), Ollama’s own GitHub release notes for versions 0.32.7–0.32.15 at fetch time, and the `muse-glimmer` tag page on ollama.com for current per-tag download sizes.