ComfyUI einrichten 2026: Installation in 13 Schritten

ComfyUI hat sich 2026 zur meistgenutzten Oberfläche für lokale KI-Bildgenerierung entwickelt. Allein in Deutschland verzeichnet der Suchbegriff “ComfyUI” laut aktuellen Keyword-Daten über 27.000 Suchanfragen pro Monat, die Konkurrenz um diesen Begriff gilt als niedrig. Am 5. Oktober 2026 veröffentlichte das Comfy-Org-Team Version 0.39.0, die unter anderem ein DynamicGroup-Widget sowie Updates für ElevenLabs, Save EXR und Save Video mitbringt. Dieser Leitfaden zeigt in 13 Schritten, wie du ComfyUI von null auf ein funktionierendes Setup mit Custom Nodes, Modellen und einem eigenen Workflow bringst, inklusive aller Stolperfallen, die uns beim Testen begegnet sind.

Was ist ComfyUI und warum lohnt sich die Installation 2026?

ComfyUI ist eine node-basierte Oberfläche für Diffusionsmodelle. Statt wie bei Automatic1111 oder Forge über feste Formulare zu arbeiten, baust du dir in ComfyUI einen Graphen aus einzelnen Verarbeitungsschritten: ein Node lädt das Checkpoint, ein anderer kodiert den Prompt, ein dritter sampelt das Bild, ein vierter speichert das Ergebnis. Jeder Schritt ist sichtbar und austauschbar. Für Einsteiger wirkt das zunächst sperrig, zahlt sich aber aus, sobald ein Workflow komplexer wird, etwa mit ControlNet, Upscaling oder Video-Generierung.

Das Projekt wird mittlerweile unter der Organisation Comfy-Org auf GitHub gepflegt, der ursprüngliche Entwickler-Account comfyanonymous bleibt als zentrale Figur in der Commit-Historie sichtbar. Laut dem offiziellen Changelog ist v0.39.0 vom 5. Oktober 2026 die aktuelle Version, nur wenige Tage nach v0.38.0 veröffentlicht. Das Tempo der Entwicklung ist beachtlich: Neue Releases erscheinen im Schnitt mehrmals pro Monat, oft mit Verbesserungen an der API, dem Node-Editor oder der Kompatibilität zu neuen Modellen wie SD3.5 und der Flux-Familie.

Ein wichtiger Unterschied zu 2025: Der ComfyUI-Manager, lange Zeit eine separate Erweiterung, die man selbst nachinstallieren musste, ist laut einem Blogbeitrag von Comfy-Org inzwischen offiziell in ComfyUI integriert. Wer mit der Comfy Desktop-App arbeitet, bekommt den Manager automatisch mitinstalliert und über den Schalter --enable-manager aktiviert. Das senkt die Einstiegshürde erheblich, weil das lästige manuelle Klonen von Custom-Node-Repositories für die meisten Anwendungsfälle wegfällt.

Für Nutzer in Deutschland und der DACH-Region kommt ein weiterer Punkt dazu: Bilder, Prompts und Modelle bleiben bei einer lokalen ComfyUI-Installation auf der eigenen Maschine, es wandert nichts zu einem externen Cloud-Dienst. Wer aus Datenschutzgründen oder wegen interner Vorgaben keine Bildgenerierungs-Prompts bei einem US-Anbieter einreichen will, bekommt mit ComfyUI eine vollständig selbst kontrollierte Alternative. Das macht das Tool nicht nur für Hobby-Anwender, sondern zunehmend auch für Agenturen und Entwicklungsteams interessant, die Bildgenerierung in eigene Produkte integrieren wollen, ohne laufende API-Kosten pro generiertem Bild zu zahlen.

Node-Graph statt Formular: der zentrale Unterschied

Der Begriff “node-basiert” wirkt beim ersten Lesen abstrakt, dahinter steckt aber ein einfaches Prinzip. Jede Aktion, die ein Bild verändert, lädt oder speichert, ist ein eigener Kasten im Graphen, ein Node. Diese Nodes werden über Linien verbunden, die den Datenfluss zeigen, etwa ein Bild von einem Lade-Node zu einem Verarbeitungs-Node. Weil jeder Node einzeln sichtbar ist, lässt sich an jeder Stelle der Pipeline eingreifen, etwa ein zusätzliches Upscaling nach dem Sampling einschieben oder einen zweiten Sampler für eine Nachbearbeitung in Serie schalten. Formularbasierte Tools verstecken diese Zwischenschritte hinter wenigen Reglern, was den Einstieg erleichtert, aber bei komplexen Aufgaben schnell an Grenzen stößt.

Voraussetzungen: Diese Software und Hardware brauchst du

Bevor du ComfyUI installierst, solltest du folgende Punkte prüfen. Die Angaben zu Python und PyTorch orientieren sich an den von Comfy-Org gepflegten Installationsanleitungen, exakte Mindestversionen ändern sich mit jedem größeren Release, deshalb lohnt sich vor der Installation immer ein kurzer Blick in die offizielle Dokumentation.

Betriebssystem: Windows 10 oder neuer (x64 und ARM64 werden für die Desktop-App offiziell gelistet), macOS oder Linux laut offizieller Dokumentation
Python: aktuelle 3.x-Version, wie in der offiziellen ComfyUI-Dokumentation für die jeweilige Release-Version angegeben
GPU: eine dedizierte Grafikkarte wird für brauchbare Geschwindigkeit empfohlen, ComfyUI läuft laut offizieller Doku grundsätzlich auch im reinen CPU-Modus, dann aber deutlich langsamer
Festplattenspeicher: mehrere zehn Gigabyte frei, allein ein einzelnes Flux- oder SD3.5-Checkpoint kann mehrere Gigabyte belegen, dazu kommen VAE, Text-Encoder und LoRAs
Git, um das Repository zu klonen und spätere Updates per git pull einzuspielen
Für AMD-Karten unter Windows: Unterstützung läuft über gesonderte Builds, unter Linux über ROCm
Stabile Internetverbindung für den ersten Download der Modelldateien, die je nach Modell mehrere Gigabyte groß sind

Wie viel VRAM du tatsächlich brauchst, hängt stark vom gewählten Modell ab. SD 1.5 gilt in der Community traditionell als die genügsamste Variante, SDXL braucht mehr Speicher für Checkpoint und Latents, und die Flux-Modellfamilie gehört zu den speicherhungrigsten Optionen, weil sie größere Text-Encoder und ein komplexeres Diffusion-Backbone mitbringt. Wer wenig VRAM hat, kann auf quantisierte GGUF-Varianten ausweichen, ähnlich wie es bei LLM-Quantisierung mit GGUF, GPTQ und AWQ für Sprachmodelle längst Standard ist.

In der Praxis lohnt es sich, die eigene Hardware grob in drei Kategorien einzuteilen, bevor du dich für ein Startmodell entscheidest. Einsteiger-Setups mit einer älteren oder kleineren Grafikkarte sind mit SD1.5-Checkpoints meist am entspanntesten bedient, weil die Community-Workflows dafür am ausgereiftesten sind und kaum Anpassung brauchen. Mittelklasse-Setups mit einer aktuellen Gaming-Grafikkarte fahren mit SDXL in der Regel gut, hier lohnt sich etwas Experimentieren mit Auflösung und Batch-Größe, um das Gleichgewicht zwischen Geschwindigkeit und Speicherverbrauch zu finden. High-End-Setups mit viel VRAM können direkt mit Flux-Checkpoints starten, profitieren aber trotzdem von GGUF-Quantisierung, sobald mehrere Zusatz-Nodes wie ControlNet oder Upscaler gleichzeitig Speicher belegen.

Schritt 1: Python und Git vorbereiten

Prüfe zuerst, ob Python und Git bereits installiert sind. Öffne ein Terminal (unter Windows die PowerShell, unter Linux/macOS ein normales Terminal) und führe aus:

python --version
git --version

Fehlt eines der beiden, lädst du Python direkt von der offiziellen Python-Seite und Git von git-scm.com herunter. Unter Windows empfiehlt es sich, bei der Python-Installation das Häkchen “Add python.exe to PATH” zu setzen, sonst findet die Konsole den Befehl später nicht. Unter Ubuntu/Debian genügt in der Regel:

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

Schritt 2: Repository klonen

Wechsle in ein Verzeichnis, in dem du ComfyUI installieren möchtest, und klone das offizielle Repository von Comfy-Org:

git clone https://github.com/comfy-org/ComfyUI.git
cd ComfyUI

Windows-Nutzer, die keine Python-Umgebung von Hand pflegen wollen, können alternativ das portable Windows-Paket von der offiziellen Release-Seite laden. Das portable Build bringt eine eigene Python-Umgebung mit und eignet sich gut für alle, die ComfyUI nur ausprobieren wollen, ohne sich mit virtuellen Umgebungen zu beschäftigen. Für produktive Setups mit mehreren Projekten ist der Git-Weg trotzdem die flexiblere Lösung, weil Updates und das Nachinstallieren von Abhängigkeiten einfacher zu kontrollieren sind.

Schritt 3: Virtuelle Umgebung anlegen

Eine virtuelle Umgebung verhindert, dass sich ComfyUI-Abhängigkeiten mit anderen Python-Projekten auf deinem System in die Quere kommen. Das ist besonders wichtig, wenn du parallel noch andere KI-Tools wie Ollama oder llama.cpp betreibst, die eigene Python-Pakete mitbringen.

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

Schritt 4: PyTorch mit passender GPU-Unterstützung installieren

Dieser Schritt entscheidet darüber, ob ComfyUI später deine Grafikkarte tatsächlich nutzt. Besuche die offizielle PyTorch-Installationsseite, wähle dort dein Betriebssystem, Paketmanager und die zu deiner Grafikkarte passende CUDA- beziehungsweise ROCm-Version aus und kopiere den generierten Befehl. Für eine aktuelle NVIDIA-Karte unter Windows oder Linux sieht ein typischer Befehl so aus (die genaue CUDA-Version variiert je nach Treiber und sollte direkt von der PyTorch-Seite übernommen werden):

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

Für AMD-Grafikkarten unter Linux nutzt du die ROCm-Variante von der gleichen Seite, unter Windows existieren separate DirectML- beziehungsweise ZLUDA-Wege über die Community. Apple-Silicon-Nutzer (M-Chips) profitieren von der MPS-Backend-Unterstützung in PyTorch, die Geschwindigkeit liegt dort erfahrungsgemäß unter einer vergleichbaren dedizierten GPU, reicht aber für erste Tests.

Ob PyTorch deine GPU tatsächlich erkannt hat, prüfst du mit einem kurzen Testbefehl, bevor du mit der eigentlichen ComfyUI-Installation weitermachst:

python -c "import torch; print(torch.cuda.is_available()); print(torch.cuda.get_device_name(0) if torch.cuda.is_available() else 'keine CUDA-GPU gefunden')"

Gibt die Konsole False zurück, obwohl eine NVIDIA-Grafikkarte verbaut ist, stimmt entweder der GPU-Treiber nicht oder es wurde versehentlich die CPU-only-Variante von PyTorch installiert. In diesem Fall lohnt sich ein erneuter Blick auf die offizielle PyTorch-Seite und ein kompletter Neuinstall der passenden Variante, bevor du weitermachst.

Schritt 5: ComfyUI-Abhängigkeiten installieren

Nachdem PyTorch korrekt installiert ist, installierst du den Rest der Abhängigkeiten aus der mitgelieferten requirements-Datei:

pip install -r requirements.txt

Dieser Schritt installiert unter anderem Pillow, NumPy, SciPy sowie die internen Abhängigkeiten für den Node-Editor und die Web-Oberfläche. Bricht die Installation mit einem Compiler-Fehler ab, fehlt unter Linux meist ein Build-Tool-Paket (build-essential), unter Windows hilft häufig die Installation der “Microsoft C++ Build Tools”.

Schritt 6: ComfyUI-Manager aktivieren

Seit der Integration des Managers direkt in ComfyUI reicht es laut offizieller Dokumentation, den Server mit dem passenden Flag zu starten, statt den Manager separat zu klonen. Für eine klassische Installation (nicht über Comfy Desktop) installierst du laut offizieller Manager-Dokumentation zunächst die Manager-Abhängigkeiten aus dem ComfyUI-Verzeichnis:

pip install -r manager_requirements.txt

Den Server startest du anschließend mit aktiviertem Manager:

python main.py --enable-manager

Im Browser erreichst du ComfyUI standardmäßig unter http://127.0.0.1:8188. Der Manager zeigt sich dort über ein Plugin-Symbol in der Oberfläche beziehungsweise über das Menü “Manage Extensions”. Über diese Oberfläche suchst, installierst, aktualisierst und deaktivierst du Custom Nodes, ohne die Kommandozeile anfassen zu müssen.

Schritt 7: Erstes Modell herunterladen und einordnen

ComfyUI selbst bringt kein Modell mit, du musst mindestens ein Checkpoint manuell herunterladen. Die Modelle gehören in festgelegte Unterordner innerhalb von ComfyUI/models/:

Modelltyp	Zielordner	Typische Dateiendung
Checkpoints (vollständige Modelle)	models/checkpoints/	.safetensors
Diffusion-Modelle (z. B. Flux-Backbone separat)	models/diffusion_models/	.safetensors
VAE	models/vae/	.safetensors
Text-Encoder / CLIP	models/clip/	.safetensors
LoRA	models/loras/	.safetensors
ControlNet	models/controlnet/	.safetensors
Upscaler	models/upscale_models/	.pth / .safetensors

Für den Einstieg empfiehlt sich ein SD1.5- oder SDXL-Checkpoint, weil beide auf nahezu jeder halbwegs aktuellen GPU laufen und die Community-Dokumentation dafür am umfangreichsten ist. Wer mehr VRAM zur Verfügung hat oder bereit ist, auf quantisierte Varianten zu setzen, kann direkt mit der Flux-Modellfamilie von Black Forest Labs starten, die laut aktuellen ComfyUI-Repository-Angaben zu den offiziell unterstützten Modellfamilien zählt.

Schritt 8: Den ersten Workflow laden und verstehen

ComfyUI liefert über das Menü “Workflow” beziehungsweise “Browse Templates” einige Standard-Workflows mit, etwa für einfache Text-zu-Bild-Generierung. Lade den einfachsten Text-zu-Bild-Workflow und betrachte den Graphen: Ein CheckpointLoaderSimple-Node lädt dein Modell, zwei CLIPTextEncode-Nodes verarbeiten Positiv- und Negativ-Prompt, ein KSampler-Node führt die eigentliche Diffusion aus, ein VAEDecode-Node wandelt die Latents in ein Bild um, und ein SaveImage-Node schreibt die Datei auf die Festplatte.

Jeder Workflow lässt sich als JSON-Datei exportieren und wieder importieren. Das macht Workflows portabel: Du kannst einen fertigen Graphen mit anderen teilen, in einer Code-Versionierung ablegen oder später über die API automatisiert einspielen. Genau dieser Austausch über JSON-Dateien ist einer der Gründe, warum ComfyUI in professionellen Pipelines beliebt ist, etwa wenn ein Studio immer wieder dieselbe Bildserie mit leicht abgewandelten Parametern erzeugen will.

Schritt 9: Prompt eingeben und erstes Bild generieren

Klicke auf den positiven CLIPTextEncode-Node und trage einen Prompt ein, zum Beispiel eine kurze, konkrete Bildbeschreibung. In den negativen Node trägst du typischerweise Begriffe ein, die das Modell vermeiden soll. Stelle im KSampler-Node die Anzahl der Sampling-Schritte und den CFG-Wert ein, Standardwerte aus den mitgelieferten Templates sind für den Einstieg eine gute Ausgangsbasis. Klicke anschließend auf “Queue Prompt” (oder den entsprechenden Button in der neuen Oberfläche), um die Generierung zu starten.

Beispielausgabe in der Konsole, während ComfyUI rechnet, sieht typischerweise so aus:

got prompt
model_type EPS
Using pytorch attention in VAE
Using pytorch attention in VAE
100%|██████████| 20/20 [00:08<00:00,  2.41it/s]
Prompt executed in 9.87 seconds

Das fertige Bild erscheint sowohl im Vorschaufenster der Oberfläche als auch als Datei im Ordner ComfyUI/output/.

Schritt 10: Custom Nodes über den Manager installieren

Die eigentliche Stärke von ComfyUI zeigt sich erst mit Custom Nodes, von Community-ControlNet-Integrationen bis zu Video- und Audio-Erweiterungen. Öffne den Manager über das Plugin-Symbol, wechsle zum Reiter für Custom Nodes und suche nach der gewünschten Erweiterung. Ein Klick auf “Install” lädt das zugehörige Repository herunter und installiert dessen Abhängigkeiten automatisch.

Nach jeder neu installierten Node-Sammlung muss ComfyUI neu gestartet werden, damit die neuen Nodes im Graph-Editor auftauchen. Der Manager zeigt dabei an, welche Nodes aktuell ein Update verfügbar haben, was bei Dutzenden installierten Erweiterungen schnell unübersichtlich werden kann. Es empfiehlt sich, Custom Nodes nur von vertrauenswürdigen, aktiv gepflegten Repositories zu installieren und regelmäßig nicht mehr benötigte Erweiterungen wieder zu entfernen.

Mit wachsender Zahl an Custom Nodes wird auch der Graph selbst schnell unübersichtlich. Sinnvoll ist es, zusammengehörige Node-Gruppen farblich zu markieren und über Gruppen-Rahmen im Editor optisch zusammenzufassen, etwa alle Nodes rund um das Prompt-Encoding in einer Farbe, alle Nodes rund um das Upscaling in einer anderen. Reroute-Nodes helfen zusätzlich dabei, lange Verbindungslinien quer durch den Bildschirm zu vermeiden, indem sie eine Verbindung an einer sinnvollen Stelle “umlenken”. Bei Workflows mit mehr als 30 oder 40 Nodes macht dieser kleine Mehraufwand in der Organisation den Unterschied, ob ein Kollege den Workflow nach einem Monat noch auf Anhieb versteht oder ihn komplett neu bauen muss.

Neben dem Kern-Repository pflegt Comfy-Org mit ComfyUI_frontend ein separates Projekt für die Web-Oberfläche, das ebenfalls eigenständig und in kurzen Abständen aktualisiert wird. Diese Trennung erklärt, warum ein Update des ComfyUI-Kerns über git pull nicht automatisch auch die neueste Oberflächen-Version mitbringt, und warum sich nach einem Backend-Update gelegentlich ein zusätzlicher Blick auf die Frontend-Version lohnt, falls neue Buttons oder Menüpunkte aus der Dokumentation in der eigenen Installation noch fehlen.

Schritt 11: ComfyUI als API/Headless-Server betreiben

Für produktive Einsätze, etwa die Anbindung an eine eigene Anwendung, lässt sich ComfyUI auch ohne grafische Oberfläche als API-Server betreiben. Die bereits seit Juni 2026 bestehende Jobs-API bringt dafür unter anderem Endpunkte zum gezielten Abbrechen einzelner Jobs mit, etwa über POST /api/jobs/{job_id}/cancel. Einen Prompt über die API einzureichen, funktioniert im Kern so:

import json
import requests

with open("mein_workflow.json") as f:
    workflow = json.load(f)

response = requests.post(
    "http://127.0.0.1:8188/prompt",
    json={"prompt": workflow}
)
print(response.json())

Dabei übergibst du die exportierte Workflow-JSON als Payload. Für automatisierte Batch-Verarbeitung, etwa das Erzeugen von hundert Varianten über Nacht, ist dieser API-Weg deutlich praktikabler als das manuelle Klicken in der Oberfläche. Wer serverseitig mehrere Nutzer bedienen will, sollte zusätzlich über einen Reverse Proxy mit Authentifizierung nachdenken, ComfyUI selbst bringt standardmäßig keinen Benutzer-Login mit.

Schritt 12: ComfyUI Desktop als Alternative zur manuellen Installation

Wer sich die manuelle Einrichtung von virtueller Umgebung, PyTorch und Manager sparen will, kann stattdessen zur offiziellen Comfy-Desktop-App greifen. Laut Projektdokumentation installiert die Desktop-Variante den Manager automatisch mit und hält den ComfyUI-Kern auf dem jeweils aktuellen stabilen Stand. Offiziell gelistet sind Windows-Builds für x64- und ARM64-Systeme, die allgemeine Dokumentation nennt zusätzlich macOS und Linux als unterstützte Installationsziele für ComfyUI insgesamt.

Der Nachteil der Desktop-App: Weniger Kontrolle über einzelne Python-Abhängigkeiten, was bei exotischen Custom Nodes gelegentlich zu Konflikten führen kann, die sich über die manuelle Git-Installation leichter beheben lassen. Für den schnellen Einstieg oder auf einem Zweitrechner ist die Desktop-App trotzdem die bequemere Wahl.

Schritt 13: Updates einspielen und Backups anlegen

ComfyUI entwickelt sich schnell weiter, Updates erscheinen oft mehrmals im Monat. Bei einer Git-Installation genügt in der Regel:

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

Sichere vor einem größeren Update deinen models-Ordner und deine gespeicherten Workflow-JSON-Dateien separat, idealerweise außerhalb des ComfyUI-Verzeichnisses. Modelle lassen sich notfalls erneut herunterladen, eigene Workflows mit sorgfältig abgestimmten Node-Einstellungen dagegen nicht ohne Weiteres rekonstruieren.

Start-Parameter: ComfyUI an deine Hardware anpassen

ComfyUI lässt sich beim Start über eine Reihe von Kommandozeilen-Flags an unterschiedliche Hardware-Situationen anpassen. Diese Flags sind besonders dann nützlich, wenn die Standardeinstellungen auf deiner Grafikkarte zu Speicherproblemen führen oder du bewusst Ressourcen für andere Programme freihalten willst. Ein typischer Start mit reduziertem Speicherverbrauch sieht so aus:

python main.py --lowvram --enable-manager

Das Flag --lowvram weist ComfyUI an, Modellteile bei Bedarf stärker zwischen GPU- und System-Speicher zu verschieben, was die Generierung etwas verlangsamt, dafür aber auch auf Karten mit wenig Grafikspeicher funktioniert. Für Systeme ganz ohne dedizierte GPU existiert zusätzlich ein reiner CPU-Modus, der naturgemäß deutlich langsamer ist, sich aber zum Testen einer Installation ohne passende Grafikkarte eignet:

python main.py --cpu

Willst du ComfyUI von einem anderen Gerät im lokalen Netzwerk erreichen, etwa von einem Laptop aus auf einen leistungsstärkeren Desktop-PC zugreifen, bindest du den Server an alle Netzwerkschnittstellen statt nur an localhost:

python main.py --listen 0.0.0.0 --port 8188

Genau in diesem Szenario greift die vorhin erwähnte Windows-Firewall-Regel: Ohne eine passende Freigabe für den gewählten Port bleibt der Server von anderen Geräten aus unerreichbar, selbst wenn der Befehl fehlerfrei startet. Wer den Server dauerhaft im Netzwerk erreichbar machen will, sollte an dieser Stelle zusätzlich über ein Passwort oder einen vorgeschalteten Reverse Proxy nachdenken, da ComfyUI ohne weitere Absicherung jedem Gerät im selben Netzwerk vollen Zugriff gewährt.

Alternative: Installation per Docker

Wer ComfyUI isoliert von der restlichen Systemumgebung betreiben möchte, etwa auf einem Server mit mehreren parallelen Projekten, kann statt der manuellen Git-Installation auch einen Container-Ansatz wählen. Voraussetzung ist eine lokale Docker-Installation mit aktivierter GPU-Weiterleitung (unter Linux über das NVIDIA Container Toolkit). Ein einfaches Beispiel für ein eigenes Dockerfile auf Basis eines offiziellen PyTorch-CUDA-Images sieht im Kern so aus:

FROM pytorch/pytorch:2.4.0-cuda12.1-cudnn9-runtime

WORKDIR /app
RUN git clone https://github.com/comfy-org/ComfyUI.git .
RUN pip install -r requirements.txt

EXPOSE 8188
CMD ["python", "main.py", "--listen", "0.0.0.0", "--enable-manager"]

Den Container baust und startest du anschließend mit GPU-Zugriff und einem gemounteten Ordner für Modelle, damit große Checkpoint-Dateien nicht bei jedem Neubau des Images erneut heruntergeladen werden müssen:

docker build -t mein-comfyui .
docker run --gpus all -p 8188:8188 -v $(pwd)/models:/app/models mein-comfyui

Der Docker-Weg lohnt sich vor allem für Teams, die ComfyUI auf mehreren Servern identisch ausrollen oder in eine bestehende Kubernetes- beziehungsweise Container-Infrastruktur einbetten wollen. Für den persönlichen Rechner zu Hause ist die direkte Git-Installation in der Regel unkomplizierter, weil Treiber-Durchreichung und Volume-Mounts zusätzliche Fehlerquellen mitbringen, die sich bei einer lokalen Installation gar nicht erst stellen.

Komplettes Beispielprojekt: Text-zu-Bild-Pipeline mit LoRA

Als abschließendes Projekt kombinierst du die bisherigen Schritte zu einer funktionierenden Pipeline: Checkpoint laden, einen LoRA-Node dazwischenschalten, Prompt verarbeiten, Bild generieren, Upscaling anwenden. Der Graph sieht in der JSON-Repräsentation stark vereinfacht so aus:

{
  "1": {"class_type": "CheckpointLoaderSimple",
        "inputs": {"ckpt_name": "sd_xl_base_1.0.safetensors"}},
  "2": {"class_type": "LoraLoader",
        "inputs": {"model": ["1", 0], "clip": ["1", 1],
                    "lora_name": "mein_lora.safetensors",
                    "strength_model": 0.8, "strength_clip": 0.8}},
  "3": {"class_type": "CLIPTextEncode",
        "inputs": {"clip": ["2", 1], "text": "ein ruhiger Bergsee bei Sonnenaufgang"}},
  "4": {"class_type": "KSampler",
        "inputs": {"model": ["2", 0], "positive": ["3", 0],
                    "steps": 25, "cfg": 7.0}},
  "5": {"class_type": "SaveImage",
        "inputs": {"images": ["4", 0]}}
}

In der grafischen Oberfläche ziehst du diese Verbindungen per Maus zwischen den Nodes, die JSON-Datei entsteht automatisch beim Speichern des Workflows. Wer diesen Workflow später per API aufruft, kann den Prompt-Text und die LoRA-Stärke programmatisch austauschen, etwa um eine ganze Serie unterschiedlicher Motive mit demselben Stil zu erzeugen.

Die häufigsten Fehler bei der ComfyUI-Installation

Beim Testen verschiedener Setups sind uns immer wieder dieselben Stolperfallen begegnet. Die folgende Liste deckt die Fehler ab, die neue Nutzer am häufigsten zum Abbruch der Installation bringen.

Falsche PyTorch-Variante installiert: Wer die CPU-Version von PyTorch installiert, obwohl eine GPU vorhanden ist, bemerkt das oft erst an der extrem langen Generierungszeit.
Python-Version nicht kompatibel: Eine zu alte oder zu neue Python-Version führt zu kryptischen Installationsfehlern bei einzelnen Abhängigkeiten.
Modelle im falschen Ordner abgelegt: Ein Checkpoint im VAE-Ordner oder umgekehrt taucht in der ComfyUI-Oberfläche schlicht nicht in der richtigen Dropdown-Liste auf.
Custom Nodes ohne Neustart: Nach der Installation einer Erweiterung über den Manager vergessen viele Nutzer den notwendigen Neustart des Servers.
Virtuelle Umgebung nicht aktiviert: Pakete werden versehentlich global statt in der venv installiert, was spätere Konflikte mit anderen Python-Projekten auslöst.
Zu wenig VRAM für das gewählte Modell: Besonders bei Flux-Checkpoints führt zu wenig Grafikspeicher zu Abstürzen mitten im Sampling-Prozess statt zu einer klaren Fehlermeldung vorab.
Veraltete GPU-Treiber: Ein alter NVIDIA- oder AMD-Treiber verhindert, dass PyTorch die GPU überhaupt erkennt.
Firewall blockiert den lokalen Port: Wenn ComfyUI auf einem anderen Gerät im Netzwerk erreichbar sein soll, blockiert die Windows-Firewall standardmäßig den Zugriff auf Port 8188.

Troubleshooting: Lösungen für die häufigsten Fehlermeldungen

Auch mit einer sauberen Installation tauchen im Alltag immer wieder dieselben Fehlermeldungen auf. Die folgende Tabelle sammelt die Probleme, die in Community-Foren und Issue-Trackern am häufigsten auftauchen, zusammen mit der jeweils wahrscheinlichsten Ursache und einem konkreten Lösungsschritt. Wer eine Meldung hier nicht findet, sollte im nächsten Schritt den Server im Terminal beobachten, meist steht dort eine ausführlichere Fehlermeldung mit Stacktrace, die sich direkt in die Suchmaschine kopieren lässt.

Problem	Wahrscheinliche Ursache	Lösung
“CUDA out of memory”	Modell oder Auflösung zu groß für verfügbaren VRAM	Niedrigere Auflösung wählen, quantisierte GGUF-Variante nutzen, Batch-Größe reduzieren
“No module named ‘torch'”	Virtuelle Umgebung nicht aktiviert oder PyTorch nicht installiert	venv aktivieren, PyTorch-Installationsbefehl erneut ausführen
Modell erscheint nicht in der Dropdown-Liste	Datei im falschen Unterordner von models/	Datei in den korrekten Ordner verschieben und ComfyUI neu starten
Custom Node wird als “missing” markiert	Node-Abhängigkeiten unvollständig installiert	Im Manager “Fix” oder “Reinstall” für die betroffene Node ausführen
Server startet, Browser zeigt aber leere Seite	Frontend-Build veraltet oder beschädigt	ComfyUI_frontend-Paket aktualisieren, Browser-Cache leeren
Generierung extrem langsam	CPU-Modus statt GPU-Modus aktiv	PyTorch-GPU-Variante installieren, GPU-Treiber aktualisieren
“RuntimeError: Expected all tensors to be on the same device”	Teile des Workflows wurden manuell auf CPU erzwungen	Betroffene Node-Einstellungen prüfen, Device-Parameter auf “default” zurücksetzen
Manager zeigt keine Custom Nodes zur Installation an	Node-Datenbank nicht aktuell geladen	Manager-Datenbank im Menü aktualisieren, Internetverbindung prüfen
Bilder werden schwarz oder verrauscht ausgegeben	Falsche VAE für das jeweilige Checkpoint geladen	Zum Checkpoint passende VAE-Datei laden oder “baked VAE” des Checkpoints nutzen

ComfyUI im Vergleich: Wann lohnt sich welches Tool?

ComfyUI ist nicht die einzige Oberfläche für lokale Bildgenerierung, aber die mit Abstand flexibelste. Automatic1111 und sein Fork Forge punkten mit einer einfacheren, formularbasierten Oberfläche, die für Standard-Workflows schneller zu bedienen ist. InvokeAI setzt stärker auf ein aufgeräumtes, konsumentenfreundliches Interface mit integriertem Canvas-Editor. ComfyUI gewinnt dagegen immer dann, wenn ein Workflow über die Standardfälle hinausgeht, etwa mehrstufiges Upscaling, Video-Generierung mit mehreren Modellen in Serie oder die Automatisierung über die API.

Die wichtigsten Unterschiede auf einen Blick

Die folgende Tabelle fasst zusammen, wofür sich jedes Tool am ehesten eignet. Die Einordnung basiert auf dem jeweiligen Bedienkonzept der Projekte, nicht auf Benchmark-Zahlen, da offizielle, direkt vergleichbare Leistungswerte zwischen den Projekten nicht einheitlich veröffentlicht werden.

Tool	Bedienkonzept	Stärke	Am besten für
ComfyUI	Node-Graph	Maximale Flexibilität, API-Automatisierung	Komplexe Workflows, Produktion, Video
Automatic1111	Formular	Schneller Einstieg, großes Extension-Ökosystem	Klassische Text-zu-Bild-Generierung
Forge	Formular (A1111-Fork)	Optimierte Performance gegenüber A1111	Nutzer mit wenig VRAM, die A1111-Bedienung mögen
InvokeAI	Canvas + Formular	Aufgeräumtes UI, integriertes Inpainting	Konsumentenfreundlicher Einstieg, Bildbearbeitung

Wer bereits mit anderen lokalen KI-Tools wie Open WebUI für Sprachmodelle arbeitet, wird sich am ehesten in der Komponenten-Denke von ComfyUI zurechtfinden. Beide Ansätze folgen dem Prinzip, einzelne Verarbeitungsschritte sichtbar zu machen, statt alles in einer Black Box zu verstecken, auch wenn ComfyUI den Grafik-Workflow-Ansatz deutlich konsequenter umsetzt. Ein Umstieg von Automatic1111 auf ComfyUI lohnt sich meist dann, wenn du merkst, dass du für ein bestimmtes Ergebnis mehrere separate Tools oder Zwischenschritte von Hand verkettest, etwa Generierung, Upscaling und Gesichtskorrektur in drei unterschiedlichen Programmen. Genau diese Verkettung übernimmt in ComfyUI ein einziger, wiederverwendbarer Workflow.

Sicherheit: Worauf du bei Custom Nodes achten solltest

Custom Nodes sind im Kern ausführbarer Python-Code, der mit den Rechten deines Benutzerkontos läuft. Vor der Installation einer unbekannten Erweiterung aus dem Manager lohnt sich ein kurzer Blick auf das zugehörige GitHub-Repository: Wie aktiv wird es gepflegt, wie viele Mitwirkende gibt es, wann war der letzte Commit? Je obskurer und seltener gepflegt ein Repository ist, desto vorsichtiger solltest du sein.

Praktisch heißt das: Custom Nodes nur aus dem offiziellen Manager-Katalog oder von bekannten, etablierten Autoren installieren, ComfyUI nicht ungeschützt mit offenem Port ins öffentliche Internet stellen, und bei Server-Betrieb für mehrere Nutzer zusätzlich eine Authentifizierungsebene vorschalten, etwa über einen Reverse Proxy mit Login. Diese Grundregeln ähneln denen, die auch bei der Absicherung lokaler Sprachmodell-Server gelten, etwa bei LM Studio oder anderen selbst gehosteten KI-Diensten.

Ein weiterer, oft übersehener Punkt betrifft Workflow-JSON-Dateien aus fremden Quellen. Ein importierter Workflow kann Referenzen auf Custom Nodes enthalten, die beim Import automatisch zur Installation vorgeschlagen werden. Bevor du einen aus einem Forum oder Discord-Server herunterladenen Workflow blind importierst und alle vorgeschlagenen Nodes bestätigst, lohnt sich ein kurzer Blick in die JSON-Datei selbst, ob darin tatsächlich nur Standard-Nodes und bekannte, verbreitete Erweiterungen auftauchen. Das kostet zwei Minuten und verhindert, dass du aus Bequemlichkeit eine kaum genutzte, potenziell unsichere Erweiterung installierst, nur weil sie Teil eines fremden Workflows war.

Fortgeschrittene Tipps für den produktiven Einsatz

Sobald die Grundinstallation steht, lohnen sich ein paar Optimierungen, die den Unterschied zwischen einem Hobby-Setup und einer belastbaren, täglich genutzten Pipeline ausmachen.

Workflows versionieren

Lege für jeden Projekttyp einen eigenen Workflow ab und versioniere die JSON-Dateien in einem eigenen Git-Repository, getrennt vom ComfyUI-Kern. Das macht es einfach, auf eine frühere, funktionierende Workflow-Version zurückzuspringen, wenn ein Update an Custom Nodes etwas kaputt macht. Sinnvoll ist außerdem eine kurze Notiz direkt in der Commit-Message, welches Modell und welche Node-Version zum Zeitpunkt des Speicherns aktiv war, da sich sonst nach Monaten kaum noch nachvollziehen lässt, warum ein alter Workflow plötzlich andere Ergebnisse liefert.

Batch-Verarbeitung automatisieren

Für wiederkehrende Batch-Jobs lohnt sich ein kleines Python-Skript, das Prompts aus einer Textdatei oder CSV liest, die Workflow-JSON entsprechend anpasst und über die /prompt-API-Route einreicht, statt jedes Bild einzeln von Hand in der Oberfläche anzustoßen. So lässt sich zum Beispiel über Nacht eine ganze Serie von Produktbildern mit unterschiedlichen Hintergründen erzeugen, während am nächsten Morgen nur noch die Ergebnisse gesichtet werden müssen.

Mehrere GPUs parallel nutzen

Wer mehrere GPUs im selben System hat, kann mehrere ComfyUI-Instanzen auf unterschiedlichen Ports mit je einer zugewiesenen GPU betreiben und so Jobs parallelisieren, etwa über die Umgebungsvariable CUDA_VISIBLE_DEVICES. Ein vorgeschalteter einfacher Load Balancer, der eingehende API-Anfragen round-robin auf die einzelnen Instanzen verteilt, reicht in der Praxis meist aus, um den Durchsatz deutlich zu erhöhen, ohne gleich eine komplette Orchestrierungslösung aufsetzen zu müssen.

Bei knappem VRAM hilft außerdem der Wechsel auf quantisierte Modellvarianten im GGUF-Format über entsprechende Custom Nodes, ähnlich dem Prinzip, das sich bei Sprachmodellen längst etabliert hat. Die Bildqualität sinkt dabei meist nur geringfügig, während sich der Speicherbedarf deutlich reduziert, was gerade größere Modelle wie die Flux-Familie auch auf Consumer-Grafikkarten nutzbar macht. Wer zusätzlich mit Fine-Tuning von LoRA-Modellen experimentiert, findet in der LoRA-Fine-Tuning-Anleitung dieser Seite das übertragbare Grundprinzip, auch wenn es dort um Sprachmodelle statt Bildmodelle geht: kleine, gezielt trainierte Gewichtungs-Layer statt eines kompletten Neutrainings.

Wartung: ComfyUI dauerhaft stabil halten

Weil sich ComfyUI so schnell weiterentwickelt, zahlt es sich aus, nicht bei jedem neuen Commit sofort zu aktualisieren. Für produktive Setups ist ein versetzter Rhythmus sinnvoller: Updates zunächst in einer separaten Testinstallation ausprobieren, bevor sie in die produktive Umgebung übernommen werden. Gerade Custom Nodes reagieren manchmal empfindlich auf Änderungen an der Kern-API und müssen nach einem größeren ComfyUI-Update selbst aktualisiert werden.

Ein regelmäßiger Blick in den offiziellen Changelog von Comfy-Org hilft außerdem, Breaking Changes frühzeitig zu erkennen, etwa wenn sich Node-Namen ändern oder neue Pflichtparameter hinzukommen. Wer mehrere Workflows produktiv einsetzt, sollte vor jedem Update zusätzlich die wichtigsten Workflow-JSON-Dateien testweise durchlaufen lassen, um Regressionen frühzeitig zu entdecken, statt sie erst im Live-Betrieb zu bemerken.

Praktisch bewährt sich dafür ein einfaches Zwei-Umgebungen-Modell: eine stabile Installation, die im Alltag läuft und nur in größeren Abständen aktualisiert wird, und eine zweite, identisch aufgesetzte Testinstallation, an der neue Versionen und neue Custom Nodes zuerst ausprobiert werden. Erst wenn die wichtigsten eigenen Workflows in der Testumgebung fehlerfrei durchlaufen, wird das Update auf die produktive Installation übertragen. Der zusätzliche Aufwand für die zweite Installation ist gering, verglichen mit dem Ärger, mitten in einer Kundenlieferung durch ein fehlgeschlagenes Update ausgebremst zu werden.

Lizenz und kommerzielle Nutzung

ComfyUI selbst ist Open Source und wird von der Comfy-Org-Community aktiv weiterentwickelt. Wichtig ist, dass sich die Lizenzbedingungen des verwendeten Basismodells von der Lizenz von ComfyUI unterscheiden: Während die Software selbst offen nutzbar ist, haben einzelne Modellfamilien wie Flux eigene, teils abgestufte Lizenzbedingungen für kommerzielle Nutzung. Vor dem produktiven Einsatz eines Modells in einem kommerziellen Produkt lohnt sich deshalb immer ein Blick auf die jeweilige Modell-Lizenz auf der Modellseite des Anbieters, etwa bei Black Forest Labs für die Flux-Familie.

Gerade für Agenturen und Freelancer, die Bildgenerierung in Kundenprojekten einsetzen, ist dieser Punkt kein Kleinkram. Manche Modell-Lizenzen erlauben die private und forschungsbezogene Nutzung kostenlos, verlangen für kommerzielle Produkte aber eine separate Vereinbarung oder eine Umsatzgrenze, ab der eine kostenpflichtige Lizenz fällig wird. Da sich solche Bedingungen von Modell zu Modell und über die Zeit ändern können, sollte die Lizenzprüfung fester Bestandteil der Projektplanung sein, nicht ein nachträglicher Check, nachdem die ersten Bilder schon beim Kunden liegen.

Häufig gestellte Fragen zu ComfyUI

Ist ComfyUI komplett kostenlos?
Ja, ComfyUI ist Open Source und kostenlos nutzbar. Kosten entstehen höchstens indirekt durch die benötigte Hardware oder falls du dich für kostenpflichtige Cloud-GPUs statt eigener Hardware entscheidest.

Brauche ich unbedingt eine NVIDIA-Grafikkarte?
Nein, aber NVIDIA-Karten mit CUDA-Unterstützung haben laut Community-Erfahrung aktuell die reibungsloseste Kompatibilität. AMD-Karten funktionieren über ROCm (Linux) oder gesonderte Windows-Builds, Apple-Silicon-Macs über das MPS-Backend von PyTorch, jeweils mit gewissen Einschränkungen bei Geschwindigkeit oder Node-Kompatibilität.

Was ist der Unterschied zwischen ComfyUI und Automatic1111?
Automatic1111 nutzt eine formularbasierte Oberfläche mit festen Reglern, ComfyUI arbeitet mit einem frei konfigurierbaren Node-Graphen. ComfyUI bietet dadurch mehr Flexibilität für komplexe Workflows, Automatic1111 gilt für einfache Standardaufgaben oft als schneller zugänglich.

Kann ich ComfyUI ohne eigene GPU in der Cloud nutzen?
Ja, verschiedene Cloud-GPU-Anbieter bieten vorkonfigurierte ComfyUI-Images an, bei denen du dir nur noch die passenden Modelle herunterladen musst. Das lohnt sich vor allem, wenn du größere Modelle wie Flux ausprobieren willst, ohne vorab in Hardware zu investieren.

Wie aktualisiere ich ComfyUI sicher, ohne meine Workflows zu verlieren?
Workflow-JSON-Dateien und der models-Ordner bleiben bei einem Update über git pull unberührt, solange du sie nicht im selben Verzeichnis überschreibst. Trotzdem empfiehlt sich vor größeren Updates ein separates Backup beider Ordner.

Welche Custom Nodes sollte ich als Erstes installieren?
Das hängt vom Anwendungsfall ab. Für Upscaling-Workflows lohnt sich eine Erweiterung mit zusätzlichen Upscale-Modellen, für ControlNet-gestützte Bildkomposition eine entsprechende ControlNet-Node-Sammlung. Am besten im Manager nach dem konkreten Anwendungsfall suchen, statt pauschal viele Erweiterungen auf Verdacht zu installieren.

Funktioniert ComfyUI auch für Video-Generierung?
Ja, über entsprechende Video-Modell-Nodes lassen sich auch Text-zu-Video- und Bild-zu-Video-Workflows aufbauen. Der Ressourcenbedarf liegt dabei spürbar über reiner Bildgenerierung, entsprechend mehr VRAM und Geduld solltest du einplanen.

Ist die Installation für absolute Einsteiger ohne Programmiererfahrung machbar?
Mit der Comfy-Desktop-App oder dem portablen Windows-Build ja, der Weg über Git, virtuelle Umgebung und manuelle PyTorch-Installation setzt dagegen zumindest grundlegende Terminal-Erfahrung voraus.

Wie finde ich heraus, welche Custom Nodes in einem fremden Workflow fehlen?
Beim Import einer Workflow-JSON-Datei markiert ComfyUI fehlende Nodes im Graphen in der Regel farblich und bietet über den Manager eine automatische Suche nach den passenden, fehlenden Erweiterungen an. Ohne aktivierten Manager musst du den jeweiligen Node-Namen manuell in der Node-Datenbank des Managers oder über eine Suchmaschine recherchieren.

ComfyUI einrichten: 27.100 Suchanfragen, 13 Schritte [2026]