Snapdragon X Elite: rodar um LLM local em PC ARM

#Por que o Snapdragon X Elite desperta interesse para uso com um LLM local

O Snapdragon X Elite é um SoC ARM da Qualcomm: até 12 núcleos Oryon, uma GPU Adreno integrada, uma NPU Hexagon anunciada com 45 TOPS e, principalmente, uma memória LPDDR5X unificada compartilhada entre CPU, GPU e NPU. Essa memória unificada lembra a abordagem do Apple Silicon: o modelo carregado pode ser acessado por todos os mecanismos de processamento sem cópia, e você não fica limitado por uma VRAM separada de 8 ou 12 GB.

O outro ponto forte é o perfil térmico. Esses chips foram projetados para ultraportáteis sem ventilador ou quase silenciosos, com autonomia de dezenas de horas em tarefas de escritório. Para um LLM local rodando em segundo plano — resumo de e-mails, reformulação, pequenos scripts — isso abre um campo de possibilidades inédito: sem ventilador disparando, sem bateria se esgotando em vinte minutos.

#O verdadeiro desafio: Windows em ARM

O primeiro obstáculo não é a potência, é a compatibilidade de software. O Windows 11 em ARM executa aplicações x86/x64 por meio de uma camada de emulação (Prism), mas essa emulação custa desempenho e, para a IA, muitas vezes impede o uso de aceleração de hardware. Um binário compilado para x86 com instruções AVX não verá nem a GPU Adreno nem a NPU Hexagon.

A boa notícia: as principais ferramentas de IA local agora possuem builds nativos para ARM64. Essa é a distinção fundamental a manter em mente ao longo deste guia — uma ferramenta “que pode ser instalada” não é necessariamente uma ferramenta “nativa para ARM”. Em emulação, você perde grande parte do benefício da máquina.

Ollama

Disponibiliza um build nativo para Windows ARM64. Inferência na CPU Oryon, com escuta por padrão em http://localhost:11434, como em qualquer outra plataforma.

LM Studio

Oferece uma versão nativa para ARM64 no Windows com Snapdragon, com um runtime llama.cpp compilado para ARM.

llama.cpp

Compila nativamente para ARM64 e aproveita as instruções vetoriais; é o motor subjacente mais otimizado para esses chips.

Evitar

Toda versão x64 executada em emulação Prism: ela funciona, mas lentamente e sem acesso ao hardware especializado.

#A NPU Hexagon: mito e realidade

É o cerne do mal-entendido. O marketing do Copilot+ destaca os 45 TOPS da NPU Hexagon como se qualquer LLM local fosse se beneficiar deles automaticamente. Na prática, em 2026, quase todos os LLMs que você executa via Ollama ou LM Studio rodam nos núcleos da CPU, não na NPU.

Por quê? Porque usar o NPU exige modelos convertidos e quantizados especificamente para o runtime da Qualcomm (via QNN — Qualcomm AI Engine Direct — e o formato ONNX, geralmente por meio do ONNX Runtime com o provedor de execução QNN). Esses não são os mesmos arquivos GGUF consumidos pelo llama.cpp. O NPU se destaca em cargas de trabalho com ritmo regular e previsível; a geração de texto autorregressiva, dominada pela largura de banda da memória, é menos adequada a ele do que se costuma acreditar.

O que utiliza o NPU

Demonstrações e aplicações empacotadas via SDK Qualcomm / AI Hub com modelos ONNX pré-convertidos (geralmente pequenos modelos ou tarefas de visão/áudio).

O que não utiliza o NPU

Ollama, LM Studio e llama.cpp em uso padrão: eles utilizam a CPU (e, às vezes, a GPU Adreno por meio de backends experimentais).

A realidade do desempenho

Nessas máquinas, são principalmente os núcleos Oryon e a largura de banda LPDDR5X que determinam sua velocidade de geração, não os TOPS anunciados da NPU.

#Pré-requisitos e verificações

Antes de instalar qualquer coisa, confirme que você está realmente em uma máquina ARM e identifique a quantidade de RAM — é ela que determina o tamanho dos modelos que você poderá rodar, já que a memória é unificada.

# Architecture du processeur (doit renvoyer ARM64)
$env:PROCESSOR_ARCHITECTURE

# Mémoire physique totale, en Go
(Get-CimInstance Win32_ComputerSystem).TotalPhysicalMemory / 1GB

OS

Windows 11 24H2 ou mais recente, atualizado (as builds mais recentes aprimoram significativamente a emulação Prism e o suporte ARM).

RAM

No mínimo 16 GB para usar confortavelmente modelos de 3B–9B; 32 GB para trabalhar com modelos de 20 a 27B e manter uma margem de memória para o sistema.

Armazenamento

Reserve de 10 a 30 GB livres conforme o número de modelos baixados (um modelo 7B Q4_K_M pesa ~5 GB).

Expectativa realista

Conte com uma experiência fluida com modelos pequenos, razoável com modelos de 8–9B e que exige paciência acima disso. As taxas de processamento não chegam às de uma GPU dedicada.

#Instalar um LLM local passo a passo

A via mais simples e confiável hoje é Ollama em build ARM64 nativo, opcionalmente complementado por uma interface gráfica. Segue o passo a passo.

1. 01
   Baixar Ollama ARM64

   Acesse ollama.com/download e baixe o instalador Windows. A partir das versões recentes, o instalador detecta a arquitetura ARM64 e instala o binário nativo. Verifique depois se o serviço está funcionando corretamente.
2. 02
   Verificar o serviço

   Abra um terminal e execute « ollama --version ». O daemon escuta em http://localhost:11434; uma requisição a essa URL deve retornar « Ollama is running ».
3. 03
   Baixar um primeiro modelo

   Comece pequeno para validar a cadeia completa antes de carregar algo mais pesado. Um modelo de 3B em Q4_K_M é ideal para testar a capacidade de resposta.
4. 04
   Conversar pela linha de comando

   Inicie o modelo e verifique a velocidade de geração. Se a geração for fluida, aumente progressivamente o tamanho (7B, depois 14B), enquanto a RAM for suficiente.
5. 05
   Adicionar uma interface (opcional)

   Instale o LM Studio na versão ARM64 para uma interface completa, ou conecte o Open WebUI ao endpoint do Ollama se preferir uma interface web.

# Modèle léger pour valider la chaîne
ollama pull granite4.2:3b
ollama run granite4.2:3b

# Une fois validé, monter en gamme
ollama pull qwen3.5:9b

#Modelos recomendados para 16 a 32 GB de RAM

Como a memória é unificada e compartilhada com o sistema, não pense que toda a RAM está disponível para o modelo. Sempre reserve 4 a 6 GB para o Windows e seus aplicativos. As referências de consumo de memória em Q4_K_M continuam as mesmas que em uma GPU: um 3B ≈ 2 GB, um 9B ≈ 6-7 GB, um 24B ≈ 14 GB.

16 GB de RAM

Zona de conforto: modelos de 3B a 9B em Q4_K_M. Granite 4.2 3B para agilidade, Qwen 3.5 9B ou Granite 4.2 8B para qualidade. Um gpt-oss 20B (~14 GB) ainda é viável, mas deixa pouca margem.

32 GB de RAM

Você pode usar confortavelmente modelos na faixa de 20–27B — gpt-oss 20B ou Mistral Small 24B (~14 GB, este último com ótimo desempenho em francês), até Qwen 3.8 27B (~18 GB, 262k de contexto) — em Q4_K_M, mantendo uma boa margem de memória para o sistema. Um modelo denso de 32B ou mais pode ser carregado, mas é lento nessa CPU; um MoE como Qwen 3.6 35B-A3B (~23 GB, 3B ativos) continua sendo muito mais rápido.

Quantização

Q4_K_M é o melhor equilíbrio entre qualidade, tamanho e velocidade aqui. Aumente para Q5_K_M apenas se a qualidade for prioridade e se a RAM permitir; evite FP16, que é desnecessariamente pesado nessa classe de máquina.

Casos de uso ideais

Reformulação, resumo, tradução, assistência em tarefas simples de programação, perguntas e respostas off-line — tarefas em que um bom modelo de 9B–24B é mais do que suficiente.

#Autonomia e silêncio: os verdadeiros pontos fortes

É aqui que o Snapdragon X Elite realmente se destaca. Enquanto um notebook gamer x86 com RTX esgota a bateria em poucos minutos sob carga de IA e faz seus ventiladores dispararem, essas máquinas ARM geram texto mantendo-se frias e silenciosas, estejam ou não ligadas à tomada. Para uso em mobilidade — trabalhar em um trem, em um café, em uma sala de reunião — é uma mudança de natureza, não de grau.

Em termos de velocidade bruta, espere taxas de geração razoáveis, mas modestas: da ordem de várias dezenas de tokens por segundo em um modelo de 3B, caindo para poucos tokens por segundo em um modelo denso de 24B. Isso é suficiente para uma conversa fluida com um modelo pequeno, mas torna as gerações longas mais demoradas com um modelo grande. A latência do primeiro token continua razoável graças aos rápidos núcleos Oryon.

Silêncio

É possível gerar sem que os ventiladores disparem, muitas vezes quase sem acioná-los nos modelos de baixo TDP.

Autonomia

É viável realizar inferência usando a bateria, enquanto uma GPU dedicada praticamente exige conexão à tomada. Ideal para um assistente local portátil.

Térmico

Sem throttling agressivo durante o uso leve e prolongado de LLMs, ao contrário dos ultraportáteis x86 levados ao limite.

Desvantagem

Uma taxa de geração que atinge seu máximo bem abaixo da de uma GPU dedicada: nos modelos grandes, o conforto tem um custo em tokens por segundo.

#Limitações em relação à arquitetura x86 e às GPUs dedicadas

Vamos ser claros para evitar decepções. Um Snapdragon X Elite não concorre com um PC equipado com uma placa NVIDIA recente. Uma RTX 3060 de 12 GB, de entrada, rodará um modelo de 14B muito mais rápido, e uma RTX 4090 de 24 GB está em uma categoria totalmente diferente. O ponto forte do Snapdragon não é o desempenho bruto, mas o desempenho por watt e a mobilidade.

Ecossistema ainda jovem

O suporte a ARM64 avança rapidamente, mas ainda é menos maduro que o suporte a x86. Algumas ferramentas, extensões ou backends de GPU estão atrasados ou em fase experimental.

Sem aceleração GPU para o público em geral

O backend Adreno para llama.cpp continua em fase inicial; na prática, a inferência depende principalmente do CPU.

NPU subutilizado

Como visto acima, os 45 TOPS ainda não beneficiam os runtimes de LLM mais comuns.

Limite de tamanho

Acima de cerca de vinte bilhões de parâmetros em modelos densos, a experiência piora significativamente; os modelos muito grandes continuam sendo o domínio das GPUs dedicadas (um MoE com poucos parâmetros ativos continua sendo a exceção que funciona melhor).

#Para se aprofundar

É mais fácil entender o Snapdragon X Elite ao compará-lo com outras abordagens com NPU e dominar os fundamentos da instalação local. Estes guias aprofundam a reflexão:

Ryzen AI 9 HX: o NPU de 50 TOPS realmente serve para LLMs?

O equivalente x86 desse debate sobre NPU, com testes honestos cujos resultados convergem com as conclusões deste guia.

Instalar o Ollama: Windows, macOS e Linux

Para dominar completamente o daemon do Ollama e seus comandos; também se aplica à build ARM64.

Escolher a quantização (Q4, Q5, Q8)

Para ajustar melhor o equilíbrio entre qualidade e velocidade, decisivo em uma máquina na qual a CPU faz a maior parte do trabalho.