Running Muse Glimmer Locally with Ollama: Meta's 30B Model on Consumer Hardware

On August 10, 2026, Meta Superintelligence Labs released Muse Glimmer – a multimodal 30B model under the Apache 2.0 license and the open-weight counterpart to the closed Muse Spark model. It is designed for agent-based tasks: multi-step reasoning, tool use, and code generation. In its 4-bit quantized form it requires 18 GB of VRAM, making it suitable for consumer GPUs such as an RTX 4090 or a Mac with an M4 chip.

This post shows the shortest path from a blank machine to a running Muse Glimmer service with a REST interface. The setup is based on an Ollama installation via Docker. If you already have Ollama running, you can skip directly to "Pull the model."

What Sets Muse Glimmer Apart from Other Open-Weight Models

The most noticeable difference from models like Llama 3.x or Mistral is the embedded vision encoder: the model consists of a language core with approximately 27.8 billion parameters and a separate 1.8-billion-parameter perception module that processes images, screenshots, and diagrams. A 128K-token context window accommodates long documents and multi-step agent interactions within a single conversation.

Muse Glimmer makes sense wherever privacy requirements rule out a cloud service, wherever multimodal inputs – such as screenshots of user interfaces or photos of forms – need to be processed, or wherever a coding agent needs to run on your own hardware. For high parallel throughput in production a dedicated serving stack like vLLM remains the more robust choice; how to set that up is covered in the post Self-hosting Hermes with vLLM.

Prerequisites

• Ollama ≥ 0.32.8 – mandatory; version 0.32.7 includes the model in its manifest but lacks NVIDIA/AMD backend support, causing the download to fail with HTTP 412
• 18 GB VRAM (NVIDIA/AMD) for the standard variant (Q4_K_M) or 21 GB unified memory for Apple Silicon using the MLX variant
• Docker and Docker Compose (recommended) or a native Ollama installation

Starting Ollama with Docker

services:
  ollama:
    image: ollama/ollama:0.32.8  # minimum version; use a newer available tag if not on Docker Hub (see pitfall 1)
    ports:
      - "127.0.0.1:11434:11434"
    volumes:
      - ollama_models:/root/.ollama
    restart: unless-stopped
    # NVIDIA GPU (NVIDIA Container Toolkit required):
    # deploy:
    #   resources:
    #     reservations:
    #       devices:
    #         - driver: nvidia
    #           count: all
    #           capabilities: [gpu]

volumes:
  ollama_models:

docker compose up -d
curl -s http://localhost:11434/api/version

The ollama_models volume prevents the several-gigabyte model weights from being downloaded again after every container restart. Binding to 127.0.0.1 blocks external access – Ollama has no built-in authentication. For a native installation or a deeper look at configuration options, see the post Ollama: self-host an LLM – quickstart.

Pull and Test the Model

# Standard NVIDIA/AMD/CPU - Q4_K_M, approx. 18 GB download:
docker compose exec ollama ollama pull muse-glimmer

# Apple Silicon - MLX engine, approx. 21 GB:
docker compose exec ollama ollama pull muse-glimmer:30b-mlx

# Verify loaded models:
docker compose exec ollama ollama list

# Quick interactive test in the terminal:
docker compose exec -it ollama ollama run muse-glimmer

Calling the REST API

Muse Glimmer uses the same HTTP interface as any other Ollama model – no additional SDK, no new port. By default Ollama streams the response as a sequence of JSON objects (one per line); "stream": false collects everything into a single response, which is more convenient for scripts and batch processing.

For a plain text request:

curl -s http://localhost:11434/api/chat -d '{
  "model": "muse-glimmer",
  "messages": [
    { "role": "user", "content": "Write a Python function that parses ISO 8601 date strings." }
  ],
  "stream": false
}'

The response text is in message.content. For multimodal prompts, attach the image as a Base64 string in the images array:

# Linux: -w 0 suppresses line breaks; macOS: base64 without -w
IMG=$(base64 -w 0 screenshot.png)

curl -s http://localhost:11434/api/chat -d '{
  "model": "muse-glimmer",
  "messages": [
    {
      "role": "user",
      "content": "Describe what is shown in this screenshot.",
      "images": ["'"$IMG"'"]
    }
  ],
  "stream": false
}'

Requests and responses at a glance:

                +--------------------+                      
  Text -------> |                    | ---> JSON            
                |  ollama serve      |      message.content 
  Image ------> |  Port 11434        |      eval_count      
                +--------------------+                      

Existing applications that use the OpenAI Python SDK can be redirected to Muse Glimmer without code changes by setting base_url="http://localhost:11434/v1/" – the /v1/chat/completions endpoint is fully compatible.

Three Common Pitfalls

1. Ignoring the minimum version requirement. Version 0.32.7 includes Muse Glimmer in its manifest but lacks NVIDIA/AMD backend support; the pull fails with HTTP 412. Check first with ollama --version. Docker Hub tags can lag behind GitHub releases by a few days; if 0.32.8 is not yet available as an image tag, use the next higher released version.

2. Wrong tag on Apple Silicon. The default tag muse-glimmer is GGUF-based and technically runs on Apple Silicon, but it does not use the MLX engine. For significantly higher token rates on M4 and M5 chips, explicitly pull muse-glimmer:30b-mlx. The two tags occupy separate storage areas in the Ollama directory; mixing them up means downloading data twice.

3. Underestimating the VRAM budget. The 18 GB for the Q4_K_M variant breaks down into roughly 17 GB of model weights and roughly 1 GB for the vision encoder. Add another 1–2 GB for the KV cache during inference. On a card with exactly 18 GB of VRAM the setup runs at its limit – 24 GB allows for noticeably more comfortable operation.

What to Do Next

With this in place, Muse Glimmer runs locally and is reachable via REST. A natural next step is a RAG pipeline: vectorize documents via POST /api/embed with an embedding model like nomic-embed-text and store them in a local vector database. How to set that up with Qdrant is explained in the post Self-hosting Qdrant for RAG.

Further reading: Ollama blog on Muse Glimmer, Meta research blog, Ollama API reference, Ollama library: muse-glimmer.