Model reference · open weights

Muse-Glimmer-ExecuTorch-PTE

Not for GPU servers LLMs meta-models Vision + text 1 build Open weights 15k dl/mo

Muse-Glimmer-ExecuTorch-PTE is an open-weight language model from meta-models. Built for phones (ExecuTorch). It does not run on a GPU server.

  • Muse-Glimmer-ExecuTorch-PTE is a 30-billion-parameter causal language model developed by Meta Superintelligence Lab for autonomous agentic tasks on consumer hardware.
  • It supports image-text-to-text inputs with a 131,072-token context length and is distributed under the Apache 2.0 license.
  • The repository provides pre-exported ExecuTorch artifacts for NVIDIA CUDA and Apple Silicon backends, available in text-only or multimodal variants with optional speculative decoding.

Summary of the meta-models/Muse-Glimmer-30B-ExecuTorch-PTE model card, 2026-10-01

What it is

Released bymeta-models
Released2026-08-10
VRAM50 MB for the weights

What it runs on

Memory and cards for Muse-Glimmer-30B-ExecuTorch-PTE (BF16)

50 MBweights, file size
762 MBruntime overhead, at least

How much memory each request adds isn't estimated yet for this architecture. The weights need at least the cards below, plus room for the context.

CardWeights alone
RTX 3060 12 GBfits
RTX 4060 Ti 16 GBfits
RTX 3090 24 GBfits
RTX 4090 24 GBfits
RTX 5090 32 GBfits
L40S 48 GBfits
A100 80 GBfits
H100 80 GBfits
RTX PRO 6000 Blackwell 96 GBfits
DGX Spark (GB10) 128 GB unifiedfits
H200 141 GBfits
B200 180 GBfits

From the model card

What meta-models says about Muse-Glimmer-ExecuTorch-PTE

Read the model card

Authors: Meta Superintelligence Lab Model Release Date: August 2026 License: Apache 2.0

[!NOTE] A PTE is the serialized artifact ExecuTorch produces for a PyTorch model, lowered and optimized for a specific target backend. This repo contains pre-exported PTEs for NVIDIA CUDA (sm80+ptx) and Apple Silicon (metal), for text-only and text+image, with and without DFlash speculative decoding. Everything you need to download and serve one is on this page. For export from source, custom quantization recipes, and runtime internals, see Muse Glimmer at ExecuTorch.

Muse Glimmer is a 30-billion-parameter causal language model with a dedicated perception encoder, distilled from Muse Spark and purpose-built for autonomous agentic tasks on consumer hardware. The model integrates multi-step reasoning, reliable tool use, multimodal understanding, and failure recovery into a single model that runs locally without requiring cloud infrastructure or network access.

Why an export, rather than a per-backend port. Local runtimes usually reimplement a model by hand for each target they support. That holds up for a plain text transformer; it does not hold up for a novel architecture with multimodal input and block-diffusion speculative decoding, where every backend would need its own rewrite of all three. ExecuTorch inverts that: the model and its decoding strategy are written once in PyTorch, and torch.export lowers the whole graph ahead of time — Triton on CUDA, MLX-native and custom Metal on Apple Silicon. The files in this repo are the output of that export. The PyTorch team's announcement makes the full argument.


⚠️ Read this before you download

This repo is 372 GB in total. A bare hf download meta-models/Muse-Glimmer-30B-ExecuTorch-PTE will try to pull all 16 variants. Always use --include to fetch exactly one variant (17.9–31.5 GB) plus the shared root files. The commands below do this.

On CUDA, the .pte is not the model. For every sm80+ptx variant the weights live in the .ptd (19–31 GB) and the .pte is only 16–35 MB. Both files are required. If you grabbed a 25 MB .pte and nothing works, this is why.


What's in this repo

16 variant directories, named by a fixed scheme:

muse-glimmer--128K---
FieldValuesMeaning
``k-quant-17G | k-quant-dynamic~4-bit K-quant. 17G targets a 24 GB envelope; dynamic targets 32 GB and is slightly more accurate.
128Kfixed131,072-token context. Same for all variants.
``text | text-imagetext-image includes the perception encoder.
``solo | dflashdflash bundles the speculative-decoding drafter.
``metal | sm80+ptxmetal = Apple Silicon (MLX). sm80+ptx = NVIDIA CUDA, SM80 and newer.

What each directory contains

Every directory follows the same three rules — there are no exceptions:

  1. Always: .pte
  2. If and only if sm80+ptx: .ptd — the CUDA delegate blob holding the weights
  3. If and only if text-image: pos_embed.bin — precomputed image position embeddings

A dflash directory is not an exception to rule 1. Target and drafter are exported together into that single .pte and share their token embeddings and output head, so the drafter costs far less than a second model would.

The artifacts are named after their own directory.

The artifacts are named after their own directory. They are not model.pte / aoti_cuda_blob.ptd — those are the filenames a local export_solo run writes, and they do not exist anywhere in this repo. Copy-pasting a quickstart that references them will fail. Use the $VARIANT pattern below and you cannot get this wrong.

Shared files at the repo root

tokenizer.json, tokenizer_config.json, chat_template.jinja, LICENSE, USAGE_POLICY.md. You need the three tokenizer/template files alongside whichever variant you pick — the server's --hf-tokenizer loads that directory to render prompts and tool definitions.

Download sizes (per directory, .pte + .ptd + pos_embed.bin)

QuantModalityDecodingmetalsm80+ptx
k-quant-17Gtextsolo17.9 GB19.8 GB
k-quant-17Gtextdflash19.6 GB27.2 GB
k-quant-17Gtext-imagesolo19.4 GB21.2 GB
k-quant-17Gtext-imagedflash21.1 GB28.6 GB
k-quant-dynamictextsolo20.7 GB22.6 GB
k-quant-dynamictextdflash22.4 GB30.0 GB
k-quant-dynamictext-imagesolo22.2 GB24.0 GB
k-quant-dynamictext-imagedflash23.8 GB31.5 GB

Pick a variant

  1. Backend — your hardware decides. Apple Silicon → metal. NVIDIA SM80+ → sm80+ptx. There is no CPU variant.
  2. Quant — k-quant-17G for 24 GB of VRAM/unified memory, k-quant-dynamic for 32 GB. dynamic is measurably closer to full precision (see Fitting the Model on Your Device).
  3. Modality — take text-image only if you actually send images; it costs memory and download size.
  4. Decoding — dflash is meaningfully faster on capable GPUs but adds the drafter's memory and download cost. solo is the smaller, simpler starting point.

If you're unsure, start with muse-glimmer-k-quant-17G-128K-text-solo-.


Download one variant

Set the variant once; every command below derives its paths from it.

REPO=meta-models/Muse-Glimmer-30B-ExecuTorch-PTE
VARIANT=muse-glimmer-k-quant-17G-128K-text-solo-sm80+ptx   # ← change this
LOCAL_DIR=./muse-glimmer-pte

hf download "$REPO" \
  --include "$VARIANT/*" \
  --include "tokenizer.json" \
  --include "tokenizer_config.json" 

Quoted from the model card on Hugging Face. The full card is behind the Hugging Face link above.

How it works

How language models work

Your prompttext / messagesTransformerattention over tokensNext-token loopgenerate + streamResponsetext · tool callsA language model reads your tokens and predicts the next one, again and again, streaming the reply back.

Running it

Where it runs

Built for phones (ExecuTorch). It does not run on a GPU server.

© 2026 AxForge · EU-hosted AI infrastructure Pricing Docs Trust Privacy Terms