Rodar o Flux 2 no seu próprio hardware significa não ter limites de uso, não pagar taxas e ter controle total sobre cada parâmetro. Este artigo mostra dois caminhos de instalação, o ComfyUI, para um fluxo de trabalho visual e sem código, e o Hugging Face Diffusers, para controle por script, além da otimização de VRAM para placas de 8 GB e como acessar o Flux 2 Pro sem nenhuma configuração local.
Rodar um modelo de texto para imagem de ponta diretamente na sua máquina muda tudo na forma como você trabalha. Sem limites de uso, sem filas e sem mensalidades corroendo o orçamento de cada experimento. O Flux 2, da Black Forest Labs, é um dos modelos de geração de imagens de pesos abertos mais capazes disponíveis hoje, e instalá-lo localmente é mais acessível do que a maioria das pessoas imagina. Este artigo percorre todo o processo, dos requisitos do sistema até a sua primeira imagem gerada.
O Flux 2 é a segunda geração da arquitetura Flux, criada pela Black Forest Labs, a equipe por trás de alguns dos modelos de pesos abertos mais fotorrealistas disponíveis hoje. Ele se baseia na família original Flux.1, com melhor aderência ao prompt, maior precisão anatômica em figuras humanas e renderização de detalhes mais nítida em resoluções padrão. O modelo usa uma arquitetura de difusão baseada em transformers, que se diferencia de forma fundamental dos projetos U-Net dos modelos Stable Diffusion mais antigos.
A família Flux 2 vem em várias versões distintas, cada uma voltada para uma faixa de hardware e um caso de uso diferente:
| Modelo | VRAM necessária | Ideal para |
|---|---|---|
| flux-2-dev | 16–24 GB | Pesquisa, fine-tuning, trabalho local |
| flux-2-pro | Somente na nuvem | Uso em produção comercial |
| flux-2-max | Somente na nuvem | Máximo de detalhe e resolução |
| flux-2-flex | Somente na nuvem | Controle flexível de proporção |
| flux-2-klein-4b | 8–12 GB | Inferência rápida em hardware de consumo |
| flux-2-klein-9b-base | 16 GB | Geração local de alta fidelidade |
Para a instalação local, o flux-2-dev e o flux-2-klein-4b são seus principais alvos. As versões Pro, Max e Flex funcionam exclusivamente via API e não são distribuídas como pesos para download.
Há razões concretas além da economia de custos. A inferência local significa que seus prompts e as imagens geradas nunca saem da sua máquina, o que importa em trabalhos comerciais com temas sensíveis. Você controla diretamente cada parâmetro de amostragem. Pode processar centenas de imagens em lote durante a noite sem se preocupar com preço por geração. E, para fazer fine-tuning com conjuntos de dados próprios ou acoplar adaptadores LoRA, a instalação local é o único caminho viável.
Antes de baixar qualquer coisa, confira seu hardware e seu conjunto de software em relação a estes requisitos. Dependências incompatíveis causam a maioria das falhas comuns de instalação.
O Flux 2 exige muito processamento. Aqui está o detalhamento honesto:
Configuração mínima viável:
Configuração recomendada:
GPUs AMD funcionam via ROCm no Linux, mas o suporte de drivers no Windows é irregular. Espere mais trabalho de solução de problemas em comparação com configurações CUDA.
Apple Silicon (M1/M2/M3/M4) consegue rodar versões quantizadas do Flux 2 pelo framework MLX. Os tempos de geração ficam de 2 a 4 vezes mais lentos do que em uma placa NVIDIA comparável, mas a qualidade da imagem é equivalente.
💡 Dica: Se sua GPU tem exatamente 8 GB de VRAM, use a quantização GGUF Q4_K_S. A qualidade cai um pouco, mas o modelo roda sem erros de memória na maioria dos prompts.
Seu conjunto de software precisa estar alinhado antes que qualquer instalação de pacote Python funcione corretamente:
nvidia-smi em um terminal.No Windows, instale o CUDA pelo portal de desenvolvedores da NVIDIA. No Ubuntu 22.04 ou mais recente, o instalador em runfile evita conflitos de pacotes com drivers pré-instalados.
Existem dois métodos bem suportados para rodar o Flux 2 localmente. Nenhum é objetivamente melhor, e a escolha certa depende totalmente de como você trabalha.
O ComfyUI é uma interface gráfica baseada em nós para rodar modelos de difusão. Você conecta nós em uma tela visual para montar pipelines de geração. Não é preciso escrever scripts em Python depois da configuração inicial. Para a maioria das pessoas, é o caminho mais rápido do zero até uma instalação funcional do Flux 2.
Escolha o ComfyUI quando:
A biblioteca diffusers é a API Python padrão para rodar modelos de difusão de forma programática. Você escreve scripts de inferência e tem controle total sobre cada parâmetro, desde o dtype de precisão até schedulers personalizados.
Escolha o Diffusers quando:
Este é o caminho recomendado para a maioria dos usuários que querem resultados rápidos sem escrever código.
Passo 1: clone o repositório do ComfyUI e entre no diretório:
git clone https://github.com/comfyanonymous/ComfyUI
cd ComfyUI
Passo 2: instale o PyTorch com suporte a CUDA. Use o seletor em pytorch.org para obter o comando correto para a sua versão do CUDA. Para o CUDA 12.1:
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121
Passo 3: instale as demais dependências do ComfyUI:
pip install -r requirements.txt
Passo 4: inicie o servidor:
python main.py --gpu-only
Abra http://127.0.0.1:8188 no seu navegador. O ComfyUI já está rodando.
💡 Dica: No Windows, a versão portátil standalone da página oficial do ComfyUI no GitHub já inclui Python e PyTorch pré-instalados. Ela inicia com um duplo clique e evita quase todos os problemas de configuração do ambiente.
Os pesos do Flux 2 estão hospedados no Hugging Face. Você precisa de uma conta gratuita e deve aceitar o contrato de licença do modelo na página dele antes que o download funcione.
Para o flux-2-dev (exige 16 GB+ de VRAM):
huggingface-cli download black-forest-labs/FLUX.2-dev \
flux2-dev.safetensors \
--local-dir ./models/checkpoints/
Para o flux-2-klein-4b (roda em placas de 8 GB):
huggingface-cli download black-forest-labs/FLUX.2-klein-4b \
--local-dir ./models/checkpoints/
Você também precisa dos codificadores de texto e do VAE compartilhados. Esses componentes são reutilizados em todas as variantes do Flux:
# T5 text encoder in fp8 (saves approximately 8 GB VRAM vs full precision)
huggingface-cli download comfyanonymous/flux_text_encoders \
t5xxl_fp8_e4m3fn.safetensors \
--local-dir ./models/clip/
# CLIP text encoder
huggingface-cli download openai/clip-vit-large-patch14 \
--local-dir ./models/clip/
# VAE (shared from Flux.1)
huggingface-cli download black-forest-labs/FLUX.1-schnell \
ae.safetensors \
--local-dir ./models/vae/
Carregue o JSON oficial do fluxo de trabalho do Flux no ComfyUI pelo botão Load. Os principais nós a configurar são:
Clique em Queue Prompt e sua primeira geração com Flux 2 começa.
Para fluxos de trabalho com scripts e desenvolvimento de aplicações, a biblioteca diffusers do Hugging Face oferece o maior controle sobre cada aspecto da geração de imagens.
Sempre isole projetos de IA em um ambiente virtual para evitar conflitos de pacotes entre projetos.
python -m venv flux2-env
# Windows activation
flux2-env\Scripts\activate
# Linux and macOS activation
source flux2-env/bin/activate
pip install --upgrade pip
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu121
pip install diffusers transformers accelerate sentencepiece protobuf
pip install huggingface_hub
Para suporte à quantização GGUF em placas com pouca VRAM:
pip install gguf
💡 Dica: Depois de uma instalação funcional, rode
pip freeze > requirements.txtpara fixar suas versões. A bibliotecadiffusersé atualizada com frequência, e mudanças ocasionais que quebram compatibilidade afetam a API do pipeline do Flux.
Um script mínimo funcional para o flux-2-dev:
import torch
from diffusers import FluxPipeline
pipe = FluxPipeline.from_pretrained(
"black-forest-labs/FLUX.2-dev",
torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()
prompt = "A photorealistic portrait of a woman in soft natural light, film grain, 8K"
image = pipe(
prompt,
height=1024,
width=1024,
guidance_scale=3.5,
num_inference_steps=28,
max_sequence_length=512,
generator=torch.Generator("cpu").manual_seed(42)
).images[0]
image.save("flux2_output.png")
Rode com:
python generate.py
A primeira execução baixa aproximadamente 24 GB de pesos do modelo. As execuções seguintes carregam do cache em cerca de 30 segundos em um SSD NVMe moderno.
Nem todo mundo tem uma GPU de 24 GB. Estas duas estratégias permitem rodar o Flux 2 em placas de 8–12 GB sem abrir mão da qualidade de imagem central que torna o modelo valioso.
GGUF é um formato de quantização adaptado do ecossistema llama.cpp que hoje funciona com modelos de difusão de imagem. Ele reduz a precisão do modelo de floats de 16 bits para inteiros de 4 ou 8 bits, cortando os requisitos de VRAM em 50–75%.
Arquivos GGUF quantizados pela comunidade para o Flux 2 estão disponíveis no Hugging Face. A contrapartida prática em cada nível de quantização:
| Arquivo | Uso de VRAM | Qualidade |
|---|---|---|
| flux2-dev-Q8_0.gguf | ~10 GB | Quase sem perdas |
| flux2-dev-Q4_K_S.gguf | ~6 GB | Boa, com leve suavização |
| flux2-dev-Q3_K_M.gguf | ~5 GB | Aceitável para testes rápidos |
No ComfyUI, instale a extensão de nó personalizado ComfyUI-GGUF e carregue o arquivo de checkpoint .gguf exatamente como carregaria qualquer checkpoint .safetensors. Não são necessárias outras mudanças no fluxo de trabalho.
Duas estratégias adicionais de redução de memória que combinam bem entre si:
Carregamento do transformer em fp8 no Diffusers:
from diffusers import FluxPipeline, FluxTransformer2DModel
import torch
transformer = FluxTransformer2DModel.from_pretrained(
"black-forest-labs/FLUX.2-dev",
subfolder="transformer",
torch_dtype=torch.float8_e4m3fn
)
pipe = FluxPipeline.from_pretrained(
"black-forest-labs/FLUX.2-dev",
transformer=transformer,
torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()
Offloading sequencial para CPU (mais lento, mas funciona em placas de 8 GB):
pipe.enable_sequential_cpu_offload()
💡 Dica: Combine o GGUF Q4_K_S com
enable_model_cpu_offload()para o melhor equilíbrio em placas de 8 GB. Espere tempos de geração de 3 a 5 minutos por imagem de 1024x1024, o que é perfeitamente viável para trabalho pessoal iterativo.
Se você quer testar o Flux 2 antes de se comprometer com uma configuração local completa, ou se precisa acessar as versões Pro e Max, disponíveis só na nuvem, o PicassoIA oferece todos os modelos Flux 2 diretamente no navegador, sem nenhuma instalação.
O flux-2-pro e o flux-2-max não estão disponíveis como pesos para download. Eles rodam exclusivamente via API na nuvem. O PicassoIA oferece acesso pelo navegador a ambos, junto com o flux-2-flex para dimensões de saída flexíveis e o flux-2-klein-4b para geração rápida.
Passos para gerar com o Flux 2 no PicassoIA:
Para uma qualidade equivalente à de rodar o flux-2-dev localmente em uma GPU de 24 GB, a implementação do PicassoIA entrega resultados à altura, sem tempo de configuração.
O Flux 2 responde bem a prompts em linguagem natural. Você não precisa de colchetes com peso nem de empilhamento de tokens. Escreva o que quer como uma frase clara e específica.
O que funciona bem:
O que evitar:
💡 Dica: Para o flux-2-klein-4b, mantenha o guidance scale entre 2,5 e 4,0. Valores mais altos saturam demais as cores no modelo menor.
Seja qual for o caminho que você escolheu, o ComfyUI, um script com Diffusers ou o flux-2-pro no PicassoIA, agora você tem tudo o que precisa para trabalhar com o Flux 2.
O grande valor de ter o Flux 2 rodando localmente, ou por uma plataforma como o PicassoIA, é a velocidade de iteração. Escreva um prompt, veja o resultado em menos de um minuto, refine a descrição e gere de novo. Esse ciclo de feedback rápido é onde a habilidade real de escrever prompts e ajustar parâmetros se desenvolve.
O PicassoIA dá acesso imediato ao flux-2-dev, ao flux-2-pro, ao flux-2-max, ao flux-2-flex e ao eficiente flux-2-klein-4b, sem configuração de CUDA, sem download de 24 GB de pesos e sem montar ambiente virtual. É a forma mais rápida de comparar o que cada versão realmente produz antes de decidir se vale a pena uma instalação local completa para o seu fluxo de trabalho.
Comece com um prompt que importa para você. Rode-o no flux-2-dev e depois compare com o flux-2-klein-4b. Observe o que muda entre os dois. Essa comparação mostra exatamente quanto investimento em hardware se justifica para o seu caso de uso, sem nenhum achismo.
Escolha seu idioma
