Como executar o Muse Glimmer 30B localmente para programação com IA

Como exploramos no nosso post do blog, Muse Glimmer 30B é um novo modelo aberto criado para workloads agentic e de programação. 

O que o torna especialmente interessante é que você pode executar tudo localmente em uma única NVIDIA RTX 5090 com 32 GB de VRAM usando o llama.cpp.

O modelo está disponível no formato GGUF, e, neste guia, vou usar a quantização dinâmica de maior qualidade. 

A configuração completa inclui:

• muse-glimmer-30B-kquant-dynamic.gguf: 19,7 GB modelo principal
• dflash-kquant.gguf: 1,63 GB modelo rascunho para decodificação especulativa
• mmproj-kquant.gguf: 1,4 GB codificador de visão e percepção

Segundo o model card, a quantização dinâmica de 19,7 GB tem apenas cerca de 0,2% de degradação em benchmarks em comparação com a precisão total. 

Nos meus testes, executar o modelo com uma janela de contexto de 64K consumiu cerca de 24 GB de VRAM, deixando uma boa margem na RTX 5090.

Neste guia, você vai aprender a:

1. Compilar o llama.cpp com suporte a CUDA
2. Baixar e executar o Muse Glimmer 30B localmente
3. Ativar decodificação especulativa DFlash e entrada de visão
4. Testar o modelo via API e Web UI nativa
5. Conectar o modelo local ao OpenCode
6. Usar o Muse Glimmer para criar e depurar um aplicativo completo

Ao final, também teremos uma noção prática de onde o Muse Glimmer manda bem como modelo local de programação e onde ele ainda patina. Recomendo também conferir nosso guia do Muse Spark 1.3 para conhecer os recursos mais recentes.

1. prepare o llama.cpp para inferência em GPU

Antes de executar o Muse Glimmer localmente, precisamos compilar o llama.cpp com suporte a CUDA para que o modelo use a GPU da RTX 5090.

Comece instalando os pacotes de sistema necessários:

apt-get update

apt-get install -y \
    build-essential \
    cmake \
    curl \
    git \
    libcurl4-openssl-dev

Em seguida, clone o repositório do llama.cpp e entre no diretório do projeto:

git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp

Configure a build com CUDA ativado:

cmake -B build \
    -DBUILD_SHARED_LIBS=OFF \
    -DGGML_CUDA=ON

Agora compile as ferramentas de linha de comando, a CLI multimodal e o servidor:

cmake --build build --config Release -j \
    --target llama-cli llama-mtmd-cli llama-server

Quando a compilação terminar, deixe o llama-server disponível globalmente para poder executá-lo de qualquer diretório:

ln -sf "$(pwd)/build/bin/llama-server" /usr/local/bin/llama-server

Por fim, confirme que a instalação está funcionando:

llama-server --version

Você deve ver uma saída semelhante a:

version: 10373 (38406d597)
built with GNU 13.3.0 for Linux x86_64

Neste ponto, o llama.cpp está compilado com suporte a CUDA, e o llama-server está pronto para rodar o Muse Glimmer na GPU.

2. baixe o Muse Glimmer

Agora, baixe o modelo principal do Muse Glimmer junto com os arquivos GGUF adicionais necessários para decodificação especulativa e entrada de visão.

Primeiro, instale o CLI do Hugging Face:

pip install -U huggingface_hub

Depois, faça login na sua conta do Hugging Face:

hf auth login

Escolha a opção de login pelo navegador, abra a página de autorização e aprove a conexão no seu browser.

Agora baixe os três arquivos necessários:

hf download meta-models/Muse-Glimmer-30B-GGUF \
    --local-dir Muse-Glimmer-30B-GGUF \
    --include "muse-glimmer-30B-kquant-dynamic.gguf" \
    --include "dflash-kquant.gguf" \
    --include "mmproj-kquant.gguf"

Isso baixa:

• muse-glimmer-30B-kquant-dynamic.gguf: o modelo principal de 19,7 GB
• dflash-kquant.gguf: o modelo rascunho usado para decodificação especulativa
• mmproj-kquant.gguf: o codificador de percepção necessário para entrada de imagens

Os arquivos são bem grandes, então o download pode levar um tempo, dependendo da sua conexão.

Com os três arquivos baixados, você terá tudo para executar o Muse Glimmer com geração de texto, suporte a visão e decodificação especulativa DFlash.

3. sirva o Muse Glimmer com visão e decodificação especulativa

Com os três arquivos GGUF em mãos, podemos iniciar o Muse Glimmer usando o llama-server.

O comando abaixo carrega o modelo principal, ativa o modelo rascunho DFlash para decodificação especulativa e adiciona o codificador de percepção para entrada de visão:

llama-server \
    -m /workspace/Muse-Glimmer-30B-GGUF/muse-glimmer-30B-kquant-dynamic.gguf \
    -md /workspace/Muse-Glimmer-30B-GGUF/dflash-kquant.gguf \
    --mmproj /workspace/Muse-Glimmer-30B-GGUF/mmproj-kquant.gguf \
    --spec-type draft-dflash \
    --spec-draft-n-max 15 \
    -ngl 99 \
    --spec-draft-ngl all \
    -fa on \
    --temp 1.0 \
    --top-p 0.95 \
    --top-k 64 \
    --ctx-size 64000 \
    --alias muse-glimmer-30B \
    --host 0.0.0.0 \
    --port 8910 \
    --jinja

Essa configuração usa uma janela de contexto de 64K, descarrega o modelo para a GPU, ativa o Flash Attention e executa o servidor na porta 8910.

Quando o modelo terminar de carregar, ele ficará disponível em:

http://127.0.0.1:8910

Você pode confirmar que tudo está rodando corretamente enviando uma solicitação simples para a API compatível com OpenAI:

curl -s http://127.0.0.1:8910/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "muse-glimmer-30B",
        "messages": [
            {
                "role": "user",
                "content": "Explain speculative decoding in three simple sentences."
            }
        ]
    }'

Neste teste, o Muse Glimmer gerou 364 tokens de conclusão a 83,94 tokens/segundo, enquanto o prompt foi processado a 147,48 tokens/segundo. 

Com a decodificação especulativa DFlash ativada, o modelo rascunho propôs 1.665 tokens, dos quais 253 foram aceitos, dando uma taxa de aceitação de aproximadamente 15,2%. 

O prompt de 64 tokens foi processado em cerca de 434 ms, enquanto a geração levou aproximadamente 4,34 segundos. 

A resposta confirma que o modelo está rodando corretamente via API local.

Você também pode verificar quanta memória de GPU a configuração completa está usando:

nvidia-smi

Com o modelo de 30B quantizado dinamicamente, o rascunho DFlash, o codificador de visão e a janela de 64K carregados juntos, minha configuração usou aproximadamente 23,8 GB de VRAM na RTX 5090.

Isso deixa cerca de 8 GB de VRAM livre, dando margem para experimentar janelas de contexto maiores depois.

4. teste o Muse Glimmer na Web UI com prompts de visão e código

llama-server vem com uma Web UI nativa, que facilita testar o modelo sem enviar requisições à API manualmente.

Abra:

http://127.0.0.1:8910

Você pode usar a interface para prompts de texto, compreensão de imagens e experimentos rápidos de código.

Como carregamos o codificador de visão com:

--mmproj /workspace/Muse-Glimmer-30B-GGUF/mmproj-kquant.gguf

O Muse Glimmer também aceita entrada de imagem.

Para testar a capacidade de visão, enviei a capa de um dos meus livros e usei o seguinte prompt:

Describe what you see in this image and point out the most important details.

O modelo produziu uma descrição detalhada da capa e identificou vários elementos visuais menores também. 

Foi um bom primeiro teste para confirmar que o codificador de visão estava funcionando corretamente.

Depois, testei a capacidade de código com uma tarefa simples de geração de site:

Build a modern luxury watch website for VELORÉ, 
with a minimalist V logo, black/ivory/deep-green palette, 
cinematic hero, premium watches, smooth animations, 
and elegant Swiss-inspired styling.

Durante essa tarefa de código, a geração ficou em média em torno de 121 tokens por segundo, visivelmente mais rápido que o teste de texto geral anterior. 

A decodificação especulativa DFlash pareceu funcionar particularmente bem nesse tipo de geração sequencial de código.

O modelo gerou um site utilizável de relógios de luxo. 

Ainda havia alguns problemas no resultado final, o que não surpreende para um modelo de 30B, mas ele conseguiu produzir um projeto completo bem rápido.

O Muse Glimmer é posicionado como um modelo agentic de programação, então o teste mais importante é ver como ele se sai ao criar arquivos, executar comandos, testar o próprio trabalho e corrigir problemas. Vamos testar isso conectando-o ao OpenCode.

5. conecte o Muse Glimmer ao OpenCode e teste programação agentic

Com o Muse Glimmer rodando localmente, o próximo passo é conectá-lo ao OpenCode e ver como ele se comporta como modelo agentic de código.

Primeiro, instale o OpenCode:

curl -fsSL https://opencode.ai/install | bash

Recarregue o shell e confirme a instalação:

exec bash
opencode --version

Para este teste, eu estava usando:

1.18.16

Crie o diretório de configuração do OpenCode:

mkdir -p ~/.config/opencode

Em vez de abrir um editor de texto, crie o arquivo de configuração direto no terminal:

cat > ~/.config/opencode/opencode.json <<'EOF'
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "llama.cpp": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Muse Glimmer Local",
      "options": {
        "baseURL": "http://127.0.0.1:8910/v1"
      },
      "models": {
        "muse-glimmer-30B": {
          "name": "Muse Glimmer 30B"
        }
      }
    }
  },
  "model": "llama.cpp/muse-glimmer-30B"
}
EOF

Isso informa ao OpenCode para usar a API compatível com OpenAI exposta pelo nosso llama-server local.

Agora, crie um novo projeto:

mkdir muse-app
cd muse-app
git init
opencode

O OpenCode vai abrir sua interface de terminal com o Muse Glimmer 30B já configurado como modelo principal.

Crie um aplicativo completo

Para testar o modelo em algo mais realista, pedi que ele construísse um aplicativo de pesquisa médica:

Build a modern medical AI web app called MedSearch AI.
Use Python FastAPI for the backend and HTML, CSS and JavaScript for the frontend.
Create a clean dark interface where users can ask medical research questions. 
Send prompts to my local Muse Glimmer server at:http://127.0.0.1:8910/v1/chat/completions
Add web search for the latest reliable medical information, show sources clearly, 
support streaming responses and Markdown, and include a clear-chat button and server status indicator.

Create all files, install dependencies, test the app, and tell me how to run it.

O resultado inicial foi impressionante. Levou cerca de um minuto para gerar o projeto completo. 

Ele criou backend, frontend, dependências e toda a estrutura do app muito rapidamente.

Então pedi que ele testasse tanto o backend quanto a interface.

Foi aí que comecei a notar as fraquezas do modelo.

Rápido para construir, mais fraco para depurar

Em benchmarks artificiais de código, o Muse Glimmer fica próximo do modelo Qwen3.6 27B , mas, pelos meus testes, ele é visivelmente pior ao executar uma tarefa de programação na prática.

O maior problema foi a depuração.

O Muse Glimmer foi muito rápido para criar um projeto completo do zero, mas quando algo dava errado, ele tinha dificuldade para resolver o problema sozinho. Podia gastar muito tempo tentando coisas diferentes sem avançar de fato.

Acabei tendo que dizer exatamente o que fazer. 

Por exemplo, eu instruí explicitamente a:

1. Iniciar o servidor backend em background.
2. Aguardar o servidor ficar disponível.
3. Enviar uma requisição para o app em execução.
4. Verificar a resposta.
5. Corrigir quaisquer erros encontrados.
6. Testar o aplicativo novamente.

Depois que dei esses passos concretos, ele entendeu a tarefa e os seguiu com sucesso.

Esse provavelmente foi meu maior insight ao usar o Muse Glimmer com o OpenCode. 

Você precisa ser bem explícito sobre o que quer que ele faça. 

Em vez de dizer "teste o aplicativo" ou "corrija o problema", funciona muito melhor quando você descreve a sequência exata de ações que ele deve executar.

Por isso, a engenharia de prompts é particularmente importante com este modelo.

O aplicativo final

Depois de resolver as questões de depuração, o aplicativo MedSearch AI resultante ficou muito bom.

O app ficou rápido, completo em recursos e surpreendentemente simples. 

Usou um backend leve com FastAPI e HTML, CSS e JavaScript puros no frontend, sem depender de um framework grande.

Essa simplicidade foi, na verdade, um dos pontos que mais gostei no resultado. 

O Muse Glimmer criou um app de IA funcional sem adicionar complexidade desnecessária.

Minha experiência até agora é que o Muse Glimmer é excelente para gerar muito código funcional rapidamente, mas é bem menos confiável quando precisa diagnosticar problemas, planejar depuração em múltiplas etapas e se recuperar de falhas sozinho.

Para programação local, essa diferença importa. 

Se você der instruções claras e detalhadas, ele pode ser bem capaz. 

Se você esperar que ele descubra tudo sozinho, especialmente na depuração, as limitações ficam bem mais evidentes.

considerações finais

O Muse Glimmer 30B ainda é um modelo bem novo, e isso ficou claro nos meus testes. 

Ele foi muito rápido para gerar código, mas teve mais dificuldade com depuração e tarefas em múltiplas etapas. Muitas vezes precisei dizer exatamente o que fazer para ele avançar.

Mesmo com esses pontos, acho que o modelo tem muito potencial. 

Com prompts melhores e evoluções futuras, vejo ele se tornando um modelo local de programação bem utilizável, similar ao que vivi com o Qwen3.6 27B.

Também acho que este é um ótimo caminho para a Meta AI. 

Há um interesse claro em agentes de código locais, porque eles oferecem:

• Custo menor, sem cobranças de API
• Mais privacidade para seu código e dados
• Mais controle sobre o resultado
• A possibilidade de trabalhar localmente sem depender de uma API externa

Na minha configuração, o modelo usou cerca de 24 GB de memória de GPU, o que o torna prático para hardware local de ponta. 

Você também pode rodar modelos assim com memória do sistema ou unificada, embora o desempenho fique mais lento.

Neste guia, compilamos o llama.cpp, baixamos os arquivos GGUF do Muse Glimmer, ativamos visão e decodificação especulativa, testamos a API e a Web UI e conectamos o modelo ao OpenCode. 

Também o usamos para construir e testar um app completo. 

Meu principal insight é que o Muse Glimmer é muito rápido para criar código, mas ainda precisa de instruções claras ao depurar ou lidar com tarefas agentic mais complexas.