Anima Ref Adapter: Figur aus einem Referenzbild in ComfyUI erzeugen

Ein neuer Adapter für das Anime-Bildmodell Anima übernimmt Aussehen und teils den Stil einer Figur aus einem einzigen Referenzbild. Pose, Hintergrund und Bildaufbau kommen aus dem Prompt. Das klappt auch für eigene Figuren, ohne langes Training oder Beschreibungen.

Tools Selbst ausprobieren 28. Okt. 2026 4 Min. Lesezeit Quelle: r/StableDiffusion

Worum es geht

Unter dem Namen „Anima Reference Adapter“ hat die Entwicklerin bzw. der Entwickler „ElectronGirl“ eine Erweiterung für ComfyUI veröffentlicht, die dem Anime-Bildmodell Anima eine Figurenreferenz beibringt. Man gibt ein einziges Referenzbild vor und schreibt einen Prompt, der nur die Szene beschreibt. Der Adapter behält, wer gezeichnet ist (Haare, Augen, Kleidung, Accessoires) und etwas davon, wie gezeichnet wird. Pose, Hintergrund und Bildaufbau kommen dagegen aus dem Prompt. Es braucht keinen Figurennamen, kein Künstler-Tag und keine Aussehens-Tags. Deshalb funktioniert es auch für eigene, erfundene Figuren. Ein Reddit-Nutzer fasst es so zusammen: ein Referenzbild, und dieselbe Figur wird erzeugt, ganz ohne lange Beschreibungen oder eigenes Training.

Die Veröffentlichung besteht aus ComfyUI-Nodes (Code, Apache-2.0), den Adaptergewichten auf Hugging Face und einem technischen Bericht. Die Autorin bezeichnet es ausdrücklich als Pilot-Release.

So funktioniert es

Das Referenzbild wird in einen Latent-Raum kodiert (die komprimierte Darstellung, in der das Modell rechnet). Dieser Latent wird als zweites Bild eines kurzen „2-Frame-Clips“ an das Modell gegeben, und zwar sauber, also ohne Rauschen (Timestep 0). Ein Trick verhindert das bloße Abpausen: Die RoPE-Koordinaten (Positionskodierung des Transformers) des Referenzbilds werden um eine Bildhöhe verschoben. Das Modell kann das Referenzbild so nicht pixelgenau übernehmen, kopiert also keine Pose. Eine ausgerichtete zeitliche Referenz würde dagegen die Pose mitkopieren.

Eine LoRA (kleine Zusatzgewichte, die ein Modell nachträglich anpasst) mit Rang 32 und 45,9 Millionen Parametern lernt, diesen Referenz-Frame zu lesen. Sie ist nur aktiv, wenn eine Referenz vorhanden ist. Trainiert wurde auf Paaren derselben Figur in verschiedenen Szenen, die Anima selbst erzeugt hatte; Name, Künstler und Aussehens-Tags wurden aus dem Ziel-Prompt entfernt. Zusätzlich gibt es getrennte Führung für Text und Referenz, kombiniert mit Adaptive Projected Guidance (APG), die Farben auch bei hoher Referenzstärke unter Kontrolle halten soll.

Installation und Nodes

Der Ordner wird in ComfyUI/custom_nodes geklont, die Datei anima_ref_adapter_pilot_r32.safetensors kommt nach ComfyUI/models/loras/. Dazu braucht man Anima Base v1.0, den Qwen3-0.6B-Textencoder und den Qwen-Image-VAE. Beide Beispiel-Workflows nutzen „Patch Sage Attention“ aus ComfyUI-KJNodes; ohne SageAttention lässt sich der Node umgehen (Ctrl+B).

Drei Nodes gehören dazu:

Node	Aufgabe
Anima Ref Adapter Loader	Hängt die Adapter-LoRA an das Anima-Modell; `ref_offset_h` bei 1.0 lassen
Anima Ref Latent	Passt die Referenz mit weißem Rand ein und kodiert sie per VAE, inkl. Halbgrößen-Variante
Anima Ref Guider	Guider für SamplerCustomAdvanced mit cfg, ref_guidance und apg/rescale

Empfohlene Einstellungen

Einstellung	Empfehlung
Basismodell	Anima Base v1.0 (Turbo-LoRA geht auch, wird davor geladen)
Rechengenauigkeit	bf16, da Anima in fp16 überläuft
Sampler	Euler, 28–30 Schritte, simple; SamplerSPEEDs Halbauflösungsstufe ist unzuverlässig
cfg	4,5
ref_guidance	4,5–6; höher bringt mehr Figurendetails und Stil, aber mehr Sättigung
Korrektur	apg oder rescale (phi 0,5)
Prompt	Qualität + Geschlecht + `solo` + Szenen-Tags

Für die Galerie wurden zusätzlich Anima-LoRAs (Context-Detailer ca. 0,3, Base-Slider ca. 0,6) und Anima Safe PAG genutzt. Die Seeds seien nicht ausgesucht worden. Das zeigt die Autorin auch an Figuren, die vom Training ausgeschlossen waren, etwa Tohru oder Meiko, im Vergleich zu Prompts ohne Adapter und zu Prompts mit ausgeschriebenen Aussehens-Tags.

Was du zum Ausprobieren brauchst

Die Quelle nennt keine Hardwarewerte. Anima ist ein eher kleines Modell mit 0,6-B-Texteencoder, die Adapter-Datei ist mit 45,9 Mio. Parametern winzig. Realistisch ist eine aktuelle Grafikkarte mit mehreren GB VRAM (grobe Schätzung, nicht aus der Quelle) und ein laufendes ComfyUI. Platz brauchst du für Basismodell, Texteencoder, VAE und Adapter. Ob es auf Mac oder CPU läuft, geht aus der Quelle nicht hervor.

Grenzen

Die Identität wird deutlich besser übertragen als der Stil; stark malerische Stile kommen kaum durch.
Kleine Muster, Narben, Ohrringe und ungewöhnliche Hautfarben gehen oft verloren; große Kleidungsstücke können farblich abdriften.
Gelegentlich taucht die Referenzfigur zusätzlich als Objekt in der Szene auf.
Das Training nutzte nur von Anima erzeugte Bilder, also erbt der Adapter dessen Vorurteile.

Einordnung

Bisher musste man für eine bestimmte Figur entweder eine eigene LoRA trainieren oder lange Aussehens-Tags schreiben, was bei Originalfiguren mühsam ist. Ein Adapter, der mit einem Bild auskommt, senkt diese Hürde erheblich. Offen ist, wie robust er außerhalb der gezeigten Beispiele ist; die Galerie stammt von der Autorin selbst, und unabhängige Vergleiche fehlen. Wichtig für die Nutzung: Die Gewichte sind nicht-kommerziell lizenziert, weil sie vom CircleStone-Modell abgeleitet sind. Auf der Roadmap stehen getrennte Referenzen für Figur und Stil, ein größerer Datensatz mit 2.000 Figuren in je drei Künstlerstilen, bessere Übertragung malerischer Stile und Training für Halbauflösungs-Sampler.

Begriffe einfach erklärt

LoRA: Eine kleine Zusatzdatei mit wenigen trainierten Gewichten, die ein großes Bildmodell nachträglich um eine Fähigkeit oder einen Stil erweitert.
ComfyUI: Eine knotenbasierte Oberfläche, in der man Bildgenerierung aus Bausteinen (Nodes) zusammensteckt.
RoPE: Eine Positionskodierung, mit der ein Transformer-Modell weiß, wo im Bild oder in der Sequenz etwas liegt. Hier wird sie für das Referenzbild verschoben.
Latent: Die stark komprimierte interne Darstellung eines Bildes, in der das Modell rechnet, bevor am Ende das fertige Bild entsteht.
APG (Adaptive Projected Guidance): Ein Korrekturverfahren bei der Führung des Samplers, das übersättigte Farben bei hoher Führungsstärke vermeiden soll.
CFG: Regler dafür, wie stark das Modell dem Text-Prompt folgt.
Adapter: Ein Zusatzmodul, das einem bestehenden Modell eine neue Eingabe oder Fähigkeit beibringt, hier die Bildreferenz.

Quellen

r/StableDiffusion github.com

#comfyui#anima#stable-diffusion#lora#character-reference#anime

Originalquelle lesen

Selbst ausprobieren: Anima Reference Adapter

Schritt für Schritt erklärt, auch ohne Vorkenntnisse – auf deinem Rechner oder kostenlos im Browser.

Was kann ich damit machen?

Der Adapter erweitert das Anime-Bildmodell Anima um eine Figurenreferenz. Du gibst ein Bild einer Figur vor und beschreibst nur die Szene, etwa „full body, walking, city, night, rain“. Heraus kommt dieselbe Figur mit ähnlicher Frisur, Augenfarbe und Kleidung in neuer Pose und neuer Umgebung. Das geht auch für selbst erfundene Figuren, weil weder Name noch Aussehens-Tags nötig sind. Stärker als der Stil wird die Identität übertragen; sehr malerische Stile und kleine Details wie Narben oder Ohrringe gehen oft verloren. Es handelt sich um einen Pilot-Release mit 300 Trainingsfiguren, entsprechend sind Ausreißer zu erwarten.

Für wen lohnt es sich?

Interessant für alle, die in ComfyUI Anime-Bilder erzeugen und dieselbe Figur in vielen Szenen brauchen, etwa für Comics, Charakterdesign oder Rollenspiele. Weniger geeignet für kommerzielle Projekte (Gewichte nur nicht-kommerziell) und für alle, die realistische oder stark malerische Stile suchen.

Ideen: Was du damit anstellen kannst

Comic-Figur in vielen Szenen

Lade ein Bild deiner Hauptfigur als Referenz und erzeuge Szenen wie Café, Strand oder Klassenzimmer nur per Szenen-Tags. So bekommst du Vorlagen für Panels, ohne eine eigene LoRA zu trainieren.

Rollenspiel-Charakter visualisieren

Mit einem Porträt deines Pen-and-Paper-Charakters erstellst du Bilder von Abenteuerszenen, etwa im Schnee oder in einer Bibliothek. Das Aussehen bleibt weitgehend konsistent.

Maskottchen für ein Hobbyprojekt

Für Discord-Server, Streams oder Fan-Projekte lassen sich Varianten eines Maskottchens in verschiedenen Situationen erzeugen. Beachte die nicht-kommerzielle Lizenz.

Charakterdesign testen

Probiere, wie ein Entwurf in unterschiedlichen Posen und Umgebungen wirkt, und finde so Schwächen des Designs.

Visual-Novel-Hintergrundvarianten

Dieselbe Figur in mehreren Szenen für Hobby-Visual-Novels, als Ausgangsmaterial für spätere Feinarbeit.

Größe0,0459 Mrd. Parameter

Download0,1 GB (bei 100 MBit/s ca. 1 Min.)

Lizenzeigene Lizenz (siehe Model Card)

ArtBildgenerator

Hugging FaceElectronGirl/anima-ref-adapter

Was dein Rechner braucht

Grafikkarte (NVIDIA) mind. 6 GB VRAMfast jede Grafikkarte ab 4 GB (z. B. GTX 1650, RTX 3050)

Mac (Apple Silicon M1–M5) ab 8 GB gemeinsamer Speicherläuft über Metal (MPS), aber deutlich langsamer als mit NVIDIA-Karte

Nur Prozessor (ohne Grafikkarte) Möglich, aber sehr langsammehrere Minuten pro Bild. Nicht empfehlenswert.

Speicherplatz ca. 2,1 GB freiModell-Download plus Programme

Google Colab läuft kostenlosGratis-GPU Tesla T4 mit 15 GB reicht

Es gibt genau eine Adapterdatei (anima_ref_adapter_pilot_r32.safetensors), die auf Anima Base v1.0 trainiert wurde. Die Anima-Turbo-LoRA funktioniert ebenfalls und kann für weniger Schritte davor geladen werden.

Anima läuft in bf16 (ModelComputeDtype); in fp16 gibt es Überläufe.
Konkrete VRAM-Werte nennt die Quelle nicht; der Adapter selbst ist mit ca. 46 Mio. Parametern klein.
Das Referenzbild wird als zweiter Frame mitgerechnet, das kostet zusätzlichen Rechenaufwand gegenüber normaler Generierung.
SageAttention ist optional; ohne lässt sich der Patch-Node umgehen.

Wie finde ich heraus, was mein Rechner hat?

Windows: Strg + Umschalt + Esc drücken → Task-Manager → Reiter Leistung → links GPU anklicken. Unten steht Dedizierter GPU-Speicher (das ist dein VRAM). Den Arbeitsspeicher findest du unter Arbeitsspeicher.
Mac: Apfel-Menü oben links → Über diesen Mac. Dort stehen Chip (z. B. M2) und Speicher (z. B. 16 GB). Bei Apple-Chips teilen sich Grafik und Prozessor diesen Speicher.
Linux: Im Terminal nvidia-smi eingeben (zeigt Grafikkarte und Speicher) und free -h für den Arbeitsspeicher.

Anleitung

Dieses Modell läuft mit einem eigenen Programm seiner Entwickler (ElectronGirl/ComfyUI-Anima-Ref-Adapter auf GitHub). Die Befehle unten stammen aus der Model Card und der Anleitung der Entwickler.

Windows 10 / 11

Windows 10 / 11: nicht offiziell getestet. In der Quelle steht nichts zu Windows. ComfyUI läuft dort normalerweise mit NVIDIA-Karten, der Adapter ist aber nicht ausdrücklich getestet.

Voraussetzungen prüfen. Du brauchst Python 3.10 oder neuer, Git und bei NVIDIA-Karten einen aktuellen Treiber. Öffne PowerShell und prüfe die Versionen. Das Modell ist ein Zusatz (LoRA) für ComfyUI, eine grafische Oberfläche für Bildmodelle.
```
python --version
git --version
nvidia-smi
```
ComfyUI holen. Lade ComfyUI herunter und wechsle in den Ordner. Falls du ComfyUI schon hast, überspring diesen Schritt.
```
git clone https://github.com/comfyanonymous/ComfyUI.git
cd ComfyUI
```
Umgebung anlegen und installieren. Eine venv ist ein abgetrennter Python-Bereich. Installiere zuerst PyTorch passend zu deiner Grafikkarte (Anleitung auf pytorch.org), dann die ComfyUI-Pakete. Meldet PowerShell einen Skriptfehler, erlaube Skripte für diese Sitzung mit dem ersten Befehl.
```
Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass
python -m venv .venv
.venv\Scripts\Activate.ps1
pip install -r requirements.txt
```
Adapter-Knoten installieren. Die Knoten des Adapters kommen in den Ordner custom_nodes. Ohne sie funktioniert das Referenzbild nicht.
```
cd custom_nodes
git clone https://github.com/ElectronGirl/ComfyUI-Anima-Ref-Adapter.git
cd ..
```

Adapter-Gewichte laden. Die Datei ist nur etwa 0,09 GB groß und kommt nach models\loras.

pip install -U huggingface_hub
hf download ElectronGirl/anima-ref-adapter anima_ref_adapter_pilot_r32.safetensors --local-dir models\loras

Anima-Basismodell holen. Lade Anima base v1.0, den Textencoder Qwen3-0.6B und das Qwen-Image-VAE von der Hugging-Face-Seite circlestone-labs/Anima. Lege sie in models\diffusion_models, models\text_encoders und models\vae.
Optional: KJNodes installieren. Die Beispiel-Workflows nutzen „Patch Sage Attention“ aus ComfyUI-KJNodes. Installiere es in custom_nodes oder umgehe den Knoten später in ComfyUI mit Strg+B.
```
cd custom_nodes
git clone https://github.com/kijai/ComfyUI-KJNodes.git
cd ..
```
ComfyUI starten. Starte das Programm und öffne die angezeigte Adresse im Browser (meist http://127.0.0.1:8188). Lade die Seite mit Strg+F5 neu.
```
python main.py
```
Workflow öffnen und erstes Bild erzeugen. Lade custom_nodes\ComfyUI-Anima-Ref-Adapter\workflows\anima_ref_adapter.json in ComfyUI. Wähle ein Referenzbild mit einer Figur und trage nur die Szene als Prompt ein. Empfohlen: Euler, 28 Schritte, cfg 4.5, ref_guidance 4.5, correction apg, bf16.
```
masterpiece, best quality, score_7, newest, highres, absurdres, safe, 1girl, solo, upper body, sitting, eating, cake, cafe, indoors
```
Ergebnis. In ComfyUI entsteht ein Bild, auf dem die Figur aus deinem Referenzbild in der Szene aus deinem Prompt zu sehen ist.

macOS

macOS: nicht offiziell getestet. In der Quelle steht nichts zu macOS. ComfyUI läuft grundsätzlich auch auf Apple-Chips, ob der Adapter dort sauber läuft, ist nicht getestet. Rechne mit langsamer Erzeugung.

Voraussetzungen prüfen. Du brauchst Python 3.10 oder neuer, Git und die Xcode-Kommandozeilentools. Installiere diese bei Bedarf mit dem ersten Befehl. Das Modell ist ein Zusatz (LoRA) für ComfyUI, eine grafische Oberfläche für Bildmodelle.
```
xcode-select --install
python3 --version
git --version
```
ComfyUI holen. Lade ComfyUI herunter und wechsle in den Ordner. Falls du ComfyUI schon hast, überspring diesen Schritt.
```
git clone https://github.com/comfyanonymous/ComfyUI.git
cd ComfyUI
```
Umgebung anlegen und installieren. Eine venv ist ein abgetrennter Python-Bereich. Installiere zuerst PyTorch für den Mac (Anleitung auf pytorch.org), dann die ComfyUI-Pakete.
```
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
```
Adapter-Knoten installieren. Die Knoten des Adapters kommen in den Ordner custom_nodes. Ohne sie funktioniert das Referenzbild nicht.
```
cd custom_nodes
git clone https://github.com/ElectronGirl/ComfyUI-Anima-Ref-Adapter.git
cd ..
```

Adapter-Gewichte laden. Die Datei ist nur etwa 0,09 GB groß und kommt nach models/loras.

pip install -U huggingface_hub
hf download ElectronGirl/anima-ref-adapter anima_ref_adapter_pilot_r32.safetensors --local-dir models/loras

Anima-Basismodell holen. Lade Anima base v1.0, den Textencoder Qwen3-0.6B und das Qwen-Image-VAE von der Hugging-Face-Seite circlestone-labs/Anima. Lege sie in models/diffusion_models, models/text_encoders und models/vae.
Optional: KJNodes. Die Beispiel-Workflows nutzen „Patch Sage Attention“ aus ComfyUI-KJNodes. SageAttention gibt es auf dem Mac vermutlich nicht. Umgehe den Knoten in ComfyUI deshalb mit Strg+B (Cmd-Taste kann abweichen).
```
cd custom_nodes
git clone https://github.com/kijai/ComfyUI-KJNodes.git
cd ..
```
ComfyUI starten. Starte das Programm und öffne die angezeigte Adresse im Browser (meist http://127.0.0.1:8188). Lade die Seite neu.
```
python main.py
```
Workflow öffnen und erstes Bild erzeugen. Lade custom_nodes/ComfyUI-Anima-Ref-Adapter/workflows/anima_ref_adapter.json in ComfyUI. Wähle ein Referenzbild mit einer Figur und trage nur die Szene als Prompt ein. Empfohlen: Euler, 28 Schritte, cfg 4.5, ref_guidance 4.5, correction apg, bf16.
```
masterpiece, best quality, score_7, newest, highres, absurdres, safe, 1girl, solo, upper body, sitting, eating, cake, cafe, indoors
```
Ergebnis. In ComfyUI entsteht ein Bild, auf dem die Figur aus deinem Referenzbild in der Szene aus deinem Prompt zu sehen ist.

Linux

Linux: unterstützt. Läuft über ComfyUI, am besten mit einer NVIDIA-Grafikkarte (der Autor hat auf einer NVIDIA-Karte trainiert). Andere Karten sind in der Quelle nicht erwähnt.

Voraussetzungen prüfen. Du brauchst Python 3.10 oder neuer, Git und bei NVIDIA-Karten einen aktuellen Treiber. Prüfe die Versionen mit den Befehlen. Das Modell ist kein Einzelprogramm, es ist ein Zusatz (LoRA) für ComfyUI, eine grafische Oberfläche für Bildmodelle.
```
python3 --version
git --version
nvidia-smi
```
ComfyUI holen. Lade ComfyUI herunter und wechsle in den Ordner. Falls du ComfyUI schon hast, überspring diesen Schritt.
```
git clone https://github.com/comfyanonymous/ComfyUI.git
cd ComfyUI
```
Umgebung anlegen und installieren. Eine venv ist ein abgetrennter Python-Bereich, der dein System sauber hält. Installiere zuerst PyTorch passend zu deiner Grafikkarte (Anleitung auf pytorch.org), dann die ComfyUI-Pakete.
```
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
```
Adapter-Knoten installieren. Die Knoten des Adapters kommen in den Ordner custom_nodes. Der Adapter ist kein normales LoRA: Er braucht diese Knoten, sonst wird das Referenzbild nicht richtig eingebunden.
```
cd custom_nodes
git clone https://github.com/ElectronGirl/ComfyUI-Anima-Ref-Adapter.git
cd ..
```

Adapter-Gewichte laden. Die Datei ist nur etwa 0,09 GB groß und kommt nach models/loras.

pip install -U huggingface_hub
hf download ElectronGirl/anima-ref-adapter anima_ref_adapter_pilot_r32.safetensors --local-dir models/loras

Anima-Basismodell holen. Der Adapter braucht Anima base v1.0, den Textencoder Qwen3-0.6B und das Qwen-Image-VAE. Lade sie von der Hugging-Face-Seite circlestone-labs/Anima herunter. Lege sie in die passenden ComfyUI-Ordner: Modell in models/diffusion_models, Textencoder in models/text_encoders, VAE in models/vae.
Optional: KJNodes installieren. Die Beispiel-Workflows nutzen den Knoten „Patch Sage Attention“ aus ComfyUI-KJNodes. Installiere ihn (Repo kijai/ComfyUI-KJNodes) in custom_nodes. Oder du umgehst den Knoten später in ComfyUI mit Strg+B.
```
cd custom_nodes
git clone https://github.com/kijai/ComfyUI-KJNodes.git
cd ..
```
ComfyUI starten. Starte das Programm und öffne die angezeigte Adresse im Browser (meist http://127.0.0.1:8188). Lade die Seite mit Strg+F5 neu, damit die neuen Knoten erscheinen.
```
python main.py
```
Workflow öffnen und erstes Bild erzeugen. Lade die Datei custom_nodes/ComfyUI-Anima-Ref-Adapter/workflows/anima_ref_adapter.json in ComfyUI. Wähle ein eigenes Referenzbild (eine Figur, z. B. ein Anime-Bild von dir). Trage als Prompt nur die Szene ein, ohne Namen oder Aussehen, und klicke auf „Queue“. Empfohlen: Euler, 28 Schritte, cfg 4.5, ref_guidance 4.5, correction apg, Rechengenauigkeit bf16.
```
masterpiece, best quality, score_7, newest, highres, absurdres, safe, 1girl, solo, upper body, sitting, eating, cake, cafe, indoors
```
Ergebnis. In ComfyUI entsteht ein Bild, auf dem die Figur aus deinem Referenzbild in der Szene aus deinem Prompt zu sehen ist.

So geht es nach dem ersten Ergebnis weiter

Probiere andere Szenen-Tags aus, z. B. „full body, walking, city, street, night, rain“. Schreibe keinen Figurennamen und keine Aussehens-Tags in den Prompt.
Mit ref_guidance zwischen 4,5 und 6 bekommst du mehr Figurendetails, aber auch mehr Farbsättigung. Lass ref_offset_h im Adapter-Knoten auf 1.0.
Für mehr Qualität kannst du optional Anima Safe PAG (anima_ref_adapter_pag.json) und die Detailer-/Slider-LoRAs aus den Galerie-Einstellungen nutzen.
Beachte: Die Gewichte sind nur für nichtkommerzielle Nutzung lizenziert. Kleine Muster und Ohrringe gehen oft verloren.

Das kannst du ausprobieren

masterpiece, best quality, score_7, newest, highres, absurdres, safe, 1girl, solo, upper body, sitting, eating, cake, cafe, indoors

masterpiece, best quality, score_7, newest, highres, absurdres, safe, 1boy, solo, full body, walking, hands in pockets, city, street, night, rain

masterpiece, best quality, score_7, newest, highres, absurdres, safe, 1girl, solo, portrait, closed eyes, smile, cherry blossoms, petals, wind

masterpiece, best quality, score_7, newest, highres, absurdres, safe, 1boy, solo, full body, standing, snow, forest, winter

Tipps für bessere Ergebnisse

Schreibe im Prompt keinen Figurennamen, Künstler- oder Aussehens-Tags, nur Qualität, Geschlecht, solo und die Szene.
Starte mit cfg 4,5 und ref_guidance 4,5; höhere Werte (bis 6) bringen mehr Details, aber mehr Sättigung.
Nutze Korrektur „apg“ oder „rescale“ (phi 0,5), um Farbübersättigung zu zügeln.
Optional helfen Context-Detailer-LoRA (~0,3), Base-Slider-LoRA (~0,6) und Anima Safe PAG; normale LoRAs lädst du vor dem Adapter-Loader.

Wenn es hakt

Node-Fehler nach der Installation: ComfyUI neu starten und den Browser-Tab mit Ctrl+F5 neu laden.

Fehlende Patch-Sage-Attention: ComfyUI-KJNodes installieren oder den Node mit Ctrl+B umgehen.

Schwarze oder kaputte Bilder: bf16 statt fp16 verwenden, Anima überläuft in fp16.

Benötigt werden auch Anima Base v1.0, Qwen3-0.6B-Texteencoder und Qwen-Image-VAE aus dem circlestone-labs/Anima-Repo.

Den Sampler SamplerSPEED mit Halbauflösungsstufe meiden, er ist unzuverlässig.

Die Gewichte sind nur nicht-kommerziell nutzbar.

„out of memory“, Absturz oder der Rechner hängt

Das Modell ist zu groß für deinen Grafikspeicher. Nimm eine kleinere Variante aus der Tabelle oben und schließe andere Programme, vor allem Spiele und Browser mit vielen Tabs.

Es läuft, aber extrem langsam

Wahrscheinlich rechnet der Prozessor statt der Grafikkarte. Bei Ollama zeigt ollama ps in der Spalte PROCESSOR, wie viel auf der GPU läuft. Steht dort „100% CPU“, Grafiktreiber aktualisieren oder eine kleinere Variante nehmen, die komplett in den Grafikspeicher passt.

„ollama“ bzw. „python“ wird nicht gefunden

Das Eingabefenster schließen und neu öffnen, damit es das frisch installierte Programm kennt. Bei Python unter Windows: neu installieren und das Häkchen Add python.exe to PATH setzen.

Windows: „Die Ausführung von Skripts ist auf diesem System deaktiviert“

Das Skript genau mit dem Befehl oben starten: powershell -ExecutionPolicy Bypass -File try_windows.ps1. Das erlaubt die Ausführung nur dieses einen Mal.

Fehlermeldung beim Laden des Modells (Version, „trust_remote_code“, unbekannte Architektur)

Ganz neue Modelle brauchen oft die neueste Programmversion. Bei Ollama: Ollama aktualisieren. Bei Python: pip install -U transformers in der aktivierten Umgebung. Die Model Card nennt meist die genaue Version.

Skripte und Notebook erzeugt Tokenstrom automatisch. Bitte vor dem Ausführen kurz ansehen – sie sind lesbarer Klartext. Lizenz des Modells beachten: eigene Lizenz (siehe Model Card).

Frag den KI-Assistenten

Fragen zu diesem Artikel, zur Installation oder zu Hintergründen? Unser Assistent kennt diese Seite und läuft auf unserem eigenen Rechner, nicht in einer fremden Cloud.

Verbinde …

Der Assistent ist eine KI (Gemma 4) und kann sich irren – wichtige Angaben bitte in der Quelle prüfen. Fragen werden nur zum Beantworten genutzt und nach einer Stunde gelöscht. Bitte keine persönlichen Daten eingeben.

Kommentare

Was meinst du dazu? Schon ausprobiert? Schreib es hier, ohne Anmeldung.

Kommentare werden geladen …

Kommentare sind öffentlich. Links sind nicht erlaubt, beleidigende Beiträge löschen wir. Deinen eigenen Kommentar kannst du in diesem Browser jederzeit wieder löschen. Mehr dazu in der Datenschutzerklärung.