ComfyUI su Linux: installazione e generazione immagini

ComfyUI è uno dei software più interessanti per chi vuole generare immagini con l’intelligenza artificiale mantenendo un controllo molto più avanzato rispetto alle interfacce tradizionali. A differenza di altri programmi che nascondono i dettagli tecnici, ComfyUI mostra esattamente come funziona il processo creativo, offrendo un controllo totale.

La sua logica si basa su un sistema a nodi, cioè su blocchi collegabili tra loro che rappresentano principalmente modelli, prompt, impostazioni, sampler, salvataggio dell’output.

In questa guida vediamo che cos’è ComfyUI, quali sono i requisiti minimi per usarlo, come installarlo in modo semplice su ambiente GNU/Linux e come creare un semplice workflow text-to-image per iniziare subito a generare la prima immagine.

Cos’è ComfyUI

ComfyUI è un’applicazione open source che utilizza un’architettura a nodi per gestire modelli di AI generativa (principalmente generazione di immagini e video). In pratica, invece di usare una schermata con pochi campi fissi, permette di costruire un workflow visuale collegando nodi diversi, così da controllare in modo molto preciso ogni fase della generazione. ComfyUI è sia un’interfaccia a nodi sia un motore di esecuzione per AI generativa e può essere eseguito direttamente in locale sul proprio computer.

Il progetto è nato soprattutto nel mondo Stable Diffusion, il modello open-source più diffuso, ma oggi supporta una gamma molto più ampia di modelli e casi d’uso. Esistono vari modelli per immagini, editing, video, audio, musica e 3D, oltre a funzioni come code di esecuzione, caricamento workflow da immagini con metadati, supporto di modelli personalizzati e tool di generazione avanzata.

Il punto forte di ComfyUI è la flessibilità. Se un’interfaccia classica è paragonabile a un programma con poche opzioni già pronte, ComfyUI assomiglia molto di più a un ambiente modulare dove puoi costruire pipeline personalizzate, riutilizzabili e scalabili.

Per sfruttare appieno la flessibilità di ComfyUI, è fondamentale distinguere tra i tipi principali di modello che l’interfaccia è in grado di caricare e combinare:

• Modelli base (come Stable Diffusion o Flux): rappresentano l’architettura fondamentale addestrata su dataset massivi e generici per essere il più possibile versatile, ma proprio per questo non ottimizzata per uno stile o un compito specifico.
• Checkpoint: sono versioni complete del modello base pronte all’uso, spesso più leggere o ottimizzate rispetto all’originale e che quasi sempre incorporano un addestramento aggiuntivo o una specializzazione (per questo sono detti anche modelli fine-tuned); non si usano insieme al modello base, ma lo sostituiscono direttamente come modello principale, offrendo risultati più coerenti con uno stile, un dominio o un tipo di output preciso (ad esempio illustrazioni anime, ritratti fotorealistici o concept art).
• LoRA: sono moduli leggeri che si applicano sopra il modello in uso, sia esso il base oppure un checkpoint, per introdurre modifiche mirate come particolari soggetti, stili o dettagli.

In pratica, un workflow può partire anche da un solo modello, base o checkpoint, e diventare progressivamente più specifico attraverso l’aggiunta di LoRA. Ad esempio, si può usare un checkpoint specializzato in ritratti realistici e aggiungere un LoRA che insegna al modello come rendere un preciso tipo di acconciatura, aggiungere un particolare tipo di soggetto o un’illuminazione.

Ecco i principali tipi di workflow di ComfyUI descritti sinteticamente:

• Text-to-Image: Generazione di immagini partendo esclusivamente da prompt testuali.
• Image-to-Image e Inpainting: Modifica, trasformazione o espansione di immagini esistenti.
• Controllo Condizionato: Guida precisa della generazione tramite vincoli geometrici o riferimenti visivi (ControlNet, IP-Adapter).
• Generazione Video: Creazione di sequenze animate e clip video (AnimateDiff, SVD).
• Upscaling e Refinement: Aumento della risoluzione e miglioramento dei dettagli dell’immagine.
• Training e Fine-Tuning: Addestramento e test di adattamenti di modelli personalizzati (LoRA).

Vantaggi e svantaggi di ComfyUI

Prima di installare ComfyUI, è utile capire bene quali sono i suoi punti di forza e quali, invece, possono rappresentare un limite soprattutto nelle prime fasi di utilizzo. In questo modo potrai valutare con maggiore consapevolezza se si tratta davvero dello strumento più adatto al tuo modo di lavorare.

Vantaggi di ComfyUI

• Workflow condivisibili e riutilizzabili: un aspetto molto interessante è che i flussi di lavoro possono essere salvati e condivisi con facilità. Questo rende ComfyUI particolarmente utile anche per chi vuole studiare configurazioni già pronte, importare setup creati da altri utenti o riutilizzare i propri workflow nel tempo.
• Controllo molto più preciso del workflow: uno dei maggiori vantaggi di ComfyUI è l’approccio basato su nodi, che consente di costruire il flusso di lavoro in modo modulare e dettagliato. Questo significa che ogni fase del processo può essere gestita con maggiore precisione, potendo combinare nodi, parametri e passaggi diversi in base alle tue esigenze.
• Utilizzo in locale: ComfyUI funziona in locale sul proprio hardware, quindi non è necessario appoggiarsi per forza a servizi cloud. Questo approccio è vantaggioso per chi desidera più autonomia, maggiore controllo dell’ambiente di lavoro e una gestione più diretta dei propri file.
• Buona espandibilità: non si limita solo a immagini e video, infatti esiste la possibilità di lavorare con modelli aggiuntivi e personalizzati di vario tipo, tramite nodi custom ed estensioni.

Svantaggi di ComfyUI

• Curva di apprendimento più alta: rispetto ad altre interfacce più immediate, ComfyUI può risultare inizialmente meno intuitivo e più tecnico del necessario. Nelle prime fasi è necessario capire almeno la logica di base dei nodi, delle connessioni e dei componenti principali del workflow, inclusi i parametri più importanti.
• Interfaccia meno uniforme: un limite pratico dell’approccio node-based è che i workflow possono apparire molto diversi tra loro. Questo rende ComfyUI estremamente flessibile, ma a volte anche meno immediato da leggere, soprattutto quando si importano workflow creati da altri.
• Richiede maggiore attenzione alla compatibilità: quando inizi ad aggiungere modelli, nodi custom o estensioni, può diventare necessario controllare con più cura dipendenze, versioni di Python e compatibilità fra nodi e modelli.
• Dipendenza dall’hardware locale: usare ComfyUI in locale è un vantaggio, ma comporta anche dei vincoli. Se l’hardware non è adeguato, oppure se lo spazio disponibile e le risorse non sono sufficienti, l’esperienza può diventare lenta o meno pratica da gestire.

In pratica, ComfyUI è una scelta molto valida per chi vuole flessibilità, controllo e possibilità di espansione nel tempo. Al contrario, chi preferisce un approccio più semplice e immediato potrebbe trovarlo inizialmente meno comodo.

Requisiti

I requisiti reali dipendono dal tipo di modello che si vuole usare, ma ci sono alcune basi minime da considerare per una configurazione iniziale stabile.

• Un sistema Linux aggiornato come ad esempio Debian 13.0 o Ubuntu 26.04.
• Python: Python 3.9 o superiore (Python 3.13 attualmente consigliato; Python 3.14 potrebbe dare problemi con nodi custom).
• GPU: minimo 4 GB VRAM per modelli SD1.5/SDXL base; 8 GB+ raccomandati per flussi complessi e modelli più pesanti; necessario relativo stack software installato (CUDA o ROCm in base alla GPU).
• Spazio su disco: almeno 10–12 GB per iniziare (include alcuni modelli base da installare a parte, che generalmente pesano più di 2 GB l’uno)
• Browser compatibile: Secondo la documentazione ufficiale, per la migliore esperienza d’uso si consiglia un browser aggiornato basato su Chromium.

Se sei ancora incerto sull’installarlo, puoi saltare l’installazione e provare ComfyUI gratuitamente su runcomfy.com per prendere confidenza con l’interfaccia. Tieni però presente che è necessaria la registrazione per generare immagini e che ci sono dei limiti d’uso.

Preparare il sistema

ComfyUI è un’applicazione locale che si può installare e gestire da riga di comando tramite comfy-cli. In pratica, questa rappresenta una soluzione molto comoda per chi preferisce lavorare in ambiente self-hosted e vuole tenere sotto controllo installazione, avvio e manutenzione, senza dover installare pacchetti manualmente.

Su Linux, usare pipx per installare il client CLI di Comfy è una scelta particolarmente conveniente, perché crea un ambiente virtuale dedicato per ogni applicazione Python eseguibile da terminale, tenendo le sue dipendenze separate dal resto dei pacchetti installati sul sistema.

Come primo passaggio, aggiorniamo l’elenco dei pacchetti e installiamo gli strumenti necessari. Apri il terminale ed esegui:

sudo apt update
sudo apt install -y python3 python3-pip python3-venv pipx git

A questo punto abilita il path di pipx, in modo da poter richiamare i comandi installati direttamente dal terminale:

pipx ensurepath

Dopo questo comando, chiudi e riapri il terminale. In alternativa, se la tua shell lo consente, ricarica il profilo con:

source ~/.bashrc

Installare comfy-cli con pipx

Per riferimento, la documentazione ufficiale sull’installazione di comfy-cli si trova qui, mentre questa è la sua pagina GitHub.

Ora possiamo installare il client ufficiale da riga di comando in modo isolato, senza sporcare l’ambiente Python globale:

pipx install comfy-cli

Terminata l’installazione, verifica che tutto sia andato a buon fine:

comfy --help

Se vedi l’help del comando, sei pronto per passare allo step successivo.

Installare ComfyUI con comfy install

A questo punto, eseguendo il comando, ComfyUI viene installato automaticamente all’interno della cartella home in ~/comfy:

comfy install

Alternativamente, se invece vuoi scegliere tu la cartella di installazione, puoi creare una nuova cartella e usare l’opzione --workspace. In questo caso il comando sarà:

comfy --workspace=/tuo/percorso/nuova_cartella/ install

In questo modo, ComfyUI verrà installato dentro /tuo/percorso/nuova_cartella/ComfyUI.

Non appena avviato il comando per la prima volta verrà chiesto se vuoi condividere la telemetria per migliorare l’applicazione. Se non volete condividerla digitate N e premete invio.

Segui la procedura guidata proposta dal comando, scegliendo fra Nvidia, AMD e Intel Arc in base alla tua GPU e confermando il download nel percorso indicato. Verrà clonata la repository da GitHub e verrà creata la cartella in cui verranno installate tutte le dipendenze in maniera automatica.

Come usare ComfyUI dopo l’installazione

Se stai iniziando adesso, la configurazione più semplice è quella orientata alla prima generazione text-to-image. La procedura iniziale prevede il caricamento del workflow predefinito, l’installazione del modello mancante e la generazione della prima immagine.

1. Avvia ComfyUI

Una volta completata l’installazione, puoi avviare ComfyUI direttamente dal terminale con:

comfy launch

Al primo avvio, attendi qualche secondo in più del normale, perché il sistema potrebbe completare inizializzazioni e controlli interni. Quando l’avvio è completato, apri nel browser l’indirizzo locale mostrato nel terminale, normalmente http://127.0.0.1:8188.

2. Carica il workflow

Una volta aperta la pagina di ComfyUI sul browser, al primo avvio dovrebbe aprirsi la sezione Getting Started della libreria dei template. In alternativa puoi aprire la medesima libreria cliccando su Templates nella barra laterale sinistra e una volta aperta premere sulla sezione Getting Started. A questo punto puoi selezionare il template base Image Generation (l’ultimo in fondo).

In alternativa puoi provare con il primo template proposto, Starter – Text To image. La differenza sta nel checkpoint utilizzato, nel prompt iniziale e nel fatto che questo template contiene più dettagli ed elementi informativi utili per chi inizia, ma a primo impatto può risultare un po’ più dispersivo e difficile da seguire.

Ora dovreste vedere il workflow già pronto (se non lo leggete zoomate). Come si vede dall’immagine sotto, il workflow è fatto da nodi, i quali non sono altro che blocchi collegabili fra loro. I workflow si leggono da sinistra verso destra: ogni nodo ha input a sinistra e output a destra. L’output di un nodo finisce nell’input di un altro e così via. Questo va a costituire il workflow, in cui ogni nodo ha una funzione diversa.

I nodi possono essere spostasti trascinandoli, e lo stesso vale per i riquadri celesti che servono a raggruppare e spostare più nodi insieme al loro interno. Per collegare fra loro i nodi, seleziona e trascina uno fra gli output di un nodo verso l’input di un altro. Puoi eliminare collegamenti premendo il cerchio al centro della linea di collegamento e selezionando delete.

3. Installa il modello checkpoint

Di default, ComfyUI non fornisce modelli principali già pronti. Infatti, l’interfaccia dovrebbe mostrare un avviso di un file mancante, il modello checkpoint v1-5-pruned-emaonly-fp16.safetensors oppure DreamShaper_8_pruned.safetensors, in base al template selezionato precedentemente. Premendo su Show missing models in alto a destra (vedi ultima figura del punto 2) si apre l’overview del workflow sulla destra. Premere su Download  per scaricare il modello proposto (entrambi occupano circa 2 GB).

Ecco le differenze fra i due modelli:

• Stable Diffusion 1.5 (v1-5-pruned-emaonly): è una versione più leggera ottimizzata del modello base ufficiale SD1.5, generico e versatile. Essendo neutro e privo di uno stile predefinito, è estremamente versatile, ma può richiedere prompt specifici e dettagliati per ottenere risultati di alta qualità.
• DreamShaper: è un modello fine-tuned basato su SD1.5. Eccelle in realismo, arte concettuale e ritrattistica. Si distingue per la capacità di generare output di qualità con prompt brevi, pur essendo particolarmente indicato solamente per gli stili artistici menzionati.

Attenzione: i modelli scaricati vanno inseriti manualmente nelle cartelle corrette dentro ComfyUI/models/. In particolare, i modelli checkpoint (come v1-5-pruned-emaonly-fp16.safetensors e DreamShaper_8_pruned.safetensors) vanno salvati nella sottocartella ComfyUI/models/checkpoints, mentre altri componenti e modelli come LoRA o di upscaling hanno altre directory dedicate.

ComfyUI, a differenza di altre interfacce, non scansiona automaticamente i file per categorizzarli: richiede che l’utente conosca il percorso esatto del modello per selezionarlo nei nodi (es. Load Checkpoint). Organizzare i file in sottocartelle logiche basate sui modelli principali (come SD1.5, SDXL, Flux) facilita quindi l’individuazione e il caricamento del modello corretto, mantenendo pulita la directory principale.

Si consiglia perciò di creare una nuova sottocartella dentro checkpoints chiamata SD1.5 in cui salvare il checkpoint scaricato, in quanto entrambi i checkpoint proposti sopra derivano dal modello base Stable Diffusion 1.5.

4. Controlla il nodo Load Checkpoint

Una volta copiato il modello nella cartella corretta, premi il tasto R per aggiornare la lista dei modelli, oppure ricarica la pagina, così da vedere il nome del file checkpoint caricato nel nodo Load Checkpoint. Se si ha più di un checkpoint è sufficiente premere sulle frecce del nodo per cambiare modello, oppure premere sul nome del checkpoint e selezionare il particolare modello dalla lista.

5. Avvia la generazione

Nel workflow base, il modello viene caricato dal nodo Load Checkpoint, il testo viene elaborato dai nodi di encoding e l’immagine passa poi nel sampler e nel nodo finale di salvataggio. Per eseguire il workflow puoi usare il pulsante Run oppure la scorciatoia Ctrl + Enter. Attendi che l’immagine venga generata.

Come modificare il template del workflow base

Una volta generata correttamente la prima immagine con il workflow predefinito, il passo successivo è iniziare a modificarlo per capire meglio come funziona. L’obiettivo sarebbe riconoscere i blocchi principali del flusso, capire a cosa servono e individuare i parametri che influenzano di più il risultato finale.

Nel template base text-to-image, i nodi essenziali sono pochi e seguono una logica abbastanza lineare: si carica un modello, si codifica il testo del prompt, si genera una “base rumorosa” da cui parte la creazione dell’immagine, si esegue la generazione, si decodifica l’immagine e infine la si salva. Capire bene questi passaggi è il modo più semplice per iniziare a personalizzare il workflow senza perdersi tra nodi più avanzati.

Nota: le informazioni e i consigli che seguono valgono principalmente per modelli basati su Stable Diffusion (SD 1.5, SDXL e derivati), di cui fanno parte i checkpoint v1-5-pruned-emaonly-fp16.safetensors e DreamShaper_8_pruned.safetensors dei template predefiniti. Ogni modello base può avere nodi specifici, range di parametri diversi e modi ottimali di scrivere i prompt, quindi quanto descritto qui non si applica direttamente ad altri modelli come Flux, Playground o architetture più recenti.

1. Load Checkpoint

Questo nodo è il punto di partenza del workflow, perché carica il modello principale dalla cartella models/checkpoints/. Il file selezionato, in formato .safetensors (o .ckptnel vecchio formato), contiene i componenti fondamentali necessari alla generazione: MODEL, che è il motore principale della generazione e parte da un’immagine iniziale fatta di rumore casuale per trasformarla, passo dopo passo, in un’immagine che rispecchia le istruzioni date; CLIP, che interpreta il prompt testuale e lo traduce in istruzioni che il modello può seguire; e VAE, che alla fine prende il risultato prodotto dal modello e lo trasforma in un’immagine vera e propria, pronta per essere visualizzata e salvata.

Qui l’unico parametro è ckpt_name, che permette di scegliere quale checkpoint usare. Se nella cartella sono presenti più modelli, è proprio da qui che puoi cambiarli per provare stili o comportamenti diversi. Le tre uscite del nodo, MODEL, CLIP e VAE, vanno poi collegate rispettivamente al KSampler, ai nodi CLIP Text Encode e al nodo VAE Decode.

2. CLIP Text Encode

Nei workflow base (generalmente basati su modelli Stable Diffusion) questo nodo compare normalmente due volte: una per il prompt positivo e una per il prompt negativo. Il nodo CLIP Text Encode funge da text encoder: il suo compito è prendere il testo scritto dall’utente e trasformarlo in un formato numerico che il modello possa interpretare. In altre parole, è il passaggio che traduce le istruzioni testuali in informazioni utili alla generazione.

Il prompt positivo descrive ciò che vuoi ottenere nell’immagine, per esempio un soggetto, uno stile, un’atmosfera o alcuni dettagli specifici. Il prompt negativo, invece, serve a indicare cosa evitare, come artefatti, sfocature o qualsiasi elemento indesiderato. Il parametro principale è semplicemente il campo text, ed è uno dei punti in cui conviene sperimentare di più.

Per scrivere un prompt efficace con i modelli basati su Stable Diffusion (SD), alcune linee guida utili sono:

• Usa solo inglese: i modelli SD supportano nativamente solo l’inglese. Se non sei pratico, puoi usare strumenti di IA (come ChatGPT, Copilot o altri LLM) per generare prompt ottimizzati o tradurli in inglese, oppure installare un’estensione per tradurre direttamente in ComfyUI.
• Usa elenchi di descrittori: per questi modelli in genere funziona meglio scrivere liste di parole chiave separate da virgole (es. “portrait, fantasy style, dramatic lighting, detailed eyes”) piuttosto che frasi lunghe in linguaggio naturale.
• Dettagli progressivi: inizia con una descrizione chiara del soggetto, poi aggiungi stile, atmosfera, illuminazione e dettagli tecnici.
• Ordine delle parole: i primi token hanno più peso, quindi metti all’inizio gli elementi più importanti (soggetto, stile, composizione).
• Regola il peso delle parole: selezionando una parola all’interno del campo del nodo CLIP Text Encode, è possibile aumentarne e diminuirne il peso rispettivamente tramite Ctrl + ↑ e Ctrl + ↓ in passi da 0.05 (il peso di default è 1).
• Prompt negativi comuni: per molti modelli SD funzionano bene prompt negativi generici come “low quality, bad proportions, blurry, bad anatomy, extra limbs, artifacts”.
• Limita la complessità: i modelli SD di base non sono molto bravi a gestire più soggetti nella stessa immagine o riferimenti spaziali precisi (es. “a sinistra di”, “dietro”). Per ovviare a questi limiti bisogna usare modelli più avanzati o strumenti aggiuntivi come ControlNet.
• Sperimenta: piccoli cambiamenti nel prompt possono produrre risultati molto diversi, quindi conviene provare più varianti.

L’output di ciascuno dei due nodi (positivo e negativo) è un segnale di condizionamento che va collegato rispettivamente agli ingressi positive e negative del KSampler.

3. Empty Latent Image

Questo nodo crea il punto di partenza della generazione. Per capire cosa fa, è utile chiarire prima cosa si intende per spazio latente. Invece di lavorare direttamente sui pixel dell’immagine finale, che sarebbero moltissimi e richiederebbero molti calcoli, i modelli come Stable Diffusion operano su una rappresentazione molto più compatta dell’immagine, chiamata appunto spazio latente.

Puoi pensarlo come una “versione compressa” dell’immagine, in cui le informazioni essenziali sono mantenute ma in forma più leggera. Il modello genera l’immagine in questo spazio compresso, e solo alla fine viene convertita in pixel veri e propri.

Il nodo Empty Latent Image prepara quindi questa “tela compressa” da cui parte la generazione. All’inizio contiene solo rumore casuale, che il modello trasformerà progressivamente in un’immagine coerente con il prompt. I parametri più utili da conoscere sono width e height, che definiscono la risoluzione dell’immagine, e batch_size, che indica quante immagini generare in una singola esecuzione.

Modificare questi valori è uno dei modi più immediati per personalizzare il workflow, ma è importante ricordare che ogni modello è stato addestrato su certe risoluzioni tipiche: se si usano dimensioni molto diverse da quelle per cui il modello è stato allenato, la qualità può peggiorare o possono comparire distorsioni. Per SD1.5, impostare i parametri width e height tra 512-768px e non oltre.

L’output dato da queste impostazioni è una rappresentazione latente iniziale, che va collegata all’ingresso latent_image del KSampler.

4. KSampler

Il KSampler è il nodo centrale del workflow, cioè quello che esegue materialmente il processo di generazione. Riceve il modello, le informazioni testuali positive e negative e il punto di partenza nello spazio latente, quindi applica il processo di denoising passo dopo passo. In pratica, parte dal rumore casuale creato dal nodo Empty Latent Image e lo trasforma gradualmente in un’immagine sempre più definita e coerente con il prompt.

I parametri principali del KSampler sono:

• seed: controlla la casualità; fissando lo stesso valore si ottiene lo stesso risultato, cambiandolo si generano varianti diverse. Puoi impostare il parametro control_after_generate su fixed per mantenere il seed fisso (o modificarlo manualmente quando vuoi), oppure lasciarlo su randomized per farlo cambiare automaticamente a ogni generazione.
• steps: indica quanti passaggi di generazione eseguire; più passaggi tendono a dare immagini più raffinate, ma richiedono più tempo. Come punto di partenza, per molti modelli Stable Diffusion si usano spesso circa 20-30 steps.
• cfg (Classifier Free Guidance): regola quanto il modello deve seguire fedelmente il prompt; valori alti rendono il risultato più aderente al testo, ma possono introdurre artefatti, mentre valori bassi danno più libertà al modello. Un valore iniziale tipico modelli Stable Diffusion è tra 7 e 9.
• sampler_name e scheduler: determinano il metodo e la strategia con cui il rumore viene rimosso. Per questi non esistono valori “giusti” in senso assoluto; all’inizio puoi lasciarli invariati, perché il loro effetto è generalmente meno evidente rispetto a parametri come steps, cfg e risoluzione.
• denoise: indica quanto il modello deve modificare l’immagine latente di partenza. Nel caso classico di text-to-image, dove si parte da rumore puro, questo valore va lasciato a 1, in modo che il modello possa trasformare completamente il rumore iniziale. Valori inferiori a 1 si usano in scenari più avanzati, ad esempio quando si parte da un’immagine esistente e se ne vuole conservare in parte la struttura.

All’inizio conviene modificarne uno alla volta, così da capire meglio l’effetto di ciascun parametro.

L’output del nodo KSampler è una rappresentazione latente dell’immagine generata, che non è ancora visibile ma è pronta per essere decodificata: va collegata all’ingresso del nodo VAE Decode.

5. VAE Decode

Il risultato del KSampler non è ancora un’immagine visibile, ma una rappresentazione nello spazio latente. Il nodo VAE Decode serve proprio a convertirla in un’immagine vera e propria utilizzando il componente vae caricato dal checkpoint. È il passaggio che trasforma il contenuto generato dal modello in qualcosa che puoi effettivamente vedere e salvare.

Nel workflow base questo nodo non richiede in genere particolari modifiche, perché il suo ruolo è soprattutto tecnico. Riceve in input la connessione vae dal nodo Load Checkpoint e la rappresentazione latentesamples dal KSampler, restituendo in output un’immagine vera e propria.

6. Save Image

Questo è il nodo finale del workflow. Il suo compito è prendere l’immagine prodotta dal nodo VAE Decode e salvarla nella cartella output/ di ComfyUI. Oltre al file immagine, questo nodo può conservare anche metadati utili, come prompt, seed e altre impostazioni di generazione, così da facilitare la riproduzione del risultato in un secondo momento.

L’unico parametro è filename_prefix, che permette di organizzare meglio i file generati assegnando loro un prefisso personalizzato. A seconda della configurazione, possono essere disponibili anche altre opzioni relative al formato o al salvataggio.

Come iniziare a modificarlo

Per prendere confidenza con il template base, conviene iniziare da modifiche semplici e facili da osservare. Per esempio, puoi cambiare il testo nei nodi CLIP Text Encode, provare risoluzioni diverse nel nodo Empty Latent Image, oppure intervenire su steps, cfg e seed nel KSampler per vedere come cambia il risultato.

Un altro esperimento utile è sostituire il checkpoint nel nodo Load Checkpoint per confrontare modelli diversi. La piattaforma più utilizzata e popolare per scaricare modelli è CivitAI, ma è importante verificare che i checkpoint siano compatibili con i nodi che stai usando e con il tipo di workflow (ad esempio, checkpoint per SD 1.5 non funzionano bene con workflow pensati per SDXL).

Con il tempo puoi poi aggiungere altri nodi (con un doppio clic), come LoRA, ControlNet o strumenti di upscaling, ma la logica rimane la stessa: ogni nodo svolge una funzione precisa, riceve dati in ingresso e produce dati in uscita da collegare in modo coerente agli altri blocchi del workflow. Quando hai finito puoi salvare il workflow con Ctrl + S. Per approfondimenti, puoi visitare la wiki ufficiale di ComfyUI.

In conclusione, quello di ComfyUI e della generazione di immagini con AI è un ambito molto vasto, in cui c’è sempre qualcosa di nuovo da imparare, approfondire e sperimentare fra i vari modelli. Con le basi viste finora hai già gli strumenti per iniziare a costruire e modificare i tuoi workflow in autonomia: da qui in poi, sarà soprattutto la pratica e la sperimentazione a fare la differenza.

FAQ

Quale versione di Python conviene usare?

La scelta consigliata è Python 3.13, che al momento rappresenta l’opzione più raccomandata. Se dovessi notare problemi o incompatibilità particolari, Python 3.12 è il fallback migliore, mentre Python 3.14 resta utilizzabile ma può creare problemi con alcuni nodi custom.

Meglio pipx o pip classico?

Se vuoi un’installazione più pulita di comfy-cli, pipx è una scelta molto sensata. Ti permette infatti di usare il comando comfy senza mescolare pacchetti e dipendenze dell’ambiente Python globale e senza dover creare a mano ambienti virtuali.

Qual è il comando corretto per installare ComfyUI?

Dopo aver installato comfy-cli, il comando da usare è semplicemente:

comfy install

Come si avvia ComfyUI?

Avendo installato ComfyUI tramite comfy-cli, il comando di riferimento per il lancio dell’applicazione è:

comfy launch

Per usare la GPU su Linux serve altro?

Sì, in genere è necessario avere già predisposto lo stack corretto in base all’hardware. In particolare, lato Linux possono essere richiesti CUDA (su Nvidia) oppure ROCm (AMD), a seconda della GPU utilizzata.

Dove posso scaricare modelli per generare immagini?

La piattaforma più utilizzata e popolare per scaricare modelli è CivitAI. In alternativa, puoi utilizzare anche Hugging Face.

Come si aggiorna ComfyUI?

Avendo installato ComfyUI tramite comfy-cli, il comando di riferimento per l’aggiornamento dell’applicazione è:

comfy update

Come si aggiungono nodi custom?

Il metodo più semplice è usare il Nodes Manager (anche detto ComfyUI-Manager), che permette di cercare, installare, aggiornare e rimuovere nodi custom direttamente dall’interfaccia. Vi si accede andando a cliccare sul menù della barra laterale in alto a sinistra (sul logo “C” sopra Job History) e selezionando Extensions.  Se un nodo non è disponibile tramite Manager o non è presente nella libreria, puoi procedere anche con l’installazione manuale nella cartella custom_nodes di ComfyUI.

Come si cambia la porta di default (8188)?

Avendo installato ComfyUI tramite comfy-cli, il comando di riferimento per modificare la porta predefinita è:

comfy launch -- --port XXXX

dove a XXXX va sostituito il numero della nuova porta.

Come si esportano i workflow?

I workflow possono essere salvati ed esportati in formato JSON, che rappresenta il formato strutturato del workflow di ComfyUI. Per esportare un workflow, assicurati che sia caricato e salvato, quindi vai nel menu File in alto a sinistra, seleziona Export e conferma il nome. In alternativa, fai clic-destro sulla rispettiva tab in alto e seleziona Export.

Come si importano i workflow?

Per importare un workflow, vai nel menu File in alto a sinistra, seleziona Open e apri un workflow in formato JSON. In alternativa puoi trascinare il file direttamente sul canvas di ComfyUI, o anche copiare il contenuto testuale di un file JSON e incollare con Ctrl + V in un punto vuoto del canvas.

Come si installa un modello manualmente?

Se scarichi un modello manualmente, devi copiarlo nella sottocartella corretta dentro ComfyUI/models/. Per esempio, i checkpoint vanno in ComfyUI/models/checkpoints, mentre LoRA, VAE e altri componenti hanno directory dedicate (consulta la wiki ufficiale per maggiori informazioni); dopo aver copiato i file, aggiorna l’interfaccia o ricarica la lista dei modelli per farli comparire nei nodi.

Come si risolvono errori comuni come nodi mancanti o incompatibilità?

Se apri un workflow e mancano alcuni nodi, ComfyUI Manager può aiutarti a identificare e installare i file necessari, anche mostrando direttamente i nodi mancanti nel workflow tramite avvisi. Se invece incontri errori di esecuzione o incompatibilità (spesso dovuti a versioni obsolete), assicurati di aver installato l’ultima versione del nodo e che non esistano conflitti con nodi custom installati (Nodes Manager indica la presenza di conflitti nella sezione Conflicting). Nel caso puoi disattivarli.

Come migliorare la qualità dell’immagine se risulta sfocata, distorta o con artefatti?

Se l’immagine generata ha una qualità bassa, appare sfocata o presenta problemi evidenti (artefatti, anatomia errata, distorsioni), le cause più comuni sono:

• Steps troppo bassi: aumentare il numero di steps (es. da 20 a 30-40) può migliorare la definizione.
• CFG inadeguato: un valore CFG troppo alto o troppo basso può causare artefatti o immagini poco aderenti al prompt. Per SD1.5/SDXL, un buon punto di partenza è tra 7 e 9.
• Sampler non ottimale: i sampler ancestral (contengono “a” o “ancestral” nel nome) introducono casualità a ogni step, portando a risultati meno prevedibili e talvolta di qualità inferiore. Per risultati più stabili, usare sampler deterministici come euler, heunn, dpmpp_2m.
• Risoluzione non compatibile: usare risoluzioni troppo alte o non native per il modello può degradare la qualità. Per SD1.5, attenersi a 512-768px; per SDXL, 1024px o multipli.
• Prompt troppo complesso o vago: prompt lunghi, contraddittori o poco descrittivi possono confondere modelli SD. Usare descrittori chiari, separati da virgole, ed evitare troppi concetti in una singola generazione.
• LoRA o checkpoint incompatibili: alcuni LoRA o checkpoint non funzionano bene insieme o con certi modelli. Provare a disabilitare i LoRA uno alla volta per identificare conflitti.
• VAE non ottimale: in alcuni casi, cambiare VAE può migliorare colori e dettagli.

In breve: aumentare steps, regolare CFG, cambiare sampler, usare risoluzioni native, semplificare il prompt, testare checkpoint e LoRA singolarmente, e consultare i suggerimenti specifici per il modello usato su CivitAI.

Come si risolve l’errore “out of memory”?

L’errore OutOfMemoryError indica che la VRAM della GPU si satura e perciò non è sufficiente per la combinazione data dal modello, risoluzione e il batch size selezionati. Le soluzioni più efficaci sono:

• Usare modelli più leggeri: passare a checkpoint quantizzati (GGUF, NF4) o modelli più piccoli. Come regola pratica, la somma del peso dei file dei componenti attivi (Modello UNet + Text Encoder + VAE, oppure direttamente il modello checkpoint se contiene tutti e tre i componenti in un unico file) deve rimanere sotto il 85-90% della VRAM totale della tua GPU.
• Ridurre la risoluzione: abbassare width/height nei parametri del nodo Empty Latent Image.
• Diminuire il batch size: impostare batch size a 1 per ridurre il carico di memoria.
• Chiudere altre applicazioni GPU: liberare VRAM chiudendo browser, giochi o altri programmi che usano la GPU.
• Liberare manualmente la VRAM: in alcuni casi può essere utile ripulire manualmente la memoria VRAM. Vai nel menu in alto a sinistra, clicca sul  sul logo “C” , vai su Edit e seleziona Unload Models and Execution Cache. Questa azione scarica immediatamente i modelli dalla VRAM insieme alla cache di esecuzione.
• Disabilitare VRAM dinamica: in alcuni casi, aggiungere la flag--disable-dynamic-vram al comando di lancio (aggiungi un ulteriore -- prima della flag) risolve problemi di gestione della memoria.

Se il problema persiste, può essere necessario aggiornare i driver CUDA o ROCm, provare a reinstallare o considerare un upgrade hardware.

Cosa fare se ComfyUI non si avvia e dà errore?

Se ComfyUI non si avvia o mostra un errore immediato, le cause più comuni sono conflitti di processi bloccati, driver GPU non aggiornati, dipendenze mancanti o incompatibilità con Python. Ecco i passaggi per risolvere:

• Verifica i log di errore: apri il terminale da cui hai avviato ComfyUI e leggi il messaggio di errore completo, che spesso indica la causa (es. CUDA, modulo mancante, porta già occupata).
• Chiudi i processi bloccati: in alcuni casi, processi ComfyUI precedenti rimangono in background e bloccano l’avvio. Identifica il processo e terminalo manualmente.
• Aggiorna i driver GPU: scarica e installa l’ultima versione dei driver GPU, perché driver obsoleti possono causare crash all’avvio.
• Ricarica i moduli del kernel relativi alla GPU: ad esempio con una scheda Nvidia, usare questo comando  sudo modprobe -r nvidia_uvm && sudo modprobe nvidia_uvm.
• Controlla Python e le dipendenze: assicurati di usare una versione di Python compatibile (3.9–3.13) e reinstalla le dipendenze tramite comfy-cli.
• Porta già occupata: se la porta 8188 è già in uso, cambia la porta di avvio aggiungendo --port 8189 al comando di lancio seguito da --.
• Disabilita funzionalità opzionali: in caso di errori CUDA, prova ad avviare con flag come --disable-cuda-malloc (aggiungi un ulteriore -- prima della flag).