Este mecanismo open source afirma ser 2x mais rápido que o llama.cpp

Ver no idioma original →

Autoria: Better Stack · Assistir no YouTube

Vídeo de autoria do canal indicado, não da IANIA; todos os direitos pertencem ao criador. Transcrição, resumo e tradução gerados automaticamente; o conteúdo no idioma original é preservado na versão em idioma original.

Idioma original: inglês

Vídeo original: This Open-Source Engine Claims 2x Faster Than llama.cpp · Canal: Better Stack · 07:51 · Assistir no YouTube

Tópicos: Agentes de IA, Avaliação e benchmarks de IA, Ferramentas de desenvolvimento com IA, Inferência e otimização de modelos, Modelos locais e open source

Resumo

Magnitude é um mecanismo de inferência open source que testa diferentes configurações de kernels no hardware local e escolhe a mais rápida. O vídeo demonstra seu uso no Mac e destaca a integração simples com Claude Code por meio de APIs compatíveis com OpenAI e Anthropic. Embora um teste divulgado pela equipe mostre até 92% mais velocidade na geração de tokens, outros resultados variam conforme o hardware, a configuração e o benchmark. O apresentador considera a ferramenta promissora para agentes locais em Macs M1 a M4, mas recomenda cautela para uso em produção e, por enquanto, prefere MLX para quem usa M5 e prioriza velocidade bruta.

Pontos-chave

• Magnitude testa configurações de kernels diretamente no dispositivo e armazena a opção mais rápida para aquele hardware.
• O processo de ajuste leva cerca de um minuto, segundo a ferramenta.
• Prefill mede a velocidade de leitura do prompt; decode mede a velocidade de geração de tokens e costuma ser mais perceptível ao usar um agente de programação.
• Magnitude oferece APIs compatíveis com OpenAI e Anthropic, permitindo conectar Claude Code a modelos locais com poucos passos.
• O mecanismo foi desenvolvido em Rust e usa o compilador numérico seismic, com backends para CPU, Metal, CUDA e Vulkan.
• Um benchmark em M4 Pro mostrou aumento de 30 para 57 tokens por segundo no decode, mas apenas 9% de melhora no prefill.
• Testes independentes apresentaram resultados variados, incluindo casos em que llama.cpp ou Rapid MLX foram mais rápidos.
• A versão 0.2.5 tinha uma biblioteca de cerca de 15 modelos selecionados e o apresentador não encontrou documentação para carregar arquivos GGUF próprios.
• O apresentador vê potencial em Macs M1 a M4 para uso com agentes locais, mas recomenda esperar por mais comparações independentes antes de adotar Magnitude em produção.

Capítulos

Início	Capítulo	Resumo
00:00	Como Magnitude ajusta a inferência ao hardware	O vídeo apresenta a proposta do Magnitude: testar kernels no dispositivo local e selecionar a configuração mais rápida.
01:37	Teste prático e conexão com Claude Code	O apresentador compara a geração de tokens com llama.cpp e mostra como conectar Claude Code a um modelo local.
03:13	Arquitetura e foco em agentes	O vídeo descreve os componentes do Magnitude e suas otimizações para sessões de agentes e gerenciamento de modelos.
04:47	O que os benchmarks mostram — e o que não mostram	Os resultados variam entre prefill e decode, entre dispositivos e entre testes independentes.
06:18	Limitações e recomendações de uso	O apresentador comenta limitações da versão inicial e recomendações diferentes conforme o Mac e o uso pretendido.

Citações

Magnitude afirma que pode executar modelos locais até duas vezes mais rápido que o llama.cpp no Mac. — 00:00

Ele encontra a configuração mais rápida e armazena esse ajuste para o seu dispositivo. — 01:06

Claude Code agora está conversando com um modelo executado localmente no meu Mac, sem uma configuração complicada. — 02:41

Ser duas vezes mais rápido não significa que tudo seja duas vezes mais rápido. — 04:47

Seu mecanismo de inferência local não deveria ter que adivinhar qual hardware você está usando. Ele pode simplesmente medi-lo e se ajustar à máquina à sua frente. — 07:19

Conceitos e entidades

• Magnitude (ferramenta): Mecanismo de inferência local que ajusta configurações de kernels ao hardware do usuário.
• llama.cpp (repo): Projeto de inferência local usado no vídeo como referência de desempenho.
• Ollama (ferramenta): Ferramenta para executar modelos localmente, citada como exemplo de mecanismo que prioriza ampla compatibilidade de hardware.
• MLX (ferramenta): Framework de aprendizado de máquina para dispositivos Apple, usado como alternativa de inferência no vídeo.
• Claude Code (ferramenta): Ferramenta de programação que o apresentador conecta a um modelo local executado pelo Magnitude.
• Qwen (modelo): Família de modelos; o teste demonstrado usa um modelo Qwen 3.5 4B quantizado em Q8.
• seismic (ferramenta): Compilador numérico sobre o qual, segundo o vídeo, o mecanismo do Magnitude é construído.
• vLLM (ferramenta): Mecanismo de inferência descrito no vídeo como voltado a processamento em lotes em data centers.
• SGLang (ferramenta): Mecanismo de inferência descrito no vídeo como voltado a processamento em lotes em data centers.
• Better Stack (empresa): Canal responsável pelo vídeo sobre o Magnitude.

Tradução completa (pt-BR)

00:00 Magnitude é um novo mecanismo de inference open source que afirma conseguir executar modelos locais até duas vezes mais rápido que llama.cpp no Mac. E a maneira como faz isso é bem interessante. Em vez de usar os mesmos kernels pré-compilados em todas as máquinas, Magnitude testa diferentes configurações de kernel diretamente no seu hardware e mantém a mais rápida. Então, eu queria ver que diferença isso realmente faz e se vale a pena usar no lugar de llama.cpp ou MLX.

00:35 Certo. Então, qual é a ideia básica aqui? Bem, o problema que Magnitude está tentando resolver é que mecanismos como llama.cpp ou Ollama precisam funcionar em muitos tipos diferentes de hardware. Por isso, eles distribuem kernels pré-compilados que funcionam em uma ampla variedade de chips. Isso os torna portáveis, mas esses kernels não são necessariamente a versão mais rápida possível para a máquina que você está usando. Magnitude está abordando isso de um jeito um pouco diferente. Quando você baixa um modelo, ele testa diferentes configurações de kernel na sua máquina. Aqui está

01:06 o que ele faz de diferente. Seus kernels têm diferentes parâmetros que podem ser ajustados. Quando você baixa um modelo, Magnitude executa várias variações diretamente no seu hardware. Ele mede o tempo de cada uma, encontra a mais rápida e armazena essa configuração em cache para o seu dispositivo. E, segundo a empresa, leva cerca de um minuto. E essa parte parece ser verdade. A questão é se isso realmente faz diferença. Se você gosta de ferramentas de programação que aceleram seu workflow, não deixe de se inscrever. Temos vídeos novos o tempo todo. Certo. Agora, há dois números que precisamos acompanhar aqui. O prefill é a velocidade com que o mecanismo lê seu prompt. O

01:37 decode é a velocidade com que ele gera a resposta, um token de cada vez. E, se você fica ali assistindo a um agent de programação trabalhar, decode costuma ser o número que você realmente percebe. Então, vamos colocá-los para competir. Já baixei o aplicativo do repo deles no GitHub, e é assim que ele aparece ao vivo. Você chega à aba Discover, que é onde quer estar. Magnitude analisa o hardware deste Mac e recomenda um modelo que deve caber nele. Vou escolher Qwen 3.5 4B, o Q8. Vou clicar em baixar.

02:09 Agora, o que ele faz? Analisa a máquina, baixa o modelo e executa o processo de ajuste. Você também pode baixar outros modelos, desde que tenha espaço para eles, bem aqui no catálogo. Se voltarmos aqui, vou dar um tempo. A execução vai demorar. E, quando terminar, poderemos comparar. Fazendo uma comparação lado a lado rápida, tenho llama.cpp e Magnitude. O mesmo modelo, e vou dar a eles o mesmo prompt. llama.cpp está à esquerda, Magnitude está à direita. Acompanhe os tokens por segundo. E

02:41 seja qual for o resultado que obtivermos aqui, lembre-se dele, porque mais adiante os benchmarks independentes ficam bem mais confusos. Mas, antes de chegarmos lá, esta é justamente a parte de Magnitude de que eu gosto muito. Posso abrir Connections, clicar em Connect Code e reiniciá-lo. É só isso. E agora Claude Code está conversando com um modelo executado localmente no meu Mac, sem nenhuma configuração complicada. Magnitude faz isso expondo uma API compatível com OpenAI e uma API compatível com Anthropic no localhost. Então, com um clique, você pode conectá-lo ao Claude

03:13 Code, Codex, OpenCode, Klein Pi e outros. E isso mostra o que Magnitude está realmente tentando ser. Não é apenas mais um aplicativo de chat local. Ele foi feito em torno de agents. Por baixo, o mecanismo é escrito em Rust e funciona sobre um compilador numérico chamado Seismic. Ele tem backends para CPU, Metal, CUDA e Vulkan. E o lado dos agents recebe algumas otimizações específicas. Várias sessões de agent podem compartilhar seus caches de prompt. A memória pode crescer e diminuir conforme necessário. O cache KV, basicamente a

03:45 memória de curto prazo do modelo, é comprimido. E os modelos podem ser carregados quando você precisa deles e, depois, descarregados quando ficam inativos. Então, isso é bem legal. Eles não estão simplesmente dizendo: fizemos llama.cpp ficar mais rápido. A ideia é mais: ajustamos o mecanismo para o seu hardware específico e depois o otimizamos para agents de longa duração. E isso coloca o projeto numa posição bastante singular. llama.cpp e Ollama abrem mão de um pouco de velocidade para poder funcionar em praticamente qualquer lugar. vLLM e SGLang são projetados em torno do processamento em lotes em data centers. Os mecanismos MLX podem ser

04:16 extremamente rápidos, mas só funcionam em dispositivos Apple. Então, Magnitude é um pouco diferente. Mede a máquina específica em que você está executando, faz os ajustes para ela e é desenvolvido em torno de cargas de trabalho de agents. No papel, parece ótimo. Mas agora chegamos ao número que Magnitude está usando para provar isso: 2x. Porque é aqui que as coisas mudam. O teste original usou Qwen 3.6 35B A3B em 4 bits, com um context de 64.000 tokens, em um M4 Pro com 48 GB de memória. O decode passou de 30 tokens por segundo para 57. Isso é

04:47 uma melhora de 92%, quase 2x. De novo, parece ótimo. Mas o prefill, ou seja, a leitura do prompt, foi apenas 9% mais rápido. Então, logo de cara, ser 2x mais rápido não significa que tudo seja duas vezes mais rápido. E basta olhar para o próprio benchmark. Eles colaram Moby Dick no context, até chegar a 64.000 tokens, e pediram ao modelo para repetir a seção final. No DGX Spark da Nvidia, executando o mesmo teste, a melhora no decode caiu para

05:17 19%. Depois, há outra coisa. Os dois mecanismos não estavam configurados da mesma maneira. llama.cpp estava usando um cache KV completo de 16 bits, porque o caminho de cache comprimido apresentou problemas durante o teste. Magnitude comprime o cache por padrão. Depois, muitos usuários independentes começaram a testar, e é aí que os resultados ficam ainda menos claros. Em um M5 Max, uma pessoa conseguiu 175 tokens por segundo com Rapid MLX. Magnitude chegou a 161. Outro usuário constatou

05:48 que Llama CPP rodava duas vezes mais rápido que Magnitude em um M5 Max e em uma RTX 5070 TI. Alguém mediu Llama CPP como sendo cerca de 20 a 30% mais rápido, e agora temos Magnitude quase dobrando a velocidade de Llama CPP em um teste, mas ficando para trás em outro. Então, depende um pouco da máquina em que estamos executando. Agora, o fundador tem uma explicação, pelo menos para essa parte. Magnitude ainda não usa o novo hardware Metal Matrix do M5. Então, pelo que dizem, uma comparação oficial com MLX

06:18 está a caminho. Mais uma vez, ainda é muito cedo, como acontece com muitas dessas ferramentas. É a versão 0.2.5. Eles lançaram cinco versões em cerca de quatro dias, e o mecanismo inteiro foi reescrito em setembro. Neste momento, a biblioteca de modelos tem cerca de 15 modelos selecionados. Nada abaixo de 4 bits, e não consegui encontrar documentação para carregar seu próprio arquivo GGUF. Agora, algumas coisas irritantes. É necessário ter Mac OS 13 ou mais recente. Macs com Intel só funcionam na CPU.

06:49 Os modelos baixados ficam dentro de uma pasta oculta do Magnitude no seu diretório pessoal, e apagar o aplicativo não apaga esses modelos. Então, você vai precisar limpar essa pasta por conta própria ao excluir os modelos. E, se um modelo ficou inativo, a primeira resposta pode ser lenta porque Magnitude precisa carregá-lo de novo. Então, você vai instalar? Bem, se estiver usando um M1 até M4, executando agents de programação localmente e quiser uma interação bem simples, Magnitude é bem legal. Vamos ver até onde vai. Sinceramente, o botão Connect, a maneira como conectamos Claude Code,

07:19 talvez seja o motivo mais forte para instalá-lo. Se você está usando um M5 e só se importa com a velocidade bruta em tokens por segundo, por enquanto, fique com MLX. E, se está pensando em usar isso para algo relacionado à produção, eu esperaria por mais comparações independentes com MLX, porque ainda não chegamos lá. Depois de analisar tudo isso, não acho que a questão seja que às vezes é mais rápido e às vezes não. A ideia é bem mais simples. Seu mecanismo de inference local não deveria ter que adivinhar qual hardware você está usando. Ele pode simplesmente medi-lo e se ajustar à máquina que está bem na sua frente. Aqui é Josh, da Better

07:51 Staff. Se você gosta de dicas e truques de programação como este, não deixe de se inscrever. Até o próximo vídeo. >> [música]

Transcrição original

[00:00] Magnitude is a new open-source inference engine that claims it can run local models up to twice as fast as llama.cpp on Mac. And the way it does it is actually pretty cool. Instead of using the same pre-compiled kernels for every machine, Magnitude benchmarks different kernel configurations directly on your hardware and keeps the fastest one. So, I wanted to see how much of a difference this actually makes and whether this is actually worth using over llama.cpp or MLX.

[00:35] All right. So, what’s the basic thing here? Well, the problem Magnitude is solving is that engines like llama.cpp or Ollama need to run on a lot of different hardware. So, they ship pre-compiled kernels that work across a wide range of chips. That makes them portable, but those kernels aren’t necessarily the fastest possible version for the machine you’re actually using. Magnitude is approaching this a little bit differently. When you download a model, it tests different kernel configurations on your machine. Here’s

[01:06] really what it does differently. Its kernels have different knobs it can adjust. When you download a model, Magnitude runs a bunch of variations directly on your hardware. It times them. It finds the fastest one and it caches that setup for your device. And according to it, right, it takes around a minute. And that part appears to be real. The question is whether it can actually make a difference. If you enjoy coding tools that speed up your workflow, be sure to subscribe. We have videos coming out all the time. All right. Now, there are two numbers we need to watch here. Pre-fill is how

[01:37] quickly the engine reads your prompt. Decode is how quickly it generates the response one token at a time. And if you’re sitting there watching a coding agent work, decode is usually the number you actually feel. So, let’s race it. So, I’ve already downloaded the app from their GitHub repo and this is what it looks like live. You’re brought to the discover tab, which is where you want to be. Magnitude looks at the hardware in this Mac and recommends model that should fit. I’m going to grab Quinn 3.5 4B the Q8. I’m going to hit download.

[02:09] Now, what does it do? It assesses the machine, it downloads the model, and it runs that tuning process. You can also download other models, too, as long as you have the space for them just here on the catalog. If we jump back here, I’m going to give it some time. It’s going to take time to run. And once it’s finished, we can actually compare it. Now, doing a quick side-by-side here, I have llama.cpp and magnitude. The same model, I’m going to give it the same prompt. llama.cpp is on the left, magnitude is on the right. Watch the tokens per second. And

[02:41] whatever result we get here, keep it in mind because later the independent benchmarks get a lot messier. But before we get there, this is actually the part of magnitude that I really like. I can open connections, I can click connect Code, and I can restart it. That’s really it. And Claude Code is now talking to a model running locally on my Mac with no complicated setup. Magnitude does that by exposing both the OpenAI compatible API and the Anthropic compatible API on localhost. So, with one click, you can hook it into Claude

[03:13] Code, Code X Open Code Klein Pi, and more. And that tells you what magnitude is really trying to be. This is not just another local chat app. It’s built around agents. Under this, the engine is written in a rust and sits on a numerical compiler they call seismic. It has backends for CPU, metal, CUDA, and Vulcan. And the agent side gets a few specific optimizations. Multiple agent sessions can share their prompt caches. Memory can grow and shrink as needed. The KV cache, basically the model’s

[03:45] short-term memory, gets compressed. And models can load when you need them, then unload when they sit idle. So, this is pretty cool. They’re not just saying we made llama.cpp faster, this is rather more we tune the engine for your exact hardware, then optimize it around long-running agents. And that puts this in a rather unique position. llama.cpp in Ollama trade some speed for the ability to run almost everywhere. vLLM and SGLang are designed around data center batching. MLX engines can be

[04:16] extremely fast, but they’re Apple only. So, Magnitude is a bit different. Measure the exact machine you’re running on, tune for it, and build around agent workloads. On paper, this sounds great. But now we get to the number Magnitude is using to prove it, the 2x. Because this is where things change. The original test used Qwen 3.6 35B A3B at 4-bit with a 64,000 of context on an M4 Pro with 48 gigs of memory, decode went from 30 tokens per second to 57. That’s

[04:47] a 92% improvement, which is almost 2x. Now, again, that sounds good. But prefill, actually reading the prompt, was only 9% faster. So, right away, 2x faster does not mean everything is twice as fast. And just look at the benchmark itself. They pasted Moby Dick into the context up to 64,000 tokens and asked the model to repeat the final section. On Nvidia’s DGX Spark running that same test, the decode improvement dropped to

[05:17] 19%. Then, there’s another thing. The two engines weren’t configured the same way. llama.cpp was using a full 16-bit KV cache because its compressed cache path broke during their test. Magnitude compresses its cache by default. Then a lot of independent users started testing it, and this is where things get even less clean. On an M5 Max, one person got 175 tokens per second with Rapid MLX. Magnitude got 161. Another user found

[05:48] Llama CPP running twice as fast as Magnitude on an M5 Max and on an RTX 5070 TI. Someone measured Llama CPP around 20 to 30% faster and now we have Magnitude almost doubling Llama CPP in one test while losing it in another. So, it kind of depends on what machine we’re running this on. Now, the founder has an explanation, at least for this part. Magnitude doesn’t use the M5’s new Metal Matrix hardware yet. So, apparently, they say an official MLX comparison is

[06:18] coming soon. Now, again, this is extremely early as with a lot of these tools. It’s version 0.2.5. They shipped five releases in about four days and the entire engine was rewritten in September. Right now, the model library is about 15 curated models. Nothing below 4-bit and I couldn’t actually find docs for loading your own GGUF file. Now, a few annoyances here. There are things like Mac OS 13 or newer. Intel Macs only run on CPU.

[06:49] Downloaded models live inside a hidden Magnitude folder in your home directory and deleting the app does not delete those models. So, you’ll need to clean that folder up yourself as you delete the models. And if a model has been idle, the first response can be slow because Magnitude has to load it again. So, are you going to install this? Well, if you’re running on an M1 through M4, you run coding agents locally and you want a really simple back and forth um Magnitude is pretty cool. We’ll see where it goes. Honestly, the connect button, how we connect Claude code,

[07:19] might be the strongest reason to install it. If you’re on an M5 and all you care about is raw tokens per second, just stay on MLX for now. And if you’re thinking about using this for anything production-related, I’d wait for more independent MLX comparisons cuz we’re not quite there yet. Because after digging through all of this, I don’t think sometimes it’s faster, sometimes it isn’t. The idea is a lot simpler. Your local inference engine shouldn’t have to guess what hardware you’re running. It can just measure it and tune itself around the machine sitting in front of you. I’m Josh from Better

[07:51] Staff. If you enjoy coding tips and tricks like this, be sure to subscribe. We’ll see you in another video. >> [music]