Principais conclusões
- Licença MIT, criado por um desenvolvedor conhecido como turboderp
- Cerca de 4.600 estrelas no GitHub; o repositório em github.com/turboderp-org/exllamav2 está marcado como arquivado
- Formato de quantização EXL2: mistura precisão de 2, 3, 4, 5, 6 e 8 bits por camada para atingir uma taxa de bits média-alvo, por exemplo, executando um modelo de 70B em 24 GB de VRAM a cerca de 2,55 bits por peso
- O projeto sucessor ExLlamaV3 (cerca de 1.300 estrelas no GitHub) introduz o formato EXL3, uma variante simplificada da abordagem de quantização QTIP da Cornell RelaxML
- O TabbyAPI, um servidor baseado em FastAPI, é a camada de API compatível com OpenAI recomendada para ambas as versões
- Também integrado ao text-generation-webui, lollms-webui e à interface web independente ExUI
📍 Em uma frase
O ExLlamaV2 é uma biblioteca de inferência gratuita, sob licença MIT, de turboderp's, para inferência rápida de LLM em GPUs NVIDIA de consumo, conhecida por seu formato de quantização EXL2 flexível, mas seu repositório agora está arquivado em favor do sucessor ativamente desenvolvido, o ExLlamaV3.
💬 Em termos simples
O ExLlamaV2 foi construído especificamente para extrair velocidade máxima de uma única GPU de consumo usando um esquema de quantização incomumente flexível; seu próprio mantenedor desde então transferiu o desenvolvimento para um novo projeto, o ExLlamaV3, em vez de continuar atualizando o V2.
📌Nota: O próprio README do GitHub do ExLlamaV2 declara que o projeto está arquivado e que o desenvolvimento continua no ExLlamaV3 — qualquer pessoa iniciando um novo projeto hoje deve avaliar o ExLlamaV3 em vez de construir sobre a base de código arquivada do V2.
O Que Era o ExLlamaV2?
O ExLlamaV2 era uma biblioteca de inferência gratuita e de código aberto, lançada sob licença MIT por um desenvolvedor conhecido como turboderp, construída especificamente para maximizar a velocidade de inferência em GPUs NVIDIA de consumo. Ele sucedeu um projeto anterior, o ExLlama, e era, por si só, uma reescrita mais eficiente em memória, focada em executar modelos quantizados rapidamente em uma única GPU.
O repositório, github.com/turboderp-org/exllamav2, atingiu cerca de 4.600 estrelas no GitHub antes de ser marcado como arquivado, com seu README apontando para o ExLlamaV3 como o projeto onde o desenvolvimento agora continua.
- Focado estreitamente em GPUs NVIDIA de consumo, em vez da ampla cobertura de fornecedores de hardware de engines como o llama.cpp
- Introduziu o formato de quantização EXL2 como sua principal contribuição técnica, permitindo quantização de precisão mista dentro de um único modelo
- Suportava os mesmos modelos GPTQ de 4 bits que o ExLlama original, além de seu próprio formato EXL2
- Instalável via pip (
pip install exllamav2), wheels pré-compilados, ou compilação a partir do código-fonte com o CUDA Toolkit
O Que É a Quantização EXL2?
EXL2 é o formato de quantização do ExLlamaV2, permitindo que diferentes camadas lineares dentro do mesmo modelo usem diferentes larguras de bits — de 2 a 8 bits — escolhidas automaticamente a partir de dados de calibração para atingir uma taxa de bits média-alvo. Isso é mais flexível do que uma única largura de bits fixa aplicada uniformemente a um modelo inteiro.
- Suporta níveis de quantização de 2, 3, 4, 5, 6 e 8 bits, misturados por camada dentro de um modelo
- Colunas de pesos mais importantes podem ser quantizadas com maior precisão, enquanto as menos importantes usam menos bits, de forma semelhante em espírito à quantização esparsa
- Permite compressão extrema para modelos grandes com VRAM limitada — testes documentados mostram um modelo de 70 bilhões de parâmetros rodando em 24 GB de VRAM a cerca de 2,55 bits por peso com um contexto de 2048 tokens
- Os parâmetros de quantização são escolhidos automaticamente com base em dados de calibração, em vez de exigir configuração manual por camada
Por Que o ExLlamaV2 Está Arquivado, e o Que o ExLlamaV3 Muda?
O repositório turboderp-org/exllamav2 está marcado como arquivado, com seu próprio README declarando que o desenvolvimento continua no ExLlamaV3. Este é o fato mais importante a se saber antes de avaliar o ExLlamaV2 para um novo projeto.
O ExLlamaV3 introduz seu próprio formato, o EXL3, descrito como uma variante simplificada da abordagem de quantização QTIP da Cornell RelaxML. Diferente do EXL2, o EXL3 preserva as estruturas originais dos tensores em vez de renomeá-las, com a intenção de facilitar o suporte futuro por outros frameworks. O ExLlamaV3 documenta o CUDA 12.4 ou posterior como requisito e é explicitamente sinalizado por seus próprios mantenedores como ainda em amadurecimento — espere algumas arestas a serem aparadas.
- ExLlamaV2: arquivado, licença MIT, formato EXL2, ainda instalável mas sem receber mais desenvolvimento
- ExLlamaV3: ativo, licença MIT, formato EXL3 (baseado em pesquisa QTIP), estabilidade em estágio beta segundo sua própria documentação
- Ambos são mantidos pelo mesmo desenvolvedor, turboderp, sob a organização GitHub turboderp-org
📌Nota: Para qualquer nova implantação, avalie o ExLlamaV3 primeiro — é onde a manutenção ativa e as melhorias estão acontecendo. O ExLlamaV2 permanece relevante principalmente para configurações existentes já construídas sobre ele, ou para arquivos de modelo quantizados em EXL2 já em circulação.
Como Instalar e Executar o ExLlamaV2 (ou V3)?
O ExLlamaV2 é instalado via pip, wheels pré-compilados, ou a partir do código-fonte com o CUDA Toolkit; o ExLlamaV3 segue um padrão semelhante. O TabbyAPI é a forma recomendada de ter um servidor compatível com OpenAI rodando sobre qualquer um dos dois.
- 1Para o ExLlamaV2: instale via
pip install exllamav2, ou baixe um wheel pré-compilado compatível com sua versão de Python e CUDA na página de Releases do GitHub, ou clone e compile a partir do código-fonte com o CUDA Toolkit instalado. - 2Para o ExLlamaV3 (recomendado para novas configurações): siga os caminhos de instalação equivalentes documentados em github.com/turboderp-org/exllamav3, observando que o CUDA 12.4 ou posterior é necessário.
- 3Baixe um modelo EXL2 (ou EXL3) pré-quantizado, comumente publicado no Hugging Face por quantizadores da comunidade.
- 4Instale e execute o TabbyAPI, o servidor baseado em FastAPI recomendado, para expor um endpoint de API compatível com OpenAI com download de modelos do HF e suporte a templates de chat Jinja2.
- 5Alternativamente, use o ExLlamaV2/V3 por meio de uma integração existente — text-generation-webui, lollms-webui, ou a interface web independente ExUI — em vez de executar o TabbyAPI diretamente.
Ainda posso usar o ExLlamaV2 hoje?
Sim, ele permanece instalável e funcional, mas o repositório está arquivado e não receberá mais atualizações, correções de bugs ou novos recursos.
Arquivos de modelo EXL2 funcionam com o ExLlamaV3?
Não, não diretamente — o ExLlamaV3 usa seu próprio formato de quantização EXL3. Os arquivos de modelo EXL2 existentes são feitos para configurações ExLlamaV2/TabbyAPI, não para o V3.
Que Hardware o ExLlamaV2 Exige?
O ExLlamaV2 é voltado especificamente para GPUs NVIDIA de consumo — não há caminho de suporte para AMD, Intel ou apenas CPU. Esse foco estreito em hardware é parte do que permitiu otimizá-lo tão intensamente para velocidade em uma única GPU.
- Apenas GPUs NVIDIA, com CUDA obrigatório — sem suporte documentado para AMD, Intel ou Apple Silicon
- Projetado em torno de placas de consumo, e não GPUs de data center, embora também funcione nelas
- Os requisitos de VRAM escalam com o tamanho do modelo e a taxa de bits EXL2 escolhida — é exatamente essa quantização flexível que permite que modelos grandes caibam em relativamente pouca VRAM
- O ExLlamaV3 documenta o CUDA 12.4 ou posterior como requisito, uma base mais recente do que o ExLlamaV2 assumia
Quem Deveria Usar o ExLlamaV2 (ou ExLlamaV3)?
Use o ExLlamaV3 para um novo projeto se extrair velocidade e eficiência de VRAM máximas de uma única GPU NVIDIA de consumo importar mais do que suporte amplo de hardware ou garantias de estabilidade a longo prazo; há pouca razão para começar um projeto totalmente novo no ExLlamaV2 arquivado hoje.
Como o ExLlamaV2 Se Compara às Alternativas?
As comparações mais próximas do ExLlamaV2 são seu próprio sucessor e outras engines com forte foco em quantização ou velocidade em uma única GPU.
Ferramenta | Licença | Melhor Para |
|---|---|---|
| ExLlamaV2 (arquivado) | MIT | Apenas configurações EXL2 existentes |
| ExLlamaV3 | MIT | Máx. eficiência de quantização em uma GPU (beta) |
| llama.cpp | MIT | Suporte de hardware mais amplo, controle direto |
| Ollama | MIT | Configuração local mais simples |
| KoboldCpp | AGPL 3.0 | Zero instalação, UI de roleplay/histórias |
Erros Comuns ao Avaliar o ExLlamaV2
A maior parte da confusão vem de não perceber que o projeto está arquivado, ou de esperar compatibilidade cruzada entre arquivos de modelo EXL2 e EXL3.
Perguntas Frequentes
O ExLlamaV2 ainda é mantido?
Não. O repositório GitHub turboderp-org/exllamav2 está marcado como arquivado, com seu README declarando que o desenvolvimento continua no ExLlamaV3.
O que é o EXL2?
EXL2 é o formato de quantização do ExLlamaV2, suportando precisão mista de 2 a 8 bits por camada dentro de um único modelo para atingir uma taxa de bits média-alvo, permitindo que modelos grandes caibam em menos VRAM.
O que é o ExLlamaV3, e como ele é diferente?
O ExLlamaV3 é o sucessor ativamente desenvolvido do ExLlamaV2, usando um novo formato de quantização EXL3 baseado na abordagem QTIP da Cornell RelaxML. É documentado como software em estágio beta por seus próprios mantenedores.
Quem criou o ExLlamaV2 e o ExLlamaV3?
Ambos foram criados por um desenvolvedor conhecido como turboderp, sob a organização GitHub turboderp-org.
O ExLlamaV2 é gratuito?
Sim. Tanto o ExLlamaV2 quanto o ExLlamaV3 são lançados sob licença MIT, gratuitos para uso pessoal e comercial.
O ExLlamaV2 suporta GPUs AMD?
Não. Tanto o ExLlamaV2 quanto o ExLlamaV3 exigem uma GPU NVIDIA com CUDA — não há suporte para AMD, Intel ou Apple Silicon.
O que é o TabbyAPI?
O TabbyAPI é um servidor baseado em FastAPI e a forma recomendada de expor uma API compatível com OpenAI sobre o ExLlamaV2 ou o ExLlamaV3, com recursos adicionais como download de modelos do Hugging Face e suporte a templates de chat Jinja2.
Os arquivos de modelo EXL2 e EXL3 podem ser usados de forma intercambiável?
Não. Os arquivos EXL2 são quantizados para o ExLlamaV2 e não são diretamente compatíveis com o ExLlamaV3, que usa o formato EXL3 separado.
Devo usar o ExLlamaV2 ou o ExLlamaV3 para um novo projeto?
O ExLlamaV3, já que o ExLlamaV2 está arquivado e não recebe mais desenvolvimento. O ExLlamaV3 ainda está em estágio beta, então espere algumas arestas em comparação com um projeto maduro e ativamente estabilizado.
Como o ExLlamaV2 se compara ao llama.cpp?
O llama.cpp suporta uma gama muito mais ampla de hardware (NVIDIA, AMD, Apple Silicon, Intel, apenas CPU) e é ativamente mantido; o ExLlamaV2 era focado estreitamente em GPUs NVIDIA de consumo e agora está arquivado, com o ExLlamaV3 como seu sucessor ativo.