Como executar o Qwen3.8-27B localmente em uma NVIDIA RTX 5090

1. Configure o llama.cpp para GPUs Blackwell

Primeiro, vamos garantir que a GPU foi detectada corretamente e checar a versão do driver NVIDIA e do CUDA.

nvidia-smi

Você deverá ver sua RTX 5090, a versão do driver, a versão do CUDA, a memória da GPU e o uso atual da GPU.

Observação: esta configuração é específica para GPUs NVIDIA Blackwell, como a RTX 5090. A build abaixo mira a SM120, que é a arquitetura de computação usada pela RTX 5090.

Em seguida, vamos baixar e compilar a versão mais recente do llama.cpp com suporte a CUDA.

cd /workspace

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

cmake -B build \
  -DGGML_CUDA=ON \
  -DCMAKE_CUDA_ARCHITECTURES=120

cmake --build build --config Release -j$(nproc)

A parte importante aqui é -DCMAKE_CUDA_ARCHITECTURES=120. Isso informa ao llama.cpp para compilar especificamente para a arquitetura Blackwell usada pela RTX 5090.

Quando a compilação terminar, vamos tornar o llama-server disponível globalmente para que possamos executá-lo de qualquer pasta:

sudo ln -sf "$(realpath ./build/bin/llama-server)" /usr/local/bin/llama-server

Agora, verifique se está tudo funcionando:

llama-server --version

Você deve ver uma saída parecida com:

version: 0.1.1-dev (build 10479, commit 0021a77de)
built with GNU 13.3.0 for Linux x86_64

Pronto. Agora temos uma build do llama.cpp com CUDA que aproveita a RTX 5090 e seu suporte nativo a NVFP4 de Blackwell.

2. Baixe o modelo Qwen3.8-27B NVFP4-MTP

Agora vamos baixar o modelo Qwen3.8-27B.

Primeiro, instale a CLI do Hugging Face:

pip install -U huggingface_hub

Crie uma pasta para manter o modelo:

mkdir -p /workspace/models/qwen38

Depois, baixe o GGUF NVFP4-MTP:

hf download felippeburk/Qwen3.8-27B-NVFP4-MTP-GGUF \
  --local-dir /workspace/models/qwen38

Esta é a versão ideal para esta configuração porque usa NVFP4 e inclui suporte a MTP, responsável por grande parte do ganho de velocidade na RTX 5090.

3. Inicie o servidor do Qwen3.8-27B

Agora vem a parte divertida. Vamos servir o Qwen3.8-27B totalmente na GPU com Flash Attention, janela de contexto de 131K e decodificação especulativa MTP para gerar mais rápido. 

Execute:

cd /workspace/llama.cpp

llama-server \
  -m /workspace/models/qwen38/qwen3.8-27b-text-nvfp4-mtp.gguf \
  --alias qwen3.8-27b \
  --host 0.0.0.0 \
  --port 8910 \
  --ctx-size 131072 \
  --n-gpu-layers all \
  --flash-attn on \
  --cache-type-k q8_0 \
  --cache-type-v q8_0 \
  --parallel 1 \
  --spec-type draft-mtp \
  --spec-draft-n-max 4 \
  --spec-draft-p-min 0.75 \
  --spec-draft-ngl all \
  --spec-draft-type-k q8_0 \
  --spec-draft-type-v q8_0 \
  --reasoning-effort medium \
  --jinja

Há muitas opções aqui, mas a maioria está aí para extrair o melhor desempenho da 5090.

Os principais parâmetros são:

• --ctx-size 131072 nos dá cerca de 131K de janela de contexto.

• --n-gpu-layers all mantém o modelo na GPU.

• --flash-attn on ativa o Flash Attention.

• --cache-type-k q8_0 e --cache-type-v q8_0 ajudam a reduzir o uso de memória do cache KV.

• --spec-type draft-mtp habilita a decodificação especulativa MTP do Qwen3.8.

• --spec-draft-n-max 4 controla quantos tokens especulativos o MTP pode gerar por vez.

Nesta configuração, usamos n-max 4 como ponto de partida para uma RTX 5090. Você pode experimentar valores como 2 (recomendado no card do modelo para este GGUF) ou 3 depois, já que o ajuste mais rápido pode variar um pouco conforme seu sistema.

Quando o llama-server terminar de carregar o modelo, o Qwen3.8 estará disponível localmente em http://127.0.0.1:8910.

Agora temos o Qwen3.8-27B rodando localmente. Em seguida, vamos testar o modelo tanto pela API quanto pela interface no navegador.

4. Teste a velocidade e o desempenho em código do Qwen3.8-27B

Com o servidor no ar, abra outro terminal e envie uma requisição de teste para a API compatível com OpenAI:

curl http://127.0.0.1:8910/v1/chat/completions \
 -H "Content-Type: application/json" \
 -d '{
   "model": "qwen3.8-27b",
   "messages": [
     {
       "role": "user",
       "content": "Write a Python FastAPI application that monitors GPU usage."
     }
   ],
   "max_tokens": 2000
 }'

Neste teste, o Qwen3.8-27B gerou 2.000 tokens a 122 tokens/s com uma taxa de aceitação MTP de 84,9% — excelente. 

O llama.cpp também inclui uma interface no navegador, então você pode testar o modelo sem usar a API.

Abra http://127.0.0.1:8910 no seu navegador para ver a interface.

Para um teste mais complexo, usei este prompt:

Create a stunning single-file animated HTML website with a dark futuristic 
theme, smooth scrolling, glowing gradients, floating particles, animated cards,
hover effects, and responsive design using only HTML, CSS, and JavaScript.

Na minha RTX 5090, fiquei em média por volta de 142 tokens por segundo, com picos chegando a ~170 tokens por segundo — extremamente rápido para um modelo 27B rodando localmente. 

O Qwen3.8-27B gerou um site completo, bem acabado e funcional, que rodou de primeira. É uma ótima forma de testar rapidamente tanto a habilidade de código do modelo quanto a velocidade do setup local. 

5. Use o Qwen3.8-27B com o Pi

Nesta etapa, vamos conectar o Qwen3.8-27B ao Pi e usá-lo como um agente de código totalmente local.

O Pi é um agente de código leve baseado em terminal que ajuda você a criar, editar, testar e depurar projetos direto da linha de comando.

Instale o Pi com:

curl -fsSL https://pi.dev/install.sh | sh

O instalador exige Node.js e npm. Ele instala o Pi no prefixo global do npm. Se você ainda não tem Node, instale-o antes com nvm ou pelo seu gerenciador de pacotes.

Quando a instalação terminar, reinicie o terminal.

Depois, instale a extensão pi-llama e aponte o Pi para o nosso servidor local do llama.cpp:

pi install git:github.com/huggingface/pi-llama

export LLAMA_BASE_URL=http://127.0.0.1:8910/v1

Crie um novo projeto e inicie o Pi:

mkdir new-project
cd new-project

Pi

Dentro do Pi, rode /model, pesquise por llama-cpp e selecione Qwen3.8-27B.

Para testar, passei este prompt:

Build a polished personal finance dashboard from scratch that imports CSV 
bank statements, categorizes spending, shows monthly trends and charts, and 
detects unusual expenses; also generate a realistic sample CSV, import it, 
test the full app end-to-end, and fix any errors automatically.

Ele construiu o projeto inteiro em poucos minutos. 

Depois pedi para iniciar o servidor e testar tanto o frontend quanto a lógica da aplicação. Ele dedicou mais tempo ao debug e aos testes para garantir que tudo estivesse funcionando direito.

Quando testei o dashboard, o app funcionou bem, os gráficos ficaram ótimos e a experiência geral foi fluida.

O principal ponto fraco foi fazer ajustes de UI muito precisos. Depois de várias instruções de refinamento, ele começou a fazer mudanças não relacionadas em vez de entender exatamente o que eu queria, então parei por aí.

Considerações finais

O Qwen3.8-27B ainda é bem novo, e a comunidade segue explorando a melhor combinação de quantização e decodificação especulativa. O MTP funciona muito bem, mas abordagens mais novas como DFlash 2 e DSpark também estão sendo testadas, e alguns usuários relatam velocidades ainda maiores dependendo do hardware e da carga de trabalho. 

A Unsloth também lançou recentemente GGUFs Dynamic v3.0 para o Qwen3.8-27B, afirmando cerca de 10% a mais de precisão no mesmo tamanho de modelo em comparação com seus quants anteriores. Isso torna a Unsloth outra opção bem interessante se você busca maior qualidade mantendo praticamente a mesma configuração de inferência local. 

Por enquanto, acredito que NVFP4 + MTP + llama.cpp é um dos setups mais fáceis e rápidos para a RTX 5090. Conseguir ~140 tokens por segundo com um modelo de 27B, mantendo uma janela de contexto grande e capacidade suficiente para rodar um agente de código real, é impressionante. É provável que esse setup fique ainda mais rápido à medida que o llama.cpp, a Unsloth, o DFlash 2 e o DSpark evoluírem.