O que é GGUF e qual quantização baixar: Q4_K_M, Q8_0 e IQ3 explicados

O que é GGUF? É o formato de arquivo que guarda um modelo de IA inteiro, pronto para rodar no seu computador: os “pesos” do modelo, o dicionário de palavras (tokenizador) e as informações de como ele funciona, tudo num arquivo só. Ele foi criado pela comunidade do llama.cpp, e é o que o LM Studio, o Ollama e o próprio llama.cpp abrem por baixo dos panos. Quando você vai baixar um modelo e aparece uma lista de arquivos com nomes como Q4_K_M, Q8_0 e IQ3_XXS, todos são GGUF; o que muda entre eles é a quantização, ou seja, quanto o modelo foi comprimido.

A dúvida que trava quase todo mundo na primeira vez é justamente essa: qual dos arquivos baixar. Neste guia eu explico o que é um arquivo GGUF, o que significa cada sigla, quanto cada nível de compressão ocupa e o que perde, e como escolher o certo para a sua placa de vídeo. Tudo com números que já medimos na bancada do Laboratório de IA, onde já passaram 22 modelos, e com um teste novo: o mesmo modelo medido em 5 quantizações diferentes.

O que é GGUF, em poucas palavras

GGUF é um formato binário feito para carregar e rodar modelos de linguagem de forma rápida em computador comum. Quem criou foi Georgi Gerganov, o desenvolvedor do llama.cpp, e ele substituiu em 2023 o formato anterior, o GGML. A grande diferença para formatos como o safetensors, que guardam só os números do modelo, é que o GGUF leva junto os metadados: arquitetura, tamanho de contexto, tokenizador e o modelo de conversa. Por isso basta um arquivo para o programa saber como usar o modelo.

O que é quantização (e por que ela decide o que cabe no seu PC)

Quantização é guardar cada peso do modelo com menos bits. Pense numa música: o arquivo do estúdio é enorme, um MP3 de 320 kbps já é bem menor e quase ninguém percebe diferença, e um de 64 kbps cabe em qualquer lugar, mas o som fica abafado. Com o modelo é igual: a versão original usa 16 bits por peso; a de 4 bits ocupa quase um quarto e perde muito pouco; a de 2 bits cabe numa placa pequena, mas começa a errar mais.

Isso importa porque, para rodar rápido, o modelo inteiro precisa caber na memória da placa de vídeo (a VRAM). O Qwen3.8 27B completo tem 54 GB e não cabe em nenhuma placa de casa; em 4 bits ele cai para 17,6 GB e roda nas nossas duas placas somadas; em 3 bits, 10,9 GB, cabe numa só.

Como ler o nome do arquivo GGUF: Q4_K_M, Q8_0, IQ3_XXS

O nome parece código, mas segue uma lógica simples. O número depois do Q é quantos bits sobram, em média, para cada peso. O resto diz qual método foi usado.

Tamanho de cada quantização: a conta que bate com os arquivos reais

Dá para estimar o tamanho de qualquer GGUF antes de baixar: número de parâmetros vezes bits por peso, dividido por 8. A tabela abaixo usa os bits por peso publicados pelo Hugging Face para três tamanhos comuns de modelo. Na nossa bancada, a conta bateu com os arquivos de verdade: o Qwen3.8 27B em IQ3_XXS tem 10,9 GB (a conta dá 10,3) e o Saluki, um 27B de 2 bits do tipo IQ2, tem 7,89 GB (a conta dá 7,8). A diferença é a parte do modelo que fica sempre com mais bits.

O que perde ao comprimir: o que a nossa bancada já mediu

Comprimir é trocar qualidade por espaço e, muitas vezes, por velocidade. Nos nossos testes, o padrão se repetiu: em 4 bits a perda é pequena; abaixo de 3 bits o modelo continua funcionando, mas erra mais, principalmente quando precisa de raciocínio longo ou de escrever um programa inteiro.

Testes de fora apontam na mesma direção. Um estudo da Quesma com o Qwen3.8 27B mostrou que a versão de 4 bits empata com o modelo completo num teste de agente de programação, a de 2 bits funciona “até certo ponto” e a de 1 bit desaba. E no teste independente do Saluki, um 27B de 2 bits ajustado para agentes, ele resolveu 76,7% dos problemas de código, contra 91,7% da versão de 2 bits de onde saiu. Os detalhes estão no nosso artigo do Qwen3.8 27B em Q2 e no teste do Qwen3.8-Flash-Next com o Strata.

Medimos: o mesmo modelo em 5 quantizações

Atualização de 20/10/2026. Faltava uma resposta direta para a pergunta “comprimir deixa o modelo pior?”, com o resto todo igual. Então pegamos o Qwen3.5 4B, do mesmo repositório da Unsloth, em cinco versões: o original sem compressão (BF16, 8,4 GB), Q8_0, Q6_K, Q4_K_M e Q3_K_M. Todas rodaram na mesma placa (só a RX 9070 XT), com o mesmo programa (llama.cpp b10615), a mesma memória de conversa (160 mil tokens) e os mesmos 11 testes do Laboratório. Só o arquivo mudou.

Medimos de dois jeitos. O primeiro é uma régua objetiva: cada versão leu o mesmo texto de cerca de 51 mil palavras, e conferimos em quantas delas ela escolheu uma palavra diferente da que o original escolheria (a chamada divergência KL, a medida que a própria comunidade do llama.cpp usa para comparar quantizações). O segundo é o uso de verdade: a tarefa de agente (escrever e testar um leitor de planilhas CSV sozinho), os 4 jogos feitos com ferramentas, os 4 jogos sem ferramentas e as duas páginas, PULSE e NEXUS.

A régua objetiva mostra onde está a quebra. O Q8_0 e o Q6_K ficam praticamente colados no original: menos de 4 palavras diferentes em cada 100. No Q4_K_M a diferença dobra, e no Q3_K_M ela chega a 13 em cada 100. A perplexidade (o quanto o modelo “estranha” um texto real) conta a mesma história: sobe 0,1% no Q8_0, 0,6% no Q6_K, 1,4% no Q4_K_M e 5,4% no Q3_K_M.

Nas tarefas, a perda apareceu onde o trabalho é mais exigente. Na tarefa de agente, os casos difíceis certos caíram junto com os bits: 4 no original, 3 no Q8_0, 2 no Q6_K, 1 no Q4_K_M e nenhum no Q3_K_M. Sem ferramentas, o Q3_K_M foi o único que quebrou um teste: no CORREDOR 3D ele escreveu até bater no limite de texto e entregou um jogo que não funciona (nota 2). Já nos 4 jogos feitos com ferramentas, todas as versões ficaram na mesma faixa de problemas graves (de 13 a 16 somando os quatro), e com uma execução só essa diferença está dentro da variação normal.

Resumindo o que medimos: neste modelo de 4B, até 6 bits a compressão é quase invisível; em 4 bits ela já aparece na régua e na tarefa de agente; em 3 bits aparece em quase tudo. Modelos pequenos costumam sentir a compressão mais que os grandes, por isso o mesmo Q4_K_M num 27B tende a perder menos, como o estudo da Quesma mostrou. E como o Q8_0 do 4B ocupa só 4,5 GB e foi a versão com melhor resultado geral, ele passou a ser o Qwen3.5 4B do nosso Laboratório, no lugar do Q6_K.

Qual quantização escolher para a sua placa de vídeo

A regra que usamos na bancada é simples: o arquivo, mais o contexto (a “memória da conversa”), mais a parte da VRAM que o Windows e o monitor já usam (aqui, cerca de 1,3 GB) precisam caber na placa. Se cabe, roda rápido. Se não cabe, parte vai para a RAM e a velocidade despenca.

Na dúvida, comece pelo Q4_K_M: é o padrão da maioria dos repositórios e o que o Ollama baixa por padrão em muitos modelos. Se sobrar memória, suba para Q5_K_M ou Q6_K. Em modelo grande, o Q8_0 raramente compensa o dobro de espaço; em modelo pequeno, que cabe com sobra, vale: no nosso teste com o Qwen3.5 4B, o Q8_0 ocupou 4,5 GB e foi a versão mais forte. E se o modelo que você quer não cabe nem em 3 bits, quase sempre vale mais um modelo menor em 4 bits do que um maior espremido em 2. Para escolher a placa em si, o nosso guia de quanta VRAM você precisa para IA local vai mais fundo.

Onde baixar GGUF e como usar no LM Studio e no Ollama

No Hugging Face, dá para filtrar só modelos com arquivos GGUF (filtro “GGUF” na busca de modelos). Os repositórios das equipes oficiais e de quantizadores conhecidos, como Unsloth e bartowski, listam todas as versões lado a lado, com o tamanho de cada arquivo. O Hugging Face ainda mostra, na página do arquivo, os metadados e o tipo de cada camada.

• LM Studio: ao buscar um modelo, ele mostra as quantizações disponíveis e avisa quais cabem na sua placa. Escolha e baixe pela própria interface.
• Ollama: a quantização vem no “tag” do modelo; quando há opção, ela aparece no nome (por exemplo, terminando em q4_K_M ou q8_0). Também dá para importar um GGUF baixado do Hugging Face.
• llama.cpp: é só apontar para o arquivo, com llama-server -m modelo-Q4_K_M.gguf.

Se você ainda não instalou nada, o nosso passo a passo de como rodar IA localmente no PC leva 15 minutos e já baixa o primeiro GGUF certo para a sua máquina.

Minha opinião

Quem nunca baixou o arquivo maior “porque deve ser melhor” e depois ficou olhando o modelo escrever uma palavra por segundo? A quantização é a configuração mais importante da IA local e a que menos gente explica, e o motivo é que a resposta honesta é “depende”. Depois de 20 modelos na bancada, a minha regra ficou curta: primeiro garanta que cabe inteiro na placa, depois escolha o maior número de bits que ainda cabe. Velocidade que some porque o modelo transbordou para a RAM é um defeito que você não vê na lista de arquivos, só sente na hora de usar. E desconfie de quem promete “2 bits sem perda”: nos nossos testes, perda sempre houve; o que muda é se ela importa para a tarefa que você tem.

Perguntas frequentes

O que é um arquivo GGUF?

É um arquivo único que guarda um modelo de IA com os pesos, o tokenizador e os metadados, pronto para rodar no computador com llama.cpp, LM Studio ou Ollama. Ele foi criado pelo desenvolvedor do llama.cpp e substituiu o formato GGML em 2023.

Qual a melhor quantização GGUF?

Para a maioria das pessoas, Q4_K_M: perde pouco e ocupa cerca de um quarto do modelo original. Se sobrar memória na placa, Q5_K_M ou Q6_K. Abaixo de 3 bits, só para fazer caber um modelo que não caberia de outro jeito.

Q4_K_M ou Q8_0: qual baixar?

O Q8_0 é quase idêntico ao original, mas ocupa quase o dobro do Q4_K_M. Se o Q8_0 cabe na sua placa com folga para o contexto, pode usar; se não cabe, o Q4_K_M entrega quase a mesma qualidade e roda inteiro na VRAM, o que costuma ser muito mais rápido. No nosso teste com um modelo de 4B, o Q4_K_M escolheu palavra diferente do original em 7,5% dos casos, contra 2,6% do Q8_0, e acertou menos na tarefa de agente.

O Ollama usa GGUF?

Sim. O Ollama roda modelos no formato GGUF, e a quantização aparece no nome (tag) do modelo. Também é possível importar um arquivo GGUF baixado do Hugging Face.

Qual a diferença entre GGUF e safetensors?

O safetensors guarda só os pesos do modelo e é usado para treinar e ajustar. O GGUF guarda os pesos já quantizados junto com os metadados e o tokenizador, pensado para rodar o modelo em casa.

Qual quantização você usa no dia a dia? Já se arrependeu de baixar o arquivo errado? Conta aqui nos comentários.

Para receber os testes de modelos que rodam no seu PC, inscreva-se na newsletter do TechDescomplicado. É grátis, e as análises chegam direto no seu e-mail.

Resumo

• GGUF é o formato de arquivo único usado para rodar modelos de IA em casa (llama.cpp, LM Studio, Ollama).
• O nome do arquivo (Q4_K_M, Q8_0, IQ3_XXS) diz quantos bits sobram por peso e qual método de compressão foi usado.
• Tamanho estimado = parâmetros × bits por peso ÷ 8; um 27B vai de 54 GB (original) a 15 GB (Q4_K_M).
• Na nossa bancada, 3 bits fizeram 4 de 4 programas sem problema; 1 bit, só 1 de 4.
• O mesmo Qwen3.5 4B em 5 versões: Q8_0 e Q6_K quase iguais ao original; a perda aparece no Q4_K_M e cresce no Q3_K_M.
• Regra prática: o arquivo e o contexto precisam caber na VRAM; na dúvida, Q4_K_M.

Fontes

• Hugging Face: GGUF (documentação e tabela de tipos de quantização)
• GitHub ggml: especificação do formato GGUF
• GitHub llama.cpp: pull request que criou os k-quants
• Quesma: Qwen3.8 27B quantizations benchmarked
• IBM Think: GGUF versus GGML
• GitHub llama.cpp: llama-perplexity e divergência KL (como comparar quantizações)