O ComfyUI tornou-se a interface de referência para quem quer controlar geração de imagem e vídeo por IA sem depender de serviços fechados. Em vez de um botão único “gerar”, o programa organiza o processo em nós ligados entre si, como um fluxograma visual, o que dá acesso a cada etapa do modelo. Este tutorial mostra como instalar a versão v0.39.0 (lançada a 5 de outubro de 2026), configurar o ambiente certo e correr o primeiro fluxo de trabalho em menos de uma hora, mesmo sem experiência prévia com ferramentas de IA generativa.

O projeto, mantido sob o nome de utilizador comfyanonymous no GitHub, já soma cerca de 136 mil estrelas, um número que o coloca atrás do veterano AUTOMATIC1111 (perto de 165 mil estrelas) mas à frente da maioria das alternativas recentes. A diferença é que o AUTOMATIC1111 estagnou em atualizações, enquanto o ComfyUI lança novas versões quase semanalmente e já suporta os modelos mais recentes, como Flux, Qwen Image e Hunyuan Image. Vamos instalar, configurar e gerar a primeira imagem passo a passo.

Ao contrário de serviços pagos por geração ou por assinatura mensal, correr o ComfyUI na sua própria máquina elimina filas de espera, limites de uso e qualquer dependência de um serviço online que pode mudar os termos de utilização sem aviso. É esta combinação entre controlo total, custo reduzido a longo prazo e acesso quase imediato a cada modelo novo que explica porque a ferramenta se tornou a escolha por defeito de artistas digitais, estúdios independentes e investigadores que trabalham com geração de imagem, um movimento que acompanha a tendência mais ampla de inteligência artificial aberta e local que temos vindo a seguir nesta cobertura.

O que é o ComfyUI e porque é diferente do AUTOMATIC1111

O ComfyUI é uma interface gráfica open source para correr modelos de difusão (Stable Diffusion, SDXL, Flux) e modelos de vídeo de forma local, sem enviar dados para servidores de terceiros. A diferença central face a interfaces mais antigas como o AUTOMATIC1111 WebUI está na arquitetura: em vez de formulários fixos, o utilizador constrói um grafo de nós, cada um representando uma operação (carregar modelo, codificar texto, amostrar ruído, decodificar imagem). Isto permite ver exatamente o que está a acontecer em cada etapa da geração e modificar apenas a parte que interessa, sem recriar o fluxo inteiro.

Essa flexibilidade tem um custo: a curva de aprendizagem é mais alta do que em interfaces de botão único. Em compensação, o ComfyUI costuma ser o primeiro a suportar modelos novos, porque a comunidade publica nós personalizados (custom nodes) quase no dia de lançamento de cada modelo. É por isso que ferramentas como o ComfyUI Manager e repositórios de workflows prontos se tornaram tão populares: resolvem a complexidade inicial sem sacrificar o controlo.

Além da versão clássica para navegador, existe também o ComfyUI Desktop, uma aplicação nativa para Windows, macOS (Apple Silicon) e Linux, distribuída como instalador, AppImage ou pacote .deb. Esta variante embrulha o Python e as dependências num único pacote, o que elimina boa parte dos problemas de instalação que afetam utilizadores menos técnicos. Este tutorial cobre as duas formas de instalação: a manual (mais flexível, recomendada para quem quer editar código ou usar GPUs AMD/Intel) e a Desktop (mais rápida para começar).

Pré-requisitos: hardware e software necessários

Antes de instalar, confirme que o seu equipamento cumpre os requisitos mínimos documentados pelo projeto. O ComfyUI corre em CPU, mas a velocidade cai de forma drástica sem uma GPU dedicada, por isso vale a pena verificar cada ponto da lista abaixo com atenção.

RequisitoMínimoRecomendado
Sistema operativoWindows 10, macOS (Apple Silicon), LinuxWindows 11 ou Linux recente
Python3.133.13 (3.14 funciona, mas alguns nós personalizados podem falhar)
PyTorch2.7Versão mais recente disponível
GPUNVIDIA, AMD, Intel ou Apple SiliconNVIDIA com CUDA 13.0 (placas série 20 ou mais recentes exigem build cu130+)
Memória RAM8 GB16 GB ou mais
Espaço em disco4,85 GB (só a aplicação)50 GB+ (com modelos)

Note que o ComfyUI não exige obrigatoriamente uma GPU NVIDIA: há suporte oficial para AMD, Intel e Apple Silicon, além de execução em CPU para testes. Ainda assim, gerar uma imagem SDXL em CPU pode demorar vários minutos em vez de segundos, por isso uma placa gráfica dedicada com pelo menos 8 GB de VRAM é o ponto de partida prático para a maioria dos fluxos de trabalho. Modelos de vídeo como os da família Wan ou Hunyuan exigem tipicamente 12 GB de VRAM ou mais para correr com conforto.

Se usa uma placa NVIDIA da série 20 em diante, confirme que instala uma build de PyTorch compilada com CUDA 13.0, conforme indicado na documentação oficial de instalação manual. Usar uma versão de CUDA desatualizada é uma das causas mais comuns de erros na primeira execução, como veremos na secção de resolução de problemas.

Passo 1: Escolher entre instalação manual e ComfyUI Desktop

Existem três caminhos principais para instalar o ComfyUI: a aplicação Desktop (mais simples), o pacote portátil em ZIP para Windows (sem instalador, basta extrair) e a instalação manual via Git e ambiente Python (mais flexível, ideal para quem vai personalizar nós ou contribuir para o projeto). Este tutorial segue a via manual como caminho principal, porque é a que funciona de forma idêntica em Windows, macOS e Linux, mas indicamos também os comandos para a versão Desktop.

Se só quer testar rapidamente sem tocar na linha de comandos, descarregue o instalador Desktop diretamente da página oficial de downloads. Para quem pretende mais controlo sobre bibliotecas, GPUs AMD/Intel ou pretende correr o ComfyUI num servidor remoto, a instalação manual descrita a seguir é o caminho certo.

Para quem optar pela via Desktop, o processo resume-se a três ações: descarregar o instalador correto para o seu sistema operativo (.exe no Windows, .dmg no macOS, AppImage ou .deb no Linux), executar o instalador e aceitar a pasta de instalação predefinida, e deixar a aplicação descarregar as dependências internas na primeira execução. Ao contrário da instalação manual, não é preciso abrir um terminal nem escrever um único comando: a aplicação pergunta apenas onde quer guardar os modelos e qual a GPU a usar, e depois arranca sozinha com um botão “Launch”. É a opção mais indicada para quem só quer gerar imagens sem lidar com Python, ambientes virtuais ou versões de CUDA.

Passo 2: Instalar o Python 3.13 e o Git

Confirme primeiro se já tem o Python instalado e qual a versão. Abra um terminal (PowerShell no Windows, Terminal no macOS/Linux) e corra:

python --version
git --version

Se o comando falhar ou mostrar uma versão anterior à 3.13, instale a versão recomendada. No Windows, descarregue o instalador em python.org e marque a opção “Add Python to PATH” durante a instalação. No macOS, use o Homebrew:

brew install [email protected] git

No Ubuntu ou Debian, o comando equivalente é:

sudo apt update
sudo apt install python3.13 python3.13-venv git -y

Passo 3: Clonar o repositório do ComfyUI

Com o Python e o Git prontos, descarregue o código-fonte diretamente do repositório oficial no GitHub. Escolha uma pasta sem espaços ou acentos no caminho, para evitar problemas comuns em scripts de instalação Python no Windows.

git clone https://github.com/comfyanonymous/ComfyUI.git
cd ComfyUI

Este comando cria uma pasta chamada ComfyUI com todo o código necessário. Se preferir uma versão específica em vez do código mais recente da branch principal, pode alternar para uma tag de lançamento, como a v0.39.0:

git checkout v0.39.0

Passo 4: Criar um ambiente virtual isolado

Um ambiente virtual evita conflitos entre as bibliotecas do ComfyUI e outras aplicações Python que já tenha instaladas. Dentro da pasta ComfyUI, corra:

python -m venv venv
# Windows
venv\Scripts\activate
# macOS / Linux
source venv/bin/activate

Quando o ambiente estiver ativo, o nome “(venv)” deve aparecer no início da linha do terminal. A partir deste ponto, todos os comandos de instalação de bibliotecas ficam isolados desta pasta, o que facilita também a remoção completa caso algo corra mal.

Passo 5: Instalar o PyTorch com suporte à sua GPU

Este é o passo onde a maioria dos erros de instalação acontece, porque o comando certo depende do fabricante da GPU. Para placas NVIDIA com CUDA 13.0, use:

pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu130

Para placas AMD no Linux, o ComfyUI usa a stack ROCm em vez de CUDA. Consulte a versão ROCm suportada pela sua distribuição antes de instalar, porque a sintaxe do índice muda entre versões. Para Apple Silicon (M1 a M4), basta instalar a versão padrão a partir da página oficial do PyTorch, já que o suporte a Metal está incluído de fábrica:

pip install torch torchvision torchaudio

Passo 6: Instalar as dependências do ComfyUI

Com o PyTorch já instalado e a funcionar, instale o resto das bibliotecas listadas no ficheiro requirements.txt do projeto:

pip install -r requirements.txt

Este comando pode demorar alguns minutos, dependendo da velocidade da ligação à internet, porque descarrega várias bibliotecas de processamento de imagem e redes neuronais. Se aparecer um erro relacionado com “wheel” ou compilação, normalmente basta atualizar o pip primeiro com pip install --upgrade pip e repetir o comando.

Passo 7: Descarregar um modelo base

O ComfyUI por si só não gera nada: precisa de um ficheiro de modelo (checkpoint) para funcionar. Os modelos ficam na pasta models/checkpoints. A forma mais simples de obter um modelo legítimo e gratuito é através do Hugging Face, que funciona como repositório central para a maioria dos modelos abertos usados pela comunidade.

Para quem está a começar, um checkpoint SDXL ou SD3.5 é suficiente para testar o fluxo completo sem exigir demasiada VRAM. Modelos mais recentes como Flux e Qwen Image produzem resultados de qualidade superior, mas pedem mais memória e, em alguns casos, nós personalizados adicionais para funcionar corretamente no ComfyUI. Consulte sempre a página do Hugging Face correspondente a cada modelo antes de descarregar, para confirmar a licença de utilização.

# Exemplo de estrutura de pastas depois de colocar o modelo
ComfyUI/
  models/
    checkpoints/
      meu_modelo.safetensors
    vae/
    loras/
    controlnet/

Passo 8: Arrancar o ComfyUI pela primeira vez

Com o modelo já na pasta certa, está na hora de arrancar o servidor local. Dentro da pasta ComfyUI, com o ambiente virtual ainda ativo, corra:

python main.py

Depois de alguns segundos, o terminal deve mostrar uma mensagem a indicar que o servidor está disponível no endereço http://127.0.0.1:8188. Abra esse endereço num navegador e deverá ver o grafo de nós padrão já carregado, pronto para a primeira geração.

Se preferir usar placas AMD ou forçar execução apenas em CPU (para testes sem GPU), adicione as flags correspondentes:

# Forçar execução em CPU (lento, só para teste)
python main.py --cpu

# Reduzir uso de VRAM em GPUs com pouca memória
python main.py --lowvram

Passo 9: Gerar a primeira imagem com o fluxo padrão

O grafo padrão que aparece ao abrir o ComfyUI já contém todos os nós necessários para uma geração simples: carregar o checkpoint, codificar o texto positivo e negativo, amostrar o ruído e decodificar a imagem final. Para gerar a primeira imagem:

  • Clique no nó “Load Checkpoint” e selecione o modelo que colocou na pasta checkpoints.
  • No nó de texto positivo (CLIP Text Encode), escreva a descrição da imagem que quer gerar.
  • No nó de texto negativo, escreva o que quer evitar (por exemplo, “baixa qualidade, desfocado”).
  • Confirme a resolução no nó “Empty Latent Image” (1024×1024 é um bom ponto de partida para SDXL).
  • Clique no botão “Queue Prompt” no canto superior direito.

A primeira geração costuma demorar mais tempo do que as seguintes, porque o modelo precisa de ser carregado para a memória da GPU. Em placas com 8 GB de VRAM, uma imagem SDXL a 1024×1024 pixels normalmente demora entre 10 e 30 segundos depois do modelo carregado, dependendo do número de passos de amostragem escolhido.

Passo 10: Instalar o ComfyUI Manager para gerir extensões

Depois de confirmar que a instalação base funciona, o próximo passo lógico é instalar o ComfyUI Manager, a extensão que permite descarregar nós personalizados e novos modelos diretamente a partir da interface, sem editar ficheiros manualmente. Pare o servidor (Ctrl+C no terminal) e corra:

cd custom_nodes
git clone https://github.com/Comfy-Org/ComfyUI-Manager.git
cd ..
python main.py

Depois de reiniciar, deve aparecer um novo botão “Manager” na interface. A partir daí é possível procurar e instalar extensões para suporte a modelos específicos, como os nós necessários para trabalhar com Flux ou com os modelos de vídeo da família Wan, sem sair do navegador.

Passo 11: Configurar fluxos de trabalho para modelos avançados

A documentação oficial lista suporte nativo para Stable Diffusion, SDXL, SDXL Turbo, SD3.5, Flux, Qwen Image e Hunyuan Image. Cada família de modelos tem exigências próprias de VRAM e, em alguns casos, nós específicos que não vêm incluídos na instalação base. Antes de descarregar um modelo novo, verifique sempre o workflow de exemplo recomendado pela comunidade para esse modelo específico, porque a estrutura de nós (especialmente o encoder de texto e o VAE) muda de família para família.

Para modelos de vídeo, o processo é semelhante mas mais exigente em termos de hardware: a geração produz múltiplos fotogramas em sequência, o que multiplica o uso de memória em comparação com uma imagem estática. Se a sua GPU tiver 8 GB de VRAM ou menos, comece sempre por modelos de imagem antes de avançar para vídeo, para evitar erros de falta de memória que são mais difíceis de diagnosticar em fluxos complexos.

Controlar a composição com ControlNet

Um dos recursos mais usados por quem já domina o fluxo básico é o ControlNet, uma técnica que permite guiar a composição da imagem gerada a partir de uma referência externa, como um esboço, um mapa de profundidade ou a pose de uma figura humana. Em vez de depender só do texto para descrever o que quer, o ControlNet dá controlo direto sobre a estrutura visual final, o que é especialmente útil para ilustração, design de personagens ou qualquer trabalho onde a composição exata importa mais do que o estilo.

Para usar ControlNet no ComfyUI, é preciso instalar o modelo ControlNet correspondente ao seu checkpoint base (SDXL e Flux têm modelos ControlNet distintos, não são intercambiáveis) e adicionar três nós novos ao fluxo: um para carregar a imagem de referência, um “ControlNetLoader” para carregar o modelo de controlo, e um “ControlNetApply” para ligar esse controlo ao processo de amostragem. O ComfyUI Manager facilita a instalação destes modelos, já que inclui uma secção dedicada a modelos ControlNet organizados por família de checkpoint.

# Ordem típica dos nós num fluxo com ControlNet
LoadImage (referência) -> ControlNetLoader -> ControlNetApply
                                                  |
CheckpointLoaderSimple -> CLIPTextEncode -> KSampler (recebe o ControlNetApply)

Boas práticas de segurança ao descarregar modelos e nós

Como o ComfyUI depende fortemente de extensões da comunidade, vale a pena aplicar alguns cuidados básicos antes de instalar qualquer coisa que não venha do repositório oficial. O primeiro cuidado é preferir sempre o formato de modelo .safetensors em vez do antigo .ckpt: o formato .ckpt usa serialização Python (pickle), que pode, em teoria, executar código arbitrário ao ser carregado, enquanto o .safetensors foi desenhado especificamente para evitar esse risco, guardando apenas pesos numéricos.

O segundo cuidado é verificar a origem de cada nó personalizado antes de instalar via ComfyUI Manager. Como qualquer extensão corre com os mesmos privilégios do utilizador que executa o ComfyUI, um nó malicioso poderia, em teoria, aceder a ficheiros ou à rede local. Prefira extensões com histórico de atualizações regular, número razoável de utilizadores e código visível no GitHub, e evite instalar nós a partir de ligações partilhadas em fóruns sem reputação. O terceiro cuidado, já mencionado no passo de descarregar modelos, é confirmar que o ficheiro vem de uma página oficial no Hugging Face ou do Civitai com o autor correto identificado, e não de um espelho não verificado.

Casos de uso práticos do ComfyUI

Além da experimentação pessoal, o ComfyUI tem vindo a ser adotado em contextos profissionais concretos. Estúdios de design usam-no para gerar conceitos visuais rápidos antes de passar ao trabalho manual de ilustração, aproveitando a capacidade de reutilizar o mesmo fluxo de trabalho com variações de prompt para explorar várias direções criativas em paralelo. Equipas de marketing recorrem à ferramenta para produzir variações de imagem para anúncios ou redes sociais sem depender de um gerador de imagem fechado com custos por geração.

Outro caso de uso comum é a investigação e o ensino: por ser open source e correr localmente, o ComfyUI permite a estudantes e investigadores perceber exatamente o que cada etapa de um modelo de difusão faz, sem a caixa-negra de uma API fechada. Para desenvolvedores que trabalham com visão computacional, o ComfyUI também serve como ambiente de teste rápido para avaliar como diferentes checkpoints e LoRAs se comportam antes de os integrar numa aplicação própria. Quem já usa o Roblox Studio para gerar texturas com IA encontra no ComfyUI uma forma de produzir essas mesmas texturas com mais controlo sobre o estilo final antes de as importar para o motor de jogo.

Passo 12: Guardar, exportar e partilhar fluxos de trabalho

Depois de montar um fluxo que funciona bem, vale a pena guardá-lo para reutilizar depois ou partilhar com outra pessoa. No menu do ComfyUI, use a opção “Save” para guardar o grafo como ficheiro JSON na pasta de workflows. Esse ficheiro contém toda a estrutura de nós e pode ser carregado de novo com “Load”, ou enviado para outra instalação do ComfyUI, desde que a pessoa que o recebe tenha os mesmos modelos e nós personalizados instalados.

# Localização típica dos workflows guardados
ComfyUI/user/default/workflows/meu_fluxo.json

Uma curiosidade útil do ComfyUI é que as imagens geradas guardam os metadados do fluxo de trabalho completo dentro do próprio ficheiro PNG. Isto significa que basta arrastar uma imagem gerada por outra pessoa para dentro da interface para recuperar o grafo de nós exato que a produziu, incluindo todos os parâmetros usados.

Erros comuns ao instalar e como resolver cada um

A lista seguinte reúne os problemas mais frequentes relatados por quem instala o ComfyUI por conta própria, com a causa mais provável e a correção direta para cada caso.

ProblemaCausa provávelSolução
“CUDA out of memory”VRAM insuficiente para o modelo e resolução escolhidosAdicionar a flag –lowvram ou reduzir a resolução da imagem
Erro ao instalar torchVersão de CUDA incompatível com a GPUConfirmar a versão de CUDA da placa e usar o índice pip correto (cu130 para séries recentes)
“Module not found” ao arrancarAmbiente virtual não ativado ou requirements incompletosAtivar o venv e correr pip install -r requirements.txt de novo
Interface abre mas fica em brancoBloqueio de JavaScript ou cache do navegadorLimpar cache ou abrir numa janela anónima
Nó personalizado aparece em vermelhoDependência da extensão não instaladaUsar o ComfyUI Manager para reinstalar as dependências do nó
Geração extremamente lentaA correr em modo CPU sem quererConfirmar que o PyTorch detetou a GPU com torch.cuda.is_available()
Erro de tokenizer ao carregar modeloFicheiro de modelo incompleto ou corrompido no downloadVerificar o hash do ficheiro e descarregar novamente
Porta 8188 já em usoOutra instância do ComfyUI já está a correrFechar o processo anterior ou arrancar com –port 8189

Para confirmar rapidamente se o PyTorch está mesmo a usar a GPU (um dos problemas mais comuns e menos óbvios), corra este pequeno teste antes de arrancar o ComfyUI:

python -c "import torch; print(torch.cuda.is_available())"

Se o resultado for “False” apesar de ter uma GPU NVIDIA compatível, o problema está quase sempre na versão de PyTorch instalada, que ficou sem suporte CUDA porque o comando de instalação usou o índice padrão em vez do índice específico para a sua versão de CUDA.

5 erros frequentes de quem está a começar

Além dos erros técnicos de instalação, há armadilhas conceptuais que custam horas de frustração a quem usa o ComfyUI pela primeira vez. Conhecer estas cinco à partida poupa bastante tempo.

  1. Misturar modelos incompatíveis entre si. Um VAE feito para SD1.5 não funciona bem com SDXL, e um LoRA treinado para Flux não produz resultados corretos num checkpoint SDXL. Confirme sempre a família do modelo antes de combinar componentes.
  2. Ignorar o prompt negativo. Deixar o campo de texto negativo vazio costuma produzir imagens com artefactos visuais óbvios que seriam evitados com algumas palavras-chave básicas.
  3. Usar resolução errada para o modelo. Gerar diretamente a 2048×2048 num modelo treinado a 1024×1024 produz composições distorcidas; o caminho correto é gerar na resolução nativa e depois aplicar upscale num segundo nó.
  4. Esquecer de reiniciar depois de instalar um nó novo. O ComfyUI só carrega nós personalizados no arranque; instalar via Manager e não reiniciar leva a mensagens de erro confusas sobre nós “em falta”.
  5. Descarregar modelos de fontes não verificadas. Ficheiros de modelo em formato .ckpt antigo podem conter código executável malicioso; prefira sempre o formato .safetensors e fontes como o Hugging Face oficial do criador do modelo.

Exemplo de saída esperada depois da instalação

Depois de seguir os passos acima corretamente, o terminal deve mostrar uma sequência semelhante a esta ao arrancar o servidor:

Total VRAM 12288 MB, total RAM 32768 MB
Set vram state to: NORMAL_VRAM
Device: cuda:0 NVIDIA GeForce RTX 4070 : cudaMallocAsync
VAE dtype: torch.bfloat16
Using pytorch cross attention
Starting server

To see the GUI go to: http://127.0.0.1:8188

Se o terminal mostrar “Device: cpu” em vez do nome da sua GPU, significa que o PyTorch não conseguiu detetar a placa gráfica e está a usar o processador, o que confirma o diagnóstico da secção anterior sobre a instalação incorreta do CUDA.

Dicas avançadas: otimizar velocidade e qualidade

Depois de dominar o fluxo básico, há várias formas de acelerar a geração ou melhorar a qualidade do resultado final sem comprar hardware novo. A primeira é usar amostradores (samplers) mais eficientes: samplers como “dpmpp_2m” com um scheduler “karras” costumam produzir bons resultados com menos passos do que o Euler padrão, o que reduz o tempo total de geração sem perda visível de qualidade.

A segunda dica é usar modelos quantizados em formato GGUF ou FP8 quando a VRAM disponível for limitada. O ComfyUI suporta nós de carregamento específicos para estes formatos através de extensões da comunidade, o que permite correr modelos como o Flux em placas com 8 GB de VRAM, algo impossível com o modelo em precisão total. O princípio é o mesmo já explicado no nosso tutorial de como quantizar LLMs com Hugging Face: reduzir a precisão numérica dos pesos do modelo para caber em menos memória, com uma perda de qualidade normalmente pequena.

Por fim, para quem gera várias imagens em lote com o mesmo fluxo, vale a pena aprender a usar a flag --highvram em GPUs com muita memória disponível, que mantém os modelos carregados entre gerações e evita o tempo de carregamento repetido a cada novo pedido:

A escolha do sampler e do número de passos tem um impacto direto no tempo de geração e na qualidade final. A tabela seguinte resume as combinações mais usadas pela comunidade como ponto de partida, antes de qualquer ajuste fino ao gosto pessoal.

SamplerScheduler recomendadoPassos típicosObservação
eulernormal20-30Base simples, resultado previsível
dpmpp_2mkarras15-20Boa relação velocidade/qualidade
dpmpp_sdekarras15-20Mais detalhe, ligeiramente mais lento
uni_pcnormal10-15Menos passos para resultado aceitável

Testar duas ou três combinações diferentes para o mesmo prompt é a forma mais rápida de descobrir qual se adapta melhor ao modelo que está a usar, já que o comportamento de cada sampler varia de checkpoint para checkpoint.

python main.py --highvram

Correr o ComfyUI na nuvem: quando faz sentido

Nem todos têm uma GPU com VRAM suficiente para os modelos mais recentes, e é aí que correr o ComfyUI num servidor remoto com GPU alugada por hora se torna uma alternativa razoável. O princípio é o mesmo da instalação manual descrita acima: clonar o repositório, instalar as dependências e arrancar o servidor, mas desta vez numa máquina na nuvem com uma GPU como a RTX 4090 ou superior. A diferença prática está em expor a porta 8188 de forma segura, já que, por padrão, o ComfyUI só escuta em localhost.

# Permitir acesso externo (usar só em redes privadas ou com autenticação adicional)
python main.py --listen 0.0.0.0 --port 8188

Correr na nuvem faz sentido sobretudo para quem precisa de gerar lotes grandes de imagens de forma pontual, para equipas que partilham a mesma instância entre vários membros, ou para quem quer testar modelos de vídeo muito exigentes em VRAM sem investir em hardware novo. Para uso diário e exploração pessoal, a instalação local continua a ser a opção mais simples e sem custos recorrentes.

Projeto completo: fluxo de texto para imagem com upscale

Para fechar o tutorial com um resultado prático e reutilizável, aqui fica a estrutura completa de um fluxo de trabalho que gera uma imagem a partir de texto e depois aplica upscale, pronta para carregar no ComfyUI. Guarde o conteúdo abaixo como ficheiro JSON na pasta de workflows e carregue-o através do menu “Load”:

{
  "nodes_resumo": [
    "CheckpointLoaderSimple -> carrega o modelo base",
    "CLIPTextEncode (positivo) -> descreve a imagem desejada",
    "CLIPTextEncode (negativo) -> descreve o que evitar",
    "EmptyLatentImage -> define resolução inicial (1024x1024)",
    "KSampler -> gera a imagem em latente (20 passos, dpmpp_2m, karras)",
    "VAEDecode -> converte o latente em imagem visível",
    "UpscaleModelLoader -> carrega modelo de upscale (ex: 4x-UltraSharp)",
    "ImageUpscaleWithModel -> aplica upscale à imagem final",
    "SaveImage -> guarda o resultado em output/"
  ]
}

Este fluxo representa o núcleo de praticamente todos os projetos de geração de imagem no ComfyUI: carregar, codificar, amostrar, decodificar e guardar. A partir desta base é fácil adicionar ControlNet para controlar a composição, LoRAs para estilos específicos, ou substituir o checkpoint por um modelo Flux para obter maior fidelidade a prompts complexos. Se o seu interesse é antes correr modelos de linguagem localmente em vez de imagem, o processo de instalação e gestão de dependências é muito parecido ao que descrevemos no tutorial do llama.cpp para correr o Llama 4 local.

ComfyUI vs AUTOMATIC1111: qual escolher em 2026

A pergunta mais comum de quem chega a este ponto é se ainda vale a pena aprender o ComfyUI em vez de ficar com uma interface mais simples. A tabela seguinte resume as diferenças práticas entre as duas opções mais populares.

CritérioComfyUIAUTOMATIC1111 WebUI
Estrelas no GitHub≈136 mil≈165 mil
Frequência de atualizaçõesQuase semanalPouco frequente nos últimos meses
Suporte a modelos novos (Flux, Qwen Image)Sim, rápido via comunidadeLimitado ou inexistente
Curva de aprendizagemAlta (baseado em nós)Baixa (formulários)
Controlo sobre o pipelineTotal, nó a nóLimitado às opções da interface
App Desktop oficialSim (Win/Mac/Linux)Não

Na prática, quem só quer gerar imagens simples de forma pontual pode continuar confortável com uma interface de formulário. Mas quem pretende construir fluxos repetíveis, combinar vários modelos no mesmo pipeline, ou simplesmente usar os modelos mais recentes do mercado no dia em que saem, encontra no ComfyUI a opção mais sustentável a médio prazo, precisamente porque a comunidade prioriza esta ferramenta ao lançar suporte para novidades. Esta filosofia de correr tudo localmente é a mesma que torna populares ferramentas como o Ollama e o LM Studio no mundo dos modelos de texto: mais controlo e privacidade, em troca de uma curva de aprendizagem inicial maior do que um serviço fechado.

Como manter o ComfyUI atualizado

Dado o ritmo de lançamentos do projeto, atualizar regularmente evita ficar sem suporte para modelos novos. Para atualizar uma instalação manual, pare o servidor e corra:

git pull
pip install -r requirements.txt --upgrade

Se usa a versão Desktop, a aplicação verifica automaticamente novas versões no arranque e mostra uma notificação quando há uma atualização disponível. Antes de atualizar em qualquer dos dois casos, vale a pena guardar uma cópia dos fluxos de trabalho importantes, já que, em casos raros, uma atualização maior pode alterar o nome ou o comportamento de nós antigos.

Vale também a pena acompanhar as notas de lançamento de cada versão antes de atualizar um ambiente de produção. Como o ritmo de novas versões é elevado, nem toda a atualização é obrigatória: se o fluxo de trabalho atual já cobre as suas necessidades e nenhum modelo novo que pretende usar exige a versão mais recente, pode esperar por uma atualização maior em vez de atualizar a cada lançamento semanal.

Perguntas frequentes sobre o ComfyUI

O ComfyUI é gratuito?
Sim, o ComfyUI é um projeto open source e gratuito, disponível no GitHub sob o nome de utilizador comfyanonymous. Os custos associados são apenas os de hardware (GPU) ou, caso opte por correr na nuvem, os de aluguer de servidores com GPU.

Preciso de uma GPU NVIDIA obrigatoriamente?
Não. O ComfyUI suporta oficialmente GPUs NVIDIA, AMD, Intel e Apple Silicon, além de execução em CPU (mais lenta). Para a melhor compatibilidade e desempenho, no entanto, NVIDIA continua a ser a opção mais testada pela comunidade.

Qual a diferença entre a instalação manual e o ComfyUI Desktop?
A instalação manual dá acesso total ao código e é mais fácil de personalizar, enquanto o Desktop embrulha tudo numa aplicação única, mais simples de instalar mas com menos flexibilidade para quem quer editar ficheiros diretamente.

O ComfyUI funciona com modelos de vídeo?
Sim. Através de nós personalizados instalados via ComfyUI Manager, é possível correr modelos de geração de vídeo, embora estes exijam normalmente mais VRAM do que a geração de imagens estáticas.

Posso partilhar os fluxos de trabalho que criei?
Sim, basta exportar o grafo como ficheiro JSON ou partilhar diretamente uma imagem gerada, já que o ComfyUI guarda os metadados do fluxo completo dentro do próprio ficheiro PNG.

Porque é que a minha geração está tão lenta?
Na maioria dos casos, o motivo é o PyTorch estar a correr em modo CPU em vez de usar a GPU. Confirme com o comando torch.cuda.is_available() indicado na secção de resolução de problemas.

O ComfyUI suporta o modelo Flux completo?
Sim, o Flux está listado entre os modelos com suporte nativo na documentação oficial, embora algumas variantes específicas possam exigir nós personalizados adicionais disponíveis através do Manager.

Vale a pena migrar do AUTOMATIC1111 para o ComfyUI?
Depende do uso. Quem só gera imagens pontuais pode manter-se no AUTOMATIC1111, mas quem quer acesso rápido a modelos novos e controlo total sobre o pipeline de geração tende a beneficiar da migração, apesar da curva de aprendizagem inicial mais acentuada.

Quanto espaço em disco preciso de reservar no total?
A aplicação em si ocupa menos de 5 GB, mas cada checkpoint de modelo pesa normalmente entre 2 GB e 12 GB, dependendo da família. Reserve pelo menos 50 GB se pretende guardar vários modelos, LoRAs e checkpoints de upscale ao mesmo tempo.

Posso correr o ComfyUI num portátil sem GPU dedicada?
Sim, mas com limitações sérias. A execução em CPU funciona para testes pontuais, mas o tempo de geração de uma única imagem pode passar de segundos para vários minutos, tornando o fluxo impraticável para uso diário.