---
title: "Can your Mac run Muse Glimmer? We tested it"
description: "Yes, Muse Glimmer runs on a MacBook. We tested Meta's new 30B open model on base M3 and M4 machines: it fits in 24GB of RAM but generates at 4.3 tokens per second. The numbers, why it's slow, and what hardware makes it usable."
updated: 2026-08-11
canonical: https://holaclaw.ai/blog/muse-glimmer-on-mac
---

Meta Superintelligence Labs released [Muse Glimmer](https://huggingface.co/meta-models/Muse-Glimmer-30B-GGUF) on August 10, 2026. It's a 30B multimodal model with a 128K+ context window, released under Apache 2.0, and built for always-on local agent workloads.

The release is not a one-off. In [The future is for everyone](https://www.meta.com/thefutureisforeveryone/), Mark Zuckerberg lays out Meta's position that **you should be able to run and own your personal AI intelligence**. Muse Glimmer is the first model they've shipped against that idea: open weights, a permissive license, and a size aimed at consumer hardware rather than a datacenter.

At HolaClaw, **we believe local models and AI assistants will be part of the future**. For you and your business. That's why we always love to test and integrate new models that you can run on your own hardware. But, can you run Muse Glimmer on your Mac? What performance can you expect, and what's the minimum hardware you need so it's usable?

## What we tested on

We tested Muse Glimmer on two MacBooks, both the base consumer tier:

- **MacBook Air M3, 24 GB** of unified memory
- **MacBook Air M4, 32 GB** of unified memory

Both are MacBook Airs, which means both are **fanless**. That detail matters more than it sounds; we'll come back to it.

We ran the model with [llama.cpp](https://llama.app), the same inference engine HolaClaw uses under the hood, using the official [Muse-Glimmer-30B-GGUF](https://huggingface.co/meta-models/Muse-Glimmer-30B-GGUF/tree/main) build in the `kquant-17gb` variant (about 17 GB on disk). These are the `llama-server` flags we used:

```
llama-server -m Muse-Glimmer-30B-kquant-17gb.gguf \
  -ngl 99 -c 8192 \
  --flash-attn on -b 2048 -ub 512 \
  --mlock --keep 512 \
  --cache-type-k q4_0 --cache-type-v q4_0 \
  --jinja --reasoning off
```

That's the 24 GB machine's configuration. On the 32 GB machine we raised the context to 64K (`-c 65536`). The tests are text-only, without the vision projector (`--mmproj`), leaving that RAM for the model and its context. Worth noting: the KV cache is quantized to `q4_0`, which is part of why contexts this large fit at all.

We plan to test the DFlash variant and the MLX format in a follow-up.

## What we found

**Muse Glimmer runs on a base MacBook Air**. Daily usage is a different story.

### Running it

The model fits in 24 GB of RAM at an 8K context and generates correct output. That's a 30B multimodal model working on a fanless consumer laptop.

Memory is what decides how far you can push it: 24 GB fits the model but not large contexts (64K did not fit on that machine), so 32 GB is our practical minimum.

### Using it every day

**Generation runs at about 4.3 tokens per second**, pretty slow.

The bigger number is the wait before the answer starts: on a prompt of about 4,000 tokens, the first word appeared after roughly 157 seconds. For casual chat, that's below comfortable reading speed. For interactive work like coding, it's not enough.

Better hardware helps here, because generation speed follows memory bandwidth, and the Pro and Max chips have several times more of it than the base machines we tested. More on that at the end of the post.

### Can you use it with OpenClaw on your Mac?

**Yes, but only on high-end Macs**. An OpenClaw assistant never sends your message alone: before your first word, the context already carries the system prompt, tool definitions, and skills, around 19K tokens in a fresh setup. At the prefill speed we measured, a base chip spends around 12 minutes reading that before the first reply starts. In HolaClaw, we reduced the initial context to ~14K, but it's still high for Muse Glimmer on a MacBook Air.

> **Our recommendation**: 32 GB of unified memory as the minimum requirement for Muse Glimmer, and an M5 Pro or better if you want assistant-grade speed.

If you have one of these high-end Macs, you can try it in HolaClaw from [v1.5.0](/changelog).

## The numbers we measured

Two phases matter when a model answers you, and they behave very differently:

- **Prefill** is the model reading your prompt: everything you send, from your question to the conversation so far, gets processed before the model can say anything, and this determines how long you wait for the first word.
- **Generation** is the model writing the answer, and it determines how fast the words come out once they start. A model can be acceptable at one and frustrating at the other, which is exactly what happens here.

### How we tested

We measured the two phases with two kinds of requests:

- **Short prompts.** One-line questions with short answers. Almost all the time goes to writing the reply, so this isolates generation speed.
- **A long prompt.** A roughly 3,000-word article (4,166 tokens) the model has to summarize. Here the model spends most of its time reading before it writes anything, so this isolates prefill and the time to first token.

Each figure is aggregated over several runs, after a discarded warmup run and with cooldown pauses between runs.

### The results

On the M3 Air (24 GB, 8K context):

| Metric | Test | Measured | Roofline | Efficiency |
|---|---|---|---|---|
| Generation | Short prompts | 4.33 tok/s | 5.97 tok/s | 73% |
| Prefill | Long prompt | 26.2 tok/s | 63 tok/s | 42% |
| Time to first token | Long prompt (4,166 tokens) | 157 s | 66 s | n/a |

The roofline column is the theoretical ceiling for this machine: memory bandwidth divided by model size. On the M3 that's 102.4 GB/s divided by roughly 17 GB, about 6 tokens per second. Measuring 73% of that ceiling on generation tells us something useful: the bottleneck is the machine, not the software. There's no configuration flag that wins this back.

Prefill is a different story. At 42% of its ceiling it's limited by compute rather than memory, and it's the number behind that 157-second wait on the long prompt.

On the M4 Air (32 GB), the 64K context fits, and generation speed came out similar to the M3, within noise. That sounds surprising for a newer chip until you look at what actually limits it.

## Why is it so slow?

### Generation is bound by memory bandwidth

For every token it writes, the model reads its ~17 GB of weights from memory. The M3 moves 102.4 GB/s and the M4 moves 120 GB/s, which is why both base machines land in the same range: the chips are a generation apart, but the memory feeding them is nearly the same.

A faster CPU or GPU doesn't help when the memory bus is the limit.

### Fanless laptops throttle

Testing Muse Glimmer and other models, we found that sustained inference on a fanless MacBook slows down fast: run benchmarks back to back and each run comes out slower than the previous one. The chassis is still hot from the last run 🔥.

It's easy to mistake that for a real performance difference between configurations. Every number in this post was taken with cooldown pauses between runs, so they reflect the chip rather than its temperature. It also means that on an Air, a long working session will run somewhat below these figures.

### Prefill is bound by compute, and agents pay for it

Prefill ran at 42% of its roofline, so unlike generation it's limited by compute. It's also the phase agents lean on hardest. The arithmetic from the table: a 4,166-token prompt at 26.2 tokens per second of prefill is about 159 seconds before the first output token, matching the 157 seconds we measured. Long context in, long silence out.

M5-generation chips attack exactly this: their GPUs add a Neural Accelerator to each core, built for the matrix math that prefill spends its time on.

## Where this leaves us

We believe personal assistants should be able to run on hardware you own: **your conversations stay on your machine, there's no per-token bill, and nobody can change or retire the model out from under you**. That only works if capable open models exist, which is why Muse Glimmer matters. Over time, the base consumer hardware will catch up and setups like this won't require a $5000 device to run at a decent speed.

If you already have a high-end MacBook or Mac Studio, you can try Muse Glimmer in the latest [HolaClaw version](/download)!

And whichever Mac you run it on, come tell us how it went in our [Discord](https://discord.gg/FbxAbS5sGQ): the machine, the context size, and the tokens per second you saw. We want to map how Muse Glimmer runs across the whole Mac lineup, and your numbers help everyone deciding whether to try it.

