Principais conclusões
- Gratuito e de código aberto sob licença MIT, mantido pela ggml-org no GitHub
- Escrito em C/C++, construído sobre a biblioteca de tensores ggml
- Definiu o formato de arquivo de modelo GGUF (.gguf) usado em todo o ecossistema de IA local
- Backends de hardware: CUDA, Metal, Vulkan, ROCm/HIP, SYCL e CPU (AVX/AVX2/AVX512)
- Suporte a quantização de 8 bits até aproximadamente 1,5 bit por peso
- Traz o llama-server, um servidor HTTP compatível com a OpenAI embutido com interface web
- O Ollama usa o llama.cpp como mecanismo de inferência na maioria das plataformas, adicionando um registro de modelos e uma CLI
- Sem instalador gráfico — usado via linha de comando, interface web embutida ou bindings de linguagem
📍 Em uma frase
O llama.cpp é um mecanismo de inferência C/C++ gratuito e com licença MIT criado por Georgi Gerganov, que executa LLMs localmente em CPU ou GPU, definiu o formato de modelo GGUF, e serve como backend de inferência sobre o qual várias ferramentas de IA local se apoiam, incluindo o Ollama na maioria das plataformas.
💬 Em termos simples
Em vez de um app de um clique, o llama.cpp é o próprio código do mecanismo que carrega um arquivo de modelo e gera texto — o Ollama e vários outros apps de IA local rodam o llama.cpp por baixo e colocam uma interface mais amigável por cima.
📌Nota: Este artigo é baseado no repositório oficial no GitHub do llama.cpp e em documentação pública, não em benchmarks independentes. Números específicos de tokens por segundo não são incluídos porque não foram medidos de forma independente para este artigo e variam bastante conforme o hardware, o modelo e o formato de quantização.
O que é o llama.cpp?
O llama.cpp é um mecanismo de inferência gratuito e com licença MIT, escrito em C/C++, que executa modelos de linguagem grandes localmente com dependências externas mínimas. Foi criado por Georgi Gerganov em 2023 como um port em C/C++ feito do zero do código de inferência LLaMA da Meta, projetado para rodar em hardware de consumo comum — incluindo máquinas somente com CPU — em vez de exigir uma GPU de data center. O projeto é hoje mantido pela organização ggml-org no GitHub, com contribuições de uma grande comunidade de código aberto, e cresceu para suportar modelos de visão e linguagem além de LLMs somente de texto.
- Criado por Georgi Gerganov, hoje mantido pela organização ggml-org
- Escrito em C/C++, construído sobre o ggml, uma biblioteca de tensores mantida pela mesma equipe
- Licença MIT: o código-fonte está publicamente disponível para uso, modificação e redistribuição sob os termos da licença
- Roda tanto em hardware somente com CPU quanto em GPUs, ao contrário de mecanismos que exigem obrigatoriamente uma GPU compatível com CUDA
- Definiu o formato GGUF, um formato de arquivo único que armazena juntos os pesos do modelo, dados de quantização e metadados
- Um dos projetos de inferência de LLM de código aberto mais referenciados, com bem mais de 100 mil estrelas no GitHub
Que aceleração de hardware o llama.cpp suporta?
O llama.cpp suporta uma ampla variedade de backends de aceleração de hardware, uma das razões pelas quais roda desde um notebook somente com CPU até uma estação de trabalho com múltiplas GPUs.
CUDA
- Detalhes:
- Para GPUs NVIDIA. Descarrega camadas do modelo para a memória da GPU, resultando em inferência mais rápida que somente com CPU, com suporte a configurações multi-GPU.
Metal
- Detalhes:
- Para Macs com Apple Silicon (M1 e posteriores). Usa a API Metal da Apple para executar a inferência nos núcleos de GPU dos chips série M.
Vulkan
- Detalhes:
- Uma API de GPU multifabricante suportada no Windows e Linux, utilizável em GPUs de vários fabricantes sem um SDK específico de fornecedor.
ROCm / HIP
- Detalhes:
- Para GPUs AMD, via pilha de computação ROCm da AMD, como alternativa a uma aceleração limitada a CUDA.
SYCL
- Detalhes:
- Para GPUs Intel, incluindo gráficos integrados de algumas CPUs Intel, via implementação oneAPI SYCL da Intel.
CPU (AVX / AVX2 / AVX512)
- Detalhes:
- Execução otimizada somente em CPU usando instruções vetorizadas em processadores x86 modernos — o caminho de fallback que permite rodar o llama.cpp sem nenhuma GPU.
O projeto também documenta backends adicionais e experimentais (incluindo BLAS, CANN e WebGPU) em sua documentação de build no GitHub; esta seção foca nos backends entre os quais a maioria dos usuários de LLM local realmente escolhe.
O que é o GGUF, e qual formato de quantização usar?
O GGUF é o formato de arquivo de modelo que o llama.cpp definiu para armazenar os pesos de um modelo quantizado junto com os metadados necessários para executá-lo (tokenizador, arquitetura, tamanho de contexto), substituindo o antigo formato GGML do projeto. A quantização reduz o consumo de memória de um modelo armazenando seus pesos com precisão numérica menor do que o formato de treinamento original, trocando parte da qualidade de saída por menor uso de VRAM/RAM e inferência mais rápida.
Q8_0
- Detalhes:
- Quantização de 8 bits, o mais próximo do modelo original não quantizado entre os formatos comuns do llama.cpp, com o maior tamanho de arquivo do grupo.
Q5_K_M
- Detalhes:
- Um formato "K-quant" de 5 bits que distribui a precisão de forma desigual entre as camadas do modelo, priorizando qualidade em vez do menor tamanho de arquivo possível.
Q4_K_M
- Detalhes:
- Um formato K-quant de 4 bits usado comumente como ponto de equilíbrio entre tamanho de arquivo e qualidade de saída — uma recomendação padrão frequente quando a VRAM é limitada.
Abaixo de 4 bits (Q3, Q2 e formatos ~1,5 bit)
- Detalhes:
- Formatos para encaixar modelos maiores em memória muito limitada. A perda de qualidade fica mais perceptível conforme a largura de bits diminui, então costumam ser um último recurso, não uma escolha padrão.
O formato certo depende do seu hardware e do modelo específico — este artigo não inclui percentuais de perda de qualidade medidos de forma independente para formatos específicos, pois eles variam conforme a arquitetura do modelo e a tarefa. Baixar um modelo em mais de um formato de quantização e comparar as saídas com seus próprios prompts é a forma mais confiável de avaliar essa troca para o seu caso de uso.
O que o llama-server oferece?
O llama-server é o binário de servidor HTTP que acompanha o llama.cpp. Um único binário expõe a API nativa própria do llama.cpp, uma API compatível com a OpenAI, uma camada de compatibilidade com a API do Ollama, e uma interface de chat embutida baseada em navegador, tudo apoiado no mesmo modelo carregado e no mesmo cache.
- Endpoints compatíveis com a OpenAI sob /v1, de forma que ferramentas já feitas para a API da OpenAI muitas vezes só precisam mudar a URL base para apontar para uma instância local do llama-server
- Uma interface web embutida servida diretamente pelo binário, utilizável sem instalar um front-end separado
- Uma camada de compatibilidade com a API do Ollama, permitindo que algumas ferramentas cliente voltadas ao Ollama se conectem ao llama-server em vez disso
- Endpoints de introspecção como /props e /slots para inspecionar o estado do servidor e das requisições
- Suporte a múltiplos "slots" de requisições simultâneas sobre um mesmo modelo carregado, em vez de uma requisição por vez
Como compilar e executar o llama.cpp?
O llama.cpp normalmente é compilado a partir do código-fonte com CMake, embora o projeto também publique binários pré-compilados para várias plataformas em sua página de releases no GitHub, caso você prefira não compilar você mesmo.
- 1Instale uma toolchain C++ e o CMake para o seu sistema operacional, caso ainda não tenha.
- 2Clone o repositório:
git clone https://github.com/ggml-org/llama.cpp. - 3Configure a build para o seu backend de hardware — por exemplo, ativando suporte a CUDA, Metal ou Vulkan como opção do CMake, ou deixando apenas em CPU.
- 4Compile o projeto com o CMake:
cmake -B build, seguido decmake --build build --config Release. - 5Baixe um modelo no formato GGUF, por exemplo do Hugging Face, escolhendo um formato de quantização adequado à sua VRAM ou RAM disponível.
- 6Execute o modelo pela linha de comando com o binário
llama-clipara um chat direto no terminal, ou inicie ollama-serverpara expor uma API HTTP compatível com a OpenAI e uma interface web. - 7Se usar o llama-server, conecte-se pelo navegador ao seu endereço local, ou aponte qualquer cliente compatível com a API da OpenAI para o endpoint
/v1.
Preciso compilar o llama.cpp a partir do código-fonte?
Não — o projeto também publica binários pré-compilados em sua página de releases no GitHub para várias plataformas, embora compilar a partir do código-fonte permita ativar exatamente o backend de hardware (CUDA, Metal, Vulkan e similares) para a sua máquina.
Onde consigo modelos GGUF para executar?
Muitos modelos no formato GGUF são publicados no Hugging Face e em outros sites de compartilhamento de modelos, geralmente em vários formatos de quantização por modelo, para que você possa escolher um adequado à sua memória disponível.
Qual a relação entre o llama.cpp e o Ollama?
O Ollama é uma das formas mais usadas de rodar LLMs locais sem mexer em um sistema de build, e diversos artigos técnicos de comunidade e de terceiros descrevem que ele usa o llama.cpp como mecanismo de inferência subjacente na maioria das plataformas. O próprio Ollama não documenta essa dependência em detalhe, então é melhor tratá-la como a arquitetura amplamente relatada, e não como uma especificação oficial, embora seja consistente com o próprio código aberto do Ollama.
- O llama.cpp é o mecanismo de inferência de baixo nível; o Ollama é uma camada de empacotamento que adiciona um registro de modelos, downloads em um comando só, uma CLI mais simples e seu próprio sistema de configuração Modelfile
- Escolher o llama.cpp diretamente dá controle sobre flags de compilação exatas, formato de quantização e configuração de servidor que a interface simplificada do Ollama não expõe
- Escolher o Ollama troca esse controle por um caminho mais rápido até um modelo funcionando, ao custo de alguma flexibilidade sobre como o mecanismo subjacente é configurado
- Ambos podem servir uma API compatível com a OpenAI — o llama.cpp via llama-server, o Ollama via sua própria camada de API
Para quem o llama.cpp direto é indicado?
O llama.cpp é indicado para quem quer controle direto sobre como um modelo é executado, em vez do caminho mais rápido até uma janela de chat funcionando.
llama.cpp vs. Ollama vs. LM Studio vs. vLLM
Essas quatro ferramentas ficam em pontos diferentes do espectro entre controle e comodidade, e duas delas (Ollama e, no Apple Silicon, parte do ecossistema em torno do LM Studio) são elas mesmas construídas sobre mecanismos de inferência, em vez de serem alternativas criadas do zero a um deles.
llama.cpp
- Interface e configuração:
- CLI, interface web embutida e API compatível com a OpenAI via llama-server. Compilação a partir do código-fonte com CMake ou uso de binário de release pré-compilado; você escolhe o formato de quantização.
- Melhor para:
- Controle máximo, deployment embarcado/edge e pipelines personalizados construídos diretamente sobre o mecanismo.
Ollama
- Interface e configuração:
- CLI e API REST, comumente descrita como rodando sobre o llama.cpp como backend na maioria das plataformas. Um comando instala; um comando baixa e executa um modelo.
- Melhor para:
- O caminho mais rápido até um modelo local funcionando sem etapa de build, para quem não precisa de configuração no nível do mecanismo.
LM Studio
- Interface e configuração:
- App de desktop gráfico para Mac, Windows e Linux. Baixar, instalar e depois navegar e baixar um modelo de dentro do app.
- Melhor para:
- Usuários não técnicos que querem um app de chat de um clique em vez de uma linha de comando.
vLLM
- Interface e configuração:
- Servidor Python com API compatível com a OpenAI, instalado via pip em um ambiente Python/CUDA. Usa seu próprio mecanismo de serving PagedAttention, em vez de GGUF ou llama.cpp.
- Melhor para:
- Serving de GPU de alto throughput e multiusuário em produção, não chat local de um único usuário.
Este artigo não fez benchmark independente de velocidade ou qualidade de saída entre essas quatro ferramentas e não afirma que uma seja tecnicamente superior — a comparação acima cobre apenas fatos documentados de arquitetura, configuração e modelo de acesso. Para números de throughput por hardware, veja a comparação dedicada llama.cpp vs. Ollama vs. vLLM e o guia de servidores de inferência empresariais, que trata o vLLM com mais profundidade.
O que este artigo não cobre?
Este é um artigo explicativo elaborado a partir da documentação pública e do repositório do llama.cpp, não um relatório prático de benchmarks.
- Nenhum número de tokens por segundo ou latência medido de forma independente — o throughput depende muito do seu hardware específico, modelo, formato de quantização e flags de compilação
- Nenhum percentual de perda de qualidade verificado de forma independente para formatos de quantização específicos — eles variam conforme a arquitetura do modelo e a tarefa
- Nenhuma auditoria de segurança linha por linha da base de código do llama.cpp — ele é de código aberto e licença MIT, então o próprio código está disponível para revisão
- Nenhuma cobertura de todos os backends ou flags de compilação suportados pelo llama.cpp — este artigo foca nos backends e formatos entre os quais a maioria dos usuários de LLM local escolhe
- Nenhuma cobertura de acordos de suporte comercial, já que o llama.cpp é um projeto de código aberto comunitário, não um produto de fornecedor com contrato de suporte
Erros comuns ao experimentar o llama.cpp
A maior parte do atrito com o llama.cpp vem de tratá-lo como um app para o consumidor, em vez de um mecanismo que você mesmo precisa construir.
Perguntas frequentes
O que é o llama.cpp?
O llama.cpp é um mecanismo de inferência C/C++ gratuito e com licença MIT criado por Georgi Gerganov, que executa modelos de linguagem grandes localmente em CPU ou GPU. É mantido pela organização ggml-org no GitHub.
O llama.cpp é gratuito?
Sim. O llama.cpp é um software gratuito e de código aberto lançado sob a licença MIT, sem necessidade de assinatura ou conta.
O que é o GGUF?
O GGUF é o formato de arquivo de modelo que o llama.cpp definiu para armazenar os pesos quantizados de um modelo junto com os metadados necessários para executá-lo, como o tokenizador e detalhes de arquitetura. É usado em boa parte do ecossistema de IA local, não só pelo próprio llama.cpp.
O Ollama usa o llama.cpp?
Diversos artigos técnicos de comunidade e de terceiros descrevem que o Ollama usa o llama.cpp como mecanismo de inferência na maioria das plataformas, adicionando por cima seu próprio registro de modelos, CLI e sistema Modelfile. O próprio Ollama não documenta essa dependência em detalhe.
Que hardware o llama.cpp suporta?
O llama.cpp suporta execução somente em CPU (com otimizações AVX/AVX2/AVX512), além de aceleração por GPU via CUDA (NVIDIA), Metal (Apple Silicon), Vulkan, ROCm/HIP (AMD) e SYCL (Intel).
Que formatos de quantização o llama.cpp suporta?
O llama.cpp suporta quantização desde formatos de 8 bits como o Q8_0 até formatos de aproximadamente 1,5 bit, com formatos intermediários muito usados como Q5_K_M e Q4_K_M equilibrando tamanho de arquivo e qualidade de saída.
Preciso saber C++ para usar o llama.cpp?
Não — executar modelos pelos binários llama-cli ou llama-server não exige escrever código. Compilar o projeto a partir do código-fonte exige uma toolchain C++ e o CMake, mas não escrever C++ você mesmo, a menos que queira modificar o mecanismo.
O llama.cpp tem interface gráfica?
O llama-server inclui uma interface web embutida baseada em navegador, mas não há um instalador gráfico separado nem um app de desktop comparável ao LM Studio. Vários apps de terceiros, incluindo front-ends compatíveis com Ollama e com a API da OpenAI, podem se conectar ao llama-server em vez disso.
O llama.cpp é melhor que o Ollama?
"Melhor" depende do que você precisa: o llama.cpp dá controle mais direto sobre flags de compilação, quantização e configuração de servidor, enquanto o Ollama oferece um caminho mais rápido e simples até um modelo funcionando. Este artigo não afirma que um seja tecnicamente superior; veja a tabela comparativa acima e a comparação de benchmark dedicada para mais detalhes.
O llama.cpp pode rodar sem GPU?
Sim. O llama.cpp foi projetado para rodar em hardware somente com CPU usando instruções vetorizadas (AVX/AVX2/AVX512), além de suportar aceleração por GPU quando disponível.