7 motores locais de IA: só 1 tem tabela verificável

A maioria dos motores locais de IA mede coisas diferentes e chama tudo de comparação. Numa auditoria de sete projetos, quatro reportaram números em escopos distintos e dois não tinham fonte primária alguma. O truque real é duplo: fundir kernels para eliminar pausas e usar decodificação especulativa para ler os pesos uma vez por vários tokens.

Motores locais de IA prometem demais? Como verificar as manchetes

A maioria das manchetes de motores locais de IA não se sustenta quando você abre a página, porque cada projeto mede uma fatia diferente do trabalho. Numa auditoria de sete alegações virais, apenas uma publicação trazia tabela com os dois números lado a lado; quatro reportavam algo diferente do título e duas não tinham fonte primária.

A entrada de tecnologia nessa lista é o Claude Code, a ferramenta de codificação agêntica de terminal da Anthropic dos posts atribuídos a ele descrevia um mega kernel CUDA, mas o digest alemão que circulou não linkava nem o post original nem o repositório.

A questão prática é sempre a mesma: o número ao lado do llama.cpp foi medido com o mesmo modelo, o mesmo contexto e as mesmas flags? Se a resposta não está escrita, a razão de velocidade é uma peça de propaganda, não um dado.

A única tabela verificável: Strata Pascal contra llama.cpp

O fork Strata Pascal é o único dos sete projetos examinados que publica uma tabela com baseline e resultado medidos no mesmo teste. Ele roda um modelo Qwen 3.6 de 35 bilhões de parâmetros com 3 bilhões ativos — um mistério de especialistas — em um notebook com GTX 1050 Ti mobile de 4 GB e 48 GB de RAM de sistema, segundo o repositório do projeto em 2026.

Os números: 24,53 tokens por segundo no fork contra 7,88 no llama.cpp build B11524 com prompt de 8K, uma diferença de 3,1 vezes. A leitura de prompt (prefill) teria ficado 2,26 vezes mais rápida. A 16K, a decodificação ficou em 21,40 contra 7,16.

O próprio README lista as ressalvas. O fork fez média de quatro execuções contra duas do baseline, e as flags de offload do llama.cpp não foram divulgadas. Sem elas, o tamanho real da vantagem de 3,1 vezes permanece desconhecido.

O que a ressalva implica

Sem a lista de flags do baseline, você não sabe se o llama.cpp estava configurado de forma ideal. Uma comparação séria exige build, flags, versão do modelo e configuração de hardware do mesmo lado da equação.

Mesmo assim, esse é o padrão mínimo que os outros seis projetos não atingiram.

Por que a decodificação simples para no teto de banda de memória

Toda decodificação simples de um LLM tem um teto físico: a banda de memória dividida pelos bytes lidos por token. O modelo lê aproximadamente cada peso ativo uma vez para escrever cada token novo, então a velocidade não passa dessa razão.

No caso de um RTX 3090, a banda é de 936 GB/s. Um arquivo Qwen de 27 bilhões em 4 bits ocupa de 17,1 a 19 GB. A divisão dá um teto entre cerca de 49 e 55 tokens por segundo. Um limite semelhante aparece no SoC M5 Max, com banda de 614 GB/s: sobre um arquivo stand-in de 16 a 17 GB, o teto fica perto de 36 a 38.

O limite é uma aproximação

Esse cálculo ignora o cache de chave-valor, os dados parciais que o modelo guarda sobre tokens anteriores. Ele também supõe um modelo denso, não um MoE. Os valores de banda vêm de reviews e fichas técnicas.

Ainda assim, o teto serve como filtro: qualquer alegação acima dele exige decodificação especulativa, e não apenas um kernel mais eficiente.

GPU	Banda de memória	Teto teórico em 4-bit
RTX 3090	936 GB/s	~49 a 55 tok/s
M5 Max	614 GB/s	~36 a 38 tok/s

As duas acelerações reais: kernels fundidos e decodificação especulativa

Existem duas técnicas legítimas por trás dos ganhos reais, e nenhuma delas quebra a física da memória. A primeira ataca a espera entre operações; a segunda faz render mais por leitura.

Kernels fundidos eliminam pausas

Uma inferência comum dispara cerca de 100 pequenos programas de GPU (kernels) por token, cada um com ida ao CPU, busca em memória global e sincronização. Um kernel fundido junta todas as camadas em um despacho. Um projeto documentou todas as 24 camadas de um modelo de 0,8 bilhão em um só dispatch, rodando 411 tokens por segundo a 220 W contra 267 a 350 W do llama.cpp em um RTX 3090.

Repare no tamanho do modelo: 0,8 bilhão é o cenário mais favorável possível, porque a sobrecarga de disparo pesa mais quando o modelo é pequeno. Isso explica a ideia, não como se constrói um mega kernel de 27 bilhões.

Decodificação especulativa lê o peso uma vez por vários tokens

Um rascunho barato adivinha os próximos tokens e o modelo grande confere todos em uma passada paralela. O peso é lido uma vez para o lote inteiro. A regra de aceitação mantém a distribuição de saída, então o texto gerado é equivalente.

O ganho depende da previsibilidade do texto. Em um repositório comunitário de MTP para Qwen de 27 bilhões, prompts de código aceleraram mais de 90%, contra 30% a 40% em prosa. A taxa de aceitação foi 0,78 no RTX 3090 e 0,56 no RTX 4090, mas o 4090 ganhou mais — e o repositório não explica por quê.

Uma tentativa de adivinhação é um negócio arriscado: tudo depois do primeiro erro é descartado.

Lithos-Metal, PolyStrata, Glyd e o fork V620: o que cada página sustenta

Cada um dos outros quatro projetos reporta menos do que a manchete sugere, e o motivo varia. A tabela abaixo resume o que a fonte primária efetivamente diz.

Projeto	Número da manchete	O que a página mostra
Lithos-Metal	2x mais rápido que MLX	168 tok/s a contexto curto e 127 a 32K, ambos projeções de computação-alvo no M5 Max
PolyStrata	57 tok/s vs 26 do llama.cpp	57 a 59 em notebook com RTX 4070 de 8 GB; o 26 não aparece em nenhum documento
Glyd	2,5x llama.cpp no RTX 4090	45,5 tok/s medidos no RTX 4090; nenhuma comparação com llama.cpp publicada
Fork V620	8x	~70 tok/s em oito Radeon Pro V620; nenhuma execução stock de llama.cpp para dividir

Lithos-Metal e as três medições de um único chip

O README do Lithos-Metal cita cerca de 168 tokens por segundo em contexto curto e 127 a 32K no M5 Max de 40 núcleos, mas rotula ambos como projeções de computação-alvo. O documento de verificação dos autores diz que os escopos de tempo diferentes impedem uma alegação de aceleração ponta a ponta. Um post no X acrescenta mais de 200 por segundo por usuário no pico. São três números para o mesmo chip, cada um medindo uma fatia diferente.

PolyStrata troca a placa da manchete

A manchete do PolyStrata junta 57 tokens por segundo no RTX 5090 com 26 do llama.cpp. A tabela real mede GLM 5.3 flash entre 59 e 66 no 5090. As notas de versão trazem a faixa de 57 a 59, que pertence a um notebook com RTX 4070 de 8 GB. O 26 do llama.cpp não aparece no README, no documento de backends nem nas notas.

Glyd mede bem, mas sem comparação

O cartão do modelo Glyd reporta 45,5 tokens por segundo para o Nemotron 3 Super, de 120 bilhões de parâmetros, no RTX 4090 a 4K, mantendo 190 de 512 especialistas na GPU. Os especialistas ficam comprimidos em 2,99 bits, de 241,4 GB para 48,7 GB, e o próprio cartão avisa que não é sem perdas.

A taxa de concordância com o modelo original é de 96,9%. A licença é a Business Source License 1.1: o uso gratuito vale apenas para pessoal e não comercial, e o motor próprio da Glyd é obrigatório.

O baseline se move: o que o llama.cpp ganhou em 2026

O llama.cpp não ficou parado, e isso encolhe a vantagem que qualquer fork precisa provar. Duas mudanças de 2026 elevam o piso de desempenho.

O pull request 22673, integrado em 16 de maio, permite que a cabeça MTP embutida no arquivo do modelo rascunhe dois ou três tokens para o modelo principal verificar. Com três rascunhos, o PR relata cerca de 75% de aceitação em regime estável. Em um RTX 3090 com quantização Q6K, a taxa foi de 22,97 para 42,45 tokens por segundo — cerca de 1,85 vez — ao custo de aproximadamente 2,5 GB extras de memória de vídeo.

O pull request 27694, integrado em 2 de outubro, adicionou uma flag de amostragem especulativa do rascunho. Ela troca a escolha gulosa por uma escolha probabilística, e o modelo principal aceita ou rejeita cada palpite comparando probabilidades (rejection sampling). Em temperatura zero, nada muda.

O resumo que circula fala em "+14% em prosa", mas esse número não está no PR. O mais próximo é 14,09% em temperatura 0,9, medindo comprimento aceito, não vazão. Verifique o dado na fonte antes de repetir.

O teste em três passos antes de instalar qualquer motor

Três verificações rápidas eliminam quase todos os fins de semana perdidos, e nenhuma delas exige instalar nada. Faça-as na ordem abaixo.

1. Calcule o teto da sua placa. Divida a banda de memória pelo tamanho do arquivo do modelo. Se a alegação supera muito esse número, ela exige decodificação especulativa comprovada, não apenas um kernel melhor.
2. Procure o build e as flags do baseline. A comparação precisa informar a versão do llama.cpp, a lista de flags de offload e se o MTP estava ligado. Sem isso, a razão de velocidade não tem denominador confiável.
3. Confirme modelo e hardware do número. Cada resultado foi reportado para um modelo e uma placa. Sem essa correspondência, o dado não se aplica ao que você vai rodar no mês seguinte.

Quem se dá bem com cada placa

Em uma placa de 24 GB rodando Qwen de 27 bilhões, o primeiro passo é a flag MTP do próprio llama.cpp, documentada em +33% no RTX 3090 e +60% no RTX 4090. Se você amostra em temperatura 0,5 ou mais, a flag de amostragem especulativa também vale testar, mas as tabelas do PR cobrem apenas modelos de 8 e 9 bilhões.

Em notebook com Pascal antigo, como a GTX 1050 Ti mobile de 4 GB, o fork Strata Pascal é a escolha com número medido — com a ressalva das flags não divulgadas. Em Mac, trate 168 e 127 como projeções até aparecer um número ponta a ponta. O fork V620 só interessa a quem já tem quatro ou oito Radeon Pro V620.

Perguntas frequentes

• Algum motor local de IA é realmente 2x ou 3x mais rápido que o llama.cpp?

O fork Strata Pascal é o único dos sete examinados com tabela comparando os dois lados no mesmo teste: 24,53 contra 7,88 tokens por segundo em um notebook com GTX 1050 Ti de 4 GB. Mesmo esse resultado tem ressalva, porque as flags de offload do baseline não foram divulgadas.

• Como calcular se uma alegação de velocidade é possível na minha GPU?

Divida a banda de memória da placa pelo tamanho do arquivo do modelo em bytes. Um RTX 3090 com 936 GB/s e um arquivo de 17 a 19 GB chega a um teto de cerca de 49 a 55 tokens por segundo em decodificação simples.

• O que a decodificação especulativa muda no resultado do texto?

A regra de aceitação é desenhada para manter a distribuição de saída, então o texto gerado continua equivalente ao do modelo original. O ganho de velocidade depende da previsibilidade do texto: código acelera mais que prosa.

• Vale a pena testar a flag de amostragem especulativa do llama.cpp?

Só se você amostra em temperatura 0,5 ou acima. Em temperatura zero ela não altera nada. As tabelas do pull request cobrem modelos de 8 e 9 bilhões, então o efeito em um modelo de 27 bilhões continua sem teste publicado.

• Motores que exigem licença comercial são gratuitos?

Não necessariamente. A Glyd distribui o motor sob a Business Source License 1.1, com uso gratuito apenas para fins pessoais e não comerciais. Já o llama.cpp é software livre sob a licença MIT.

Source video