Extensions/cmk_nodes
ComfyUI Extension

cmk_nodes

CMK Flow — modular, guided custom nodes and workflows for ComfyUI

By CMKFlow·Created 3 months ago·Updated about 14 hours ago· 6
CMKFlow/cmk_nodes
Nodes140
On cloudLocal install
CategoryCMK/Toolbox/Model & LoRA, CMK/Flow/Input
Stars6
Updatedabout 14 hours ago

Nodes (140)

CMK Checkpoint VAE Loader

One node instead of a checkpoint loader, a VAE loader and a switch

CMK/Toolbox/Model & LoRA
CMK Flow · Checkpoint & VAE

The loader that starts CMK Flow's modular pipeline

CMK/Flow/Input
CMK Combined ControlNet Bypass Gate

One gate, two architectures, and a hybrid special case

CMK/Developer/Boundary & Cache
CMK Flow · 05 ControlNet Combined

One ControlNet panel for SDXL and Z-Image Turbo at once

CMK/Flow/Process
CMK ControlNet Bypass Gate

The node that makes a ControlNet checkbox actually free

CMK/Developer/Boundary & Cache
CMK ControlNet Prepare

ControlNet prep without a single extra node pack — and what that costs you

CMK/Toolbox/ControlNet
CMK Flow · 05 ControlNet SDXL

SDXL ControlNet as one guided step

CMK/Flow/Process
CMK Boundary Cache

The boundary that stops your detailer running twice

CMK/Developer/Boundary & Cache
CMK Detailer Finalize -Pipe-

One paste at the end, not five pastes in the middle

CMK/Developer/Pipe/Finalize
CMK Detailer Prepare -Pipe-

Where the detailer gets its own model, prompt and SAM

CMK/Developer/Pipe/Prepare
CMK Diagnostic Concat

Thirty-two diagnostic feeds, one timeline you can actually read

CMK/Toolbox/Diagnostics
CMK Empty Image Mask

A black canvas and a fully-white mask, in fifteen lines

CMK/Toolbox/Mask & SEGS
CMK Boundary Cache

The boundary that fences off the face module

CMK/Developer/Boundary & Cache
CMK Face Crop

Crop the face you actually selected, not the one the detector liked

CMK/Toolbox/Face
CMK Face Mask

A soft ellipse over the face, and a coverage number to prove it

CMK/Toolbox/Face
CMK FaceProcess

The standalone face pass, full of ReActor DNA and one very confusing number

CMK/Toolbox/Face
CMK FaceProcess -Pipe-

Restore or re-detail the face, without the widgets you didn't ask for

CMK/Developer/Pipe/Execute
CMK FaceProcess Prepare -Pipe-

The face module's own model, prompt and SAM — built once

CMK/Developer/Pipe/Prepare
CMK Boundary Cache

The boundary around an InstantID rebuild, on disk as well as in memory

CMK/Developer/Boundary & Cache
CMK Face Restore

Face Restore that is not GFPGAN — and that's the interesting part

CMK/Toolbox/Face
CMK Face Select

Two Faces in the Frame? CMK Face Select Decides Who Gets Swapped

CMK/Toolbox/Face
CMK Boundary Cache

Why Your Unchanged FaceSwap Branch Doesn't Run Twice

CMK/Developer/Boundary & Cache
CMK FaceSwap Image

Inswapper_128 Is 128px Wide, and That's the Whole Story

CMK/Toolbox/Face
CMK FaceSwap Image -Pipe-

The FaceSwap That Knows Which Model Made the Image

CMK/Developer/Pipe/Execute
CMK FaceSwap Video

The Node That Started CMK, Still Doing Full-Length Video

CMK/Toolbox/Video
CMK FaceSwap Video Loader

One Node to Pick a Video, a Face, and Cut It Up

CMK/Toolbox/Video
CMKFamilyBranchGateSDXL

The Node That Says 'Not My Family, Don't Bother'

CMK/Developer/Boundary & Cache
CMKFamilyBranchGateSDXLSampled

Gating the Latent Handoff So Module 10 Doesn't Run Twice

CMK/Developer/Boundary & Cache
CMKFamilyBranchGateZImage

The Gate for the Model That Killed Flux 2's Launch Week

CMK/Developer/Boundary & Cache
CMK Flow · PostProcess Boundary Combined

Where Three Pipelines Stop Arguing

CMK/Flow/Finish
CMK Filename Base

Turn 'C:\\...\\portrait (2).png' into Something You Can Use

CMK/Toolbox/I-O
CMK Pipe Get

Dig One Image Out of a Pipe That Has Passed Through Five Stages

CMK/Developer/Pipe/Get
CMK Hybrid SDXL → ZIT Bridge -Pipe-

90% SDXL, Then Z-Image Finishes the Job

CMK/Developer/Pipe/Bridge
CMK Image Compare

Press and Hold to See What Your Edit Actually Did

CMK/Internal
CMKImageCompareEnableGate

Stop the Before/After Popping Up for a Module You Turned Off

CMK/Developer/Boundary & Cache
CMK Image File Loader

The Loader That Doesn't Load Anything

CMK/Flow/Input
CMK Image Forward -Pipe-

The Node That Exists Because Subgraphs Are Awkward

CMK/Developer/Pipe/Forward
CMK Load Image

Aspect-Preserving Crop, and Why Your Image Isn't Distorted

CMK/Toolbox/Image
CMK Image and Mask Switch

One Boolean, Two Pairs, No Magic

CMK/Toolbox/Mask & SEGS
CMK Image Metrics

The Node You Add When the Shape Is Wrong and Nothing Says Why

CMK/Toolbox/Diagnostics
CMK Image Preview Forward -Pipe-

Look at the image without unwiring the pipe

CMK/Developer/Pipe/Preview
CMK Image QuickMetrics

Read the tensor before you blame the sampler

CMK/Toolbox/Diagnostics
CMK InstantID Boundary

The node that exists so InstantID doesn't run twice

CMK/Developer/Boundary & Cache
CMK InstantID Face Detailer SDXL

A second InstantID pass, aimed at one crop

CMK/Toolbox/Face
CMK FaceRebuild SDXL · Advanced

Three faces, three identities, one node

CMK/Toolbox/Face
CMK InstantID Face Rebuild · Pasteback

Put the rebuilt face exactly back

CMK/Toolbox/Face
CMK Flow · InstantID Face Rebuild · Pasteback

The pipe version, with a real bypass

CMK/Toolbox/Face
CMK InstantID Face Rebuild · Prepare

Find the face, cut the crop, build the masks

CMK/Toolbox/Face
CMK Flow · InstantID Face Rebuild · Prepare

The crop step that keeps your pipe alive

CMK/Toolbox/Face
CMK FaceRebuild SDXL

Detect, re-render, paste back — in one node

CMK/Toolbox/Face
CMK InstantID Sampler SDXL -Pipe-

Identity injection without leaving the pipe

CMK/Toolbox/Face
CMK KSampler -Pipe-

The sampler that reads a pipe instead of eleven wires

CMK/Developer/Pipe/Execute
CMK Flow · Load Image

The loader that also starts your log and your pipe

CMK/Flow/Input
CMK LOG CONCAT

Stitch 32 log blocks back into one readable report

CMK/Toolbox/Diagnostics
CMK Log Create

An empty log, so the rest of the chain has something to hold

CMK/Toolbox/Diagnostics
CMK Log Export Text

Turn the CMK report into a string you can keep

CMK/Toolbox/Diagnostics
CMK Log Set Block

Write your own notes into the CMK report

CMK/Toolbox/Diagnostics
CMK LoRA SDXL Pack -Pipe-

The adapter that puts LoRAs on the pipe

CMK/Internal
CMK LoRA Stack Builder

Type <lora:name:0.8> and get a real stack

CMK/Toolbox/Model & LoRA
CMK LoRA Text Loader

Apply LoRAs from a text field, no manager required

CMK/Toolbox/Model & LoRA
CMK LoRA ZIT Pack -Pipe-

Bundling LoRAs for Z-Image Turbo in One Socket

CMK/Internal
CMK Mask Detailer Flow Gate

The Switch That Decides Whether Your Detail Pass Runs At All

CMK/Developer/Internal
CMK Mask Detailer · Intake

CMK's Mask Detailer Intake

CMK/Toolbox/Image
CMK Mask Detailer · Prepare

CMK Mask Detailer Prepare

CMK/Toolbox/Image
CMK Mask Detailer · Process

Running CMK's Standalone Detailer

CMK/Toolbox/Image
CMK Merge and Save Video

CMK Merge and Save Video

CMK/Toolbox/Video
CMK Model Forward -Pipe-

A Node That Does Nothing, On Purpose

CMK/Developer/Pipe/Forward
CMK Module Bypass Gate

CMK Module Bypass Gate

CMK/Developer/Boundary & Cache
CMK Pipe Create Detailer

CMK Pipe Create Detailer

CMK/Developer/Pipe/Create
CMK Pipe Create Face Process

The Face Restore Setting You Can't See (And Why That's Fine)

CMK/Developer/Pipe/Create
CMK Flow · 01 START HERE · Create Image

The One Node That Sets the Rules for Everything After It

CMK/Flow/Input
CMK Pipe Create Refiner

SDXL Refiner, Wrapped in One Socket

CMK/Developer/Pipe/Create
CMK Pipe Inspect

CMK Pipe Inspect

CMK/Developer/Diagnostics
CMK Pipe Peek ControlNet Source

CMK Pipe Peek ControlNet Source

CMK/Developer/Pipe/Peek
CMK Pipe Peek Detailer

Unpacking a Detailer Pipe Into Impact-Pack Shapes

CMK/Developer/Pipe/Peek
CMK Pipe Peek Face Process

The Face Pipe, Opened Up

CMK/Developer/Pipe/Peek
CMK Pipe Peek KSampler

Plug a Real KSampler Into a CMK Pipe

CMK/Developer/Pipe/Peek
CMK Pipe Peek KSampler Refiner Source

Carry the First Pass's DNA Into the Refiner

CMK/Developer/Pipe/Peek
CMK Pipe Peek Preprocess Detailer

Everything a Detailer Needs, Pulled Out of a Pipe

CMK/Developer/Pipe/Peek
CMK Pipe Peek Preprocess Face

Building a Face Pass From Scratch, With CMK's State

CMK/Developer/Pipe/Peek
CMK Pipe Peek Preprocess Image

Get things back out of the pipe

CMK/Developer/Pipe/Peek
CMK Pipe Peek Preprocess Refiner

The image, the latent, and two switches

CMK/Developer/Pipe/Peek
CMK Pipe Peek Refiner

Unpack the refiner stage without running it

CMK/Developer/Pipe/Peek
CMK Pipe Set ControlNet

Store the hint and the model, apply later

CMK/Developer/Pipe/Set
CMK Pipe Set Detailer

Detailer settings that don't wreck your first pass

CMK/Developer/Pipe/Set
CMK Pipe Set Detailer Result

Hand the detailed image back to the pipe

CMK/Developer/Pipe/Set
CMK Pipe Set Face Process Result

The same setter, wearing the right label

CMK/Developer/Pipe/Set
CMK Pipe Set Face Result

Push a processed face image back onto the pipe

CMK/Developer/Pipe/Set
CMK Pipe Set KSampler

The one-wire way to drop a latent into the pipe

CMK/Developer/Pipe/Set
CMK Pipe Set Refiner

Park an image in the pipe for the 20 Refiner module

CMK/Developer/Pipe/Set
CMK Pipe Set Sampler

One node that fills the whole first-pass context

CMK/Developer/Pipe/Set
CMK Flow · PostProcess Boundary SDXL

Where generation ends and the freestyle begins

CMK/Flow/Finish
CMK Flow · PostProcess Boundary ZIT

Closing out a Z-Image Turbo run

CMK/Flow/Finish
CMK Preview Board

A wall of diagnostics for when the graph has too many stages

CMK/Toolbox/Diagnostics
CMK Preview Render

See what one node actually did to your image

CMK/Toolbox/Diagnostics
CMK Process Enable Flag

Read a hidden switch out of the process state

CMK/Developer/Pipe/Forward
CMK Process Forward -Pipe-

The no-op that makes a subgraph export its state

CMK/Developer/Pipe/Forward
CMK Prompt Concatenate

Two strings, one separator, no surprises

CMK/Internal
CMK Boundary Cache

Why the second pass doesn't run twice

CMK/Developer/Boundary & Cache
CMK Refiner -Pipe-

The second pass, executed without re-inventing it

CMK/Developer/Pipe/Execute
CMK Refiner Prepare SDXL -Pipe-

The SDXL refiner's second pass, wired so you can't plug it in wrong

CMK/Developer/Pipe/Prepare
CMK Flow · 02 Regional Conditioning SDXL

Two characters, one prompt, and the hair colour that keeps swapping

CMK/Flow/Conditioning
CMK Result Pack -Pipe-

Packing the neutral result in CMK Flow

CMK/Developer/Boundary & Cache
CMK Result Process Forward -Pipe-

Forwarding a process pipe so the boundary never has to know about it

CMK/Developer/Pipe/Forward
CMK Result Bridge -Pipe-

The adapter that lets old CMK modules eat a new neutral result

CMK/Developer/Boundary & Cache
CMK Result Unpack -Pipe-

Unpacking a CMK result without quietly mixing two model families

CMK/Developer/Boundary & Cache
CMK Sampler Bypass Gate

How a switched-off module stops costing you a render

CMK/Developer/Boundary & Cache
CMK Sampler Prepare SDXL -Pipe-

The SDXL first pass, minus the twelve wires you'd normally forget

CMK/Developer/Pipe/Prepare
CMK Sampler Prepare Z-Image Turbo -Pipe-

Z-Image Turbo in 8 steps, with the plumbing ComfyUI Core makes you do by hand

CMK/Developer/Pipe/Prepare
CMK Save Project Image

A save node that files your image under the right folder while you sleep

CMK/Toolbox/I-O
CMK Save Project Text

The 40-line node that keeps your prompt next to the picture

CMK/Toolbox/I-O
CMK Save Project Video

Saving video without another ffmpeg command you'll have to remember

CMK/Toolbox/I-O
CMK SDXL Result Bridge -Pipe-

Turning an SDXL process into a neutral result, the one legal way out

CMK/Developer/Boundary & Cache
CMK SEGS CONCAT

Merging three detail branches without turning your image into confetti

CMK/Toolbox/Mask & SEGS
CMK SEGS Preview

So what did the detector actually find? A preview that answers that

CMK/Internal
CMK Smart Detailer

Detect, crop, resample, paste back — without installing Impact Pack

CMK/Toolbox/Image
CMK Smart Detailer -Pipe-

Running three detail passes at once and only paying for the ones that changed

CMK/Developer/Pipe/Execute
CMK Smart Outpaint Pad

Making a canvas bigger without stretching what's already on it

CMK/Toolbox/Image
CMK Smart Upscaler

One upscaler that picks 4x or 2x based on how big your image already is

CMK/Toolbox/Image
CMK Smart Upscaler -Pipe-

The upscaler that lets go of your models before it grabs another one

CMK/Developer/Pipe/Execute
CMK SourcePathInfo

Two string outputs, and one of them lies about its name

CMK/Toolbox/I-O
CMK Split Video into Segments

The entry point for long video that doesn't eat your VRAM

CMK/Toolbox/Video
CMK Positive / Negative Text

The boring node that stops you editing the same prompt twice

CMK/Toolbox/Text
CMK Summary

Turning CMK's diagnostic payloads into something you can actually read

CMK/Toolbox/Diagnostics
CMK FaceSwap Image Input

One node, two images, and they are deliberately treated differently

CMK/Toolbox/I-O
CMK Trigger Words Filter

Two of its three switches do nothing, and that's fine

CMK/Internal
CMK Boundary Cache

Why your side branch re-upscales the same image twice

CMK/Developer/Boundary & Cache
CMK Video Compare

Proving your split-and-merge round trip didn't drop two frames

CMK/Toolbox/Video
CMK Video Metrics

Width, height, fps and bit depth as real outputs you can wire

CMK/Toolbox/Diagnostics
CMK Video QuickMetrics

The video stats panel with no wiring required

CMK/Toolbox/Diagnostics
CMK Preview & Compare

Hold the mouse down to see before and after, no extra image plumbing

CMK/Toolbox/Image
CMK Flow · Visualizer

The one node at the end that saves, previews and optionally upscales

CMK/Flow/Core
CMK Visual Forward -Pipe-

The node that keeps the visual chain alive through a module that shows nothing

CMK/Developer/Visual
CMK Visual Provider -Pipe-

How you get your own node's image into the Visualizer panel

CMK/Developer/Visual
CMK Boundary Cache

Stop re-running the Z-Image decode every time you tweak the post-process

CMK/Developer/Boundary & Cache
CMK Z-Image Process Forward -Pipe-

The node that lets the ZIT branch be chosen before it's expensive

CMK/Developer/Pipe
CMK Z-Image Turbo Finalize -Pipe-

The decode step that turns a latent back into an image

CMK/Developer/Pipe/Finalize
CMK Z-Image Turbo Loader -Pipe-

Three files, one pipe, and a cache that saves you 20GB of reloading

CMK/Developer/Pipe/Load
CMK ZIT ControlNet Bypass Gate

The switch that means an unused ControlNet branch costs nothing

CMK/Developer/Boundary & Cache
CMK Flow · 05 ControlNet ZIT

Canny-only ControlNet for Z-Image, and the resolution setting that catches everyone

CMK/Flow/Process/ZIT
Readme
<p align="center"> <img src="web/assets/brand/cmk-logo.png" width="140" alt="CMK Flow logo"> </p>

CMK Flow

Modulares Custom-Node-Paket für ComfyUI.

Aktueller Release: CMK 2.5.5

Deutsch · English

Quellcode · Dokumentation · Freiwillig unterstützen

Copyright (C) 2026 Carsten Kirschner

CMK Flow verfolgt zwei klar getrennte Konzepte:

CMK **** -Pipe- → geschlossenes, geführtes Ökosystem
übrige Nodes    → offener Experimentierkasten

Der verbindliche Architektur- und Schnittstellenvertrag steht in ARCHITECTURE.md.

Inspiration und Anerkennung

Der ComfyUI LoRA Manager von willmiao hat die Erwartungen an den CMK Flow Browser wesentlich mitgeprägt. Seine direkt aus ComfyUI geöffnete Browseroberfläche für Checkpoints, LoRAs, Metadaten und Civitai-Inhalte zeigte eindrucksvoll, wie komfortabel eine integrierte Verwaltungsoberfläche sein kann.

CMK Flow ist ein eigenständiges Projekt ohne offizielle Verbindung zum LoRA Manager. Diese Nennung würdigt die gestalterische Inspiration und die umfangreiche Arbeit hinter dem Open-Source-Projekt; sie behauptet keine Übernahme von Code.

Einstieg

Der CMK Flow Browser ist die zentrale Schnittstelle zwischen Anwender und CMK. Er bietet direkt in ComfyUI einen kompakten Überblick, schnellen Zugriff auf Nodes und Subgraphen, echte Vorschauen sowie kuratierte Referenzworkflows. Er ist ein Arbeitswerkzeug und bewusst weder Handbuch noch technische Dokumentation.

CMK 2.5 trennt die familientypische Generationszone von der familienunabhängigen PostProcess-Zone:

Vorbereitung: Loader / LoRA → 01 START HERE
Generierung: 02 Regional Conditioning (optional, SDXL)
              → 05 ControlNet (optional)
              → 10 KSampler
              → 15 InstantID (optional, SDXL)
              → 20 Refiner (SDXL)
Übergabe:     PostProcess Boundary (SDXL / Z-Image Turbo / Combined)
PostProcess:  FaceRebuild · FaceSwap · FaceProcess · Detailer · MaskDetailer
Ausgabe:      Visualizer und/oder Upscale & Save

SDXL, Z-Image Turbo und HYBRID bleiben während der Generierung technisch getrennte Pfade. HYBRID baut das Bild zunächst mit SDXL auf und übergibt es für den abschließenden Finish an Z-Image Turbo. Die passende PostProcess Boundary beendet den Generationsabschnitt und stellt anschließend einen unabhängigen, familienneutralen Arbeitskontext bereit. Bei parallelen Familien übernimmt die Variante Combined ausschließlich den aktiven SDXL-, ZIT- oder HYBRID-Zweig.

Die sichtbaren Hauptrollen sind:

MODEL | PROCESS | IMAGE | LOG | VISUAL

Zwischen SDXL-Sampler, InstantID und Refiner wird statt IMAGE der proprietäre Latent-Übergabetyp SAMPLED verwendet. Sichtbare Titel dienen ausschließlich der Darstellung; technische Identität und Navigation beruhen auf Metadaten, Node-Klassen, Provider-Keys und UUIDs.

Wesentliche Eigenschaften

  • klare Trennung von Modellressourcen, Prozesszustand, Bild, Log und Visualisierung;
  • proprietäre Prepare-/Execute-Schnittstellen gegen Fehlverkabelung;
  • getrennte SDXL-, Z-Image-Turbo- und HYBRID-Generationspfade mit gemeinsamer familienneutraler PostProcess-Zone;
  • parallele Smart-Detailer- und FaceProcess-Instanzen;
  • dynamische SEGS, LOG BLOCK und DIAGNOSTIC-Eingänge;
  • persistente Branch-Caches für unveränderte parallele Instanzen;
  • verpflichtende Modul-Boundaries vor Comparer, nachfolgenden Modulen und öffentlichen Ausgängen;
  • zentrale VISUAL-Kette für registrierte Bearbeitungsstufen im Visualizer;
  • eigenständige Nutzung der PostProcess-Module in diskreten oder gekapselten Modul-Workflows;
  • CMK Flow · Image Input verwendet für neue Nodes standardmäßig den sichtbaren seitenverhältnistreuen Crop. center/top/bottom/left/right bestimmen, welcher Bildbereich beim Resize erhalten bleibt; dadurch wird das Bild nicht auf das Zielseitenverhältnis verzerrt.
  • CMK Swap Image Loader -Pipe- lädt Target und Source in einer zweispaltigen Oberfläche; nur das Target nutzt Resize und optionalen Advanced-Crop, die Source bleibt pixelmäßig unverändert.
  • Z-Image Turbo besitzt eigene Loader-, Sampler- und optionale ControlNet-Module. ZIT-Inpaint bleibt aufgrund der sehr hohen Speicher- und Laufzeitanforderungen ausdrücklich EXPERIMENTAL und vorläufig eingefroren.
  • Der Referenzkatalog gliedert sich in Task Workflows, Module Workflows, Comparisons, Real-World Workflows, System Workflow und Legacy. Er enthält 20 aufsteigend komplexe Task-Workflows, diskrete und gekapselte Modulbeispiele, direkte Vergleiche, vollständige Praxisabläufe und den Full Flow als Systemreferenz.

Installation

Installation über den ComfyUI-Manager

Nach der Veröffentlichung in der Comfy Registry im ComfyUI-Manager nach CMK Flow suchen, den Eintrag von CMKFlow installieren und ComfyUI neu starten. Der Manager lädt CMK und installiert die Python-Abhängigkeiten aus requirements.txt automatisch. Modellgewichte gehören bewusst nicht zum Python-Paket und werden anschließend mit dem CMK-Ressourcencheck geprüft.

Der Registry-Paketname lautet cmk-flow. CMK selbst setzt jedoch keinen festen Namen des Installationsordners voraus; auch ein durch den Manager normalisierter oder manuell gewählter Verzeichnisname funktioniert.

Die Manager-Installation lädt keine Modellressourcen automatisch und übernimmt oder migriert keine Dateien aus historischen CMK-Installationen. Der separate Ressourcencheck bleibt dafür der ausdrücklich vorgesehene nächste Schritt.

Alternative: manuelle Installation von GitHub

ComfyUI vor der Installation vollständig beenden.

1. Den richtigen ComfyUI-Ordner öffnen

Öffne den Hauptordner deiner ComfyUI-Installation. Es ist der Ordner, der die Datei main.py und den Unterordner custom_nodes enthält. Öffne genau in diesem Ordner ein Terminal.

Falls dort bereits custom_nodes/cmk_nodes existiert, nicht darüberinstallieren: Den vorhandenen Ordner zuerst sichern oder vollständig entfernen.

2. CMK herunterladen und Abhängigkeiten installieren

Diese beiden Befehle nacheinander in das geöffnete Terminal kopieren:

git clone https://github.com/CMKFlow/cmk_nodes.git custom_nodes/cmk_nodes
python3 custom_nodes/cmk_nodes/scripts/install_cmk_requirements.py

Der Installationshelfer ermittelt aus dem Zielpfad automatisch die tatsächlich von ComfyUI verwendete Python-Umgebung, installiert dort requirements.txt und prüft anschließend alle verpflichtenden CMK-Importe. Das ist insbesondere bei ComfyUI Desktop wichtig, weil System-Python, standalone-env und ComfyUI/.venv nebeneinander vorhanden sein können.

Die Installation war erfolgreich, wenn am Ende diese Meldung erscheint:

CMK dependency check: OK

Modellressourcen prüfen

Die Python-Abhängigkeiten enthalten keine Modellgewichte. Prüfe die Ressourcen deshalb ausdrücklich gegen die Installation und – falls verwendet – gegen den gemeinsamen Modellordner:

python3 custom_nodes/cmk_nodes/scripts/check_cmk_resources.py \\
  --models-root "/Pfad/zum/ComfyUI-Shared"

Nach einer Manager-Installation liegt dasselbe Skript regulär unter custom_nodes/cmk-flow/scripts/check_cmk_resources.py. Der Ressourcencheck ermittelt ComfyUI aus seinem eigenen Speicherort und funktioniert unabhängig vom Namen des CMK-Installationsordners.

Wenn ein gemeinsamer Modellordner verwendet wird, ist er das bevorzugte Ziel für fehlende Ressourcen und wird über --models-root angegeben. CMK verschiebt oder kopiert dabei keine Modelle aus älteren Installationen; vorhandene Ressourcen werden ausschließlich an den ausdrücklich angegebenen und von ComfyUI registrierten Modellpfaden gesucht.

Beim ersten Lauf mit --models-root registriert der Helfer diesen gemeinsamen Modellordner zusätzlich in ComfyUI/extra_model_paths.yaml, damit ComfyUI die gefundenen Modelle auch zur Laufzeit verwendet. Eine vorhandene Konfiguration wird nicht überschrieben; der CMK-Block wird höchstens einmal ergänzt. Nach dem Audit ComfyUI neu starten, damit die Pfade geladen werden.

Der Helfer prüft die konkreten Dateinamen der ausgelieferten CMK-2.5-Workflows; ein lediglich nicht-leerer Modellordner gilt nicht als Treffer. Jede Ressource wird einzeln mit ihrem CMK-Einsatzbereich als FOUND oder MISSING ausgegeben. Direkt nach einer fehlenden Ressource mit eindeutigem öffentlichem Original- Download fragt der Helfer, ob sie jetzt installiert werden soll. Mit n läuft die Prüfung weiter; mit y wird zuerst diese Datei mit Fortschrittsanzeige in den korrekten ComfyUI-Modellordner geladen.

Wenn mehrere installierbare Ressourcen fehlen, stehen zwei Modi zur Auswahl: INSTALL ALL MISSING bestätigt und installiert alle diese Ressourcen in einem Durchlauf; INSTALL ONE BY ONE fragt jede Ressource einzeln ab. Mit --install-mode all oder --install-mode one-by-one lässt sich der Modus für Skripte direkt vorgeben.

Direkt installierbar sind die in den ausgelieferten Workflows festgelegten Ressourcen für SDXL, Z-Image Turbo, ControlNet, InstantID, InsightFace, SAM, Ultralytics-Detektoren, FaceSwap, GFPGAN, Fooocus Inpaint, Refiner-LoRAs und RealESRGAN. Vor jeder einzelnen Datei zeigt der Helfer Quelle, Lizenzhinweis, Zielpfad und – bei großen Dateien – die ungefähre Größe an und fragt ausdrücklich nach. Downloads mit festgelegter Referenzversion werden vor der Installation per SHA-256 geprüft; das offizielle buffalo_l-Archiv wird kontrolliert in den erwarteten InsightFace-Modellordner entpackt.

Verlangt Civitai für eine Ressource eine Anmeldung, fragt der Helfer nach dem Civitai-API-Key. Jedes übernommene Zeichen wird als * dargestellt; anschließend bestätigt der Helfer zusätzlich die übernommene Zeichenanzahl. Der Key selbst wird nur für den laufenden Prozess im Speicher gehalten und weder angezeigt noch gespeichert. Alternativ kann er vorab über die Umgebungsvariable CIVITAI_API_TOKEN bereitgestellt werden. Ohne Key lässt sich die betroffene Ressource überspringen; die Prüfung läuft danach mit den übrigen Ressourcen weiter.

Kann für eine künftig ergänzte Ressource keine eindeutig verifizierte Datei oder automatisierbare Bezugsquelle festgelegt werden, bleibt sie als manueller Fall sichtbar. Die Meldung nennt dann die betroffene Funktion und den Grund.

python3 custom_nodes/cmk_nodes/scripts/check_cmk_resources.py \\
  --models-root "/Pfad/zum/ComfyUI-Shared" \\
  --install instantid-adapter \\
  --target-root "/Pfad/zum/ComfyUI-Shared"

python3 custom_nodes/cmk_nodes/scripts/check_cmk_resources.py \\
  --models-root "/Pfad/zum/ComfyUI-Shared" \\
  --install instantid-controlnet \\
  --target-root "/Pfad/zum/ComfyUI-Shared"

Mehrere Z-Image-/ControlNet-Dateien sind mehrere Gigabyte groß; jede davon wird deshalb separat bestätigt. Workflows und technische Identitäten werden durch den Ressourcencheck nicht verändert.

Für automatisierte Prüfungen ohne Nachfrage steht --non-interactive zur Verfügung.

ComfyUI neu starten

ComfyUI erst nach der Erfolgsmeldung wieder starten. Der Flow Browser wird mit dem geladenen CMK-Paket automatisch registriert.

Update

Manager-Installationen werden über Update im ComfyUI-Manager aktualisiert; der Manager pflegt dabei auch die Abhängigkeiten aus requirements.txt.

Für ein manuelles Git-Update erneut ein Terminal im ComfyUI-Hauptordner öffnen und ausführen:

git -C custom_nodes/cmk_nodes pull --ff-only
python3 custom_nodes/cmk_nodes/scripts/install_cmk_requirements.py

Ein manueller Git-Clone führt niemals automatisch pip aus. Deshalb gehört der zweite Befehl verbindlich zur Installation und zu jedem Update.

Erforderliche ComfyUI-Oberfläche

Bestätigte Zielversion

CMK 2.5.5 wurde mit ComfyUI 0.38.2 und comfyui-frontend-package 1.53.6 vollständig geprüft. Dazu gehören die Flow-Browser-Navigation, paketierte Subgraphen und Referenzworkflows, eingebettete Vorschauen, Cache-Pfade sowie die serialisierten Link-, Socket-, UUID- und Topologieverträge.

CMK Flow benötigt die ComfyUI-Einstellung Vue Nodes / Nodes 2.0. Ohne sie fallen dynamische CMK-Nodes auf die alte LiteGraph-Darstellung zurück; Advanced-Umschaltung, Dropdowns, Shapes und automatische Größenanpassung stehen dann nicht wie vorgesehen zur Verfügung. CMK zeigt beim Start einen Hinweis, wenn die Einstellung im aktuellen Benutzerprofil nicht aktiviert ist. Die Oberfläche wechselt beim Aktivieren unmittelbar; ein Neuladen ist nicht nötig.

Für Vorschauen während Sampler- und Refiner-Läufen sollte unter Comfy → Execution → Live preview method der Wert auto gewählt sein.

Keine alten Einzeldateien neben einer aktuellen Installation liegen lassen. Die JSON-Dateien unter subgraphs/ bleiben im Node-Pack. Zusätzliche Kopien unter user/default/subgraphs/ erzeugen doppelte Blueprint-Einträge.

Vor dem Kopieren sollten vorhandene gleichnamige Workflows außerhalb des Node-Packs gesichert werden. Historische Entwicklungsstände sind nicht Bestandteil der öffentlichen CMK-Veröffentlichung.

Laufzeitabhängigkeiten

Die CMK-Kernnodes für Detektion, SEGS, Detailer, Pasteback, FaceProcess-Restore, SAM-Laden und die angebotenen ControlNet-Preprozessoren benötigen keine fremden Custom-Node-Pakete. Die optionalen Subgraphen LoRA Stack · SDXL, LoRA Stack · ZIT und LoRA Stack · Combined sowie Referenzworkflows, die sie verwenden, setzen den ComfyUI LoRA Manager voraus. Ohne ihn bleiben die übrigen CMK-Module verwendbar.

Die Python-Bibliotheken stehen in requirements.txt. Modellgestützte Funktionen benötigen weiterhin die jeweils ausgewählten Modelle, insbesondere Ultralytics-Detektormodelle, SAM-Modelle, InsightFace-Modelle sowie optionale Face-Restore-Modelle. Fehlende Modelle blockieren nicht die Registrierung unbeteiligter CMK-Nodes, sondern erzeugen im gewählten Funktionspfad eine klare Laufzeitmeldung.

FaceSwap ContentGuard

Die öffentlichen CMK-FaceSwap-Pfade besitzen einen verpflichtenden lokalen ContentGuard. Er prüft Quell- und Zielbilder vor dem Swap; im Videopfad wird jedes Ziel-Frame geprüft. Explizite Inhalte, ein geschätztes Alter unter 18, ein Source-Alter unter der konservativen 25er-Grenze sowie fehlende oder fehlerhafte Schutzmodelle führen zu einem harten Abbruch. Es gibt in der öffentlichen Oberfläche keine Umgehungsoption. Deaktivierte FaceSwap-Nodes bleiben echte Pass-through-Pfade und laden den Guard nicht.

Der Guard arbeitet vollständig lokal mit NudeNet zur Erkennung expliziter Inhalte und InsightFace zur Altersschätzung. Für Target-Gesichter gilt die Erwachsenen-Grenze 18, um instabile Schätzungen bei generierten oder stilisierten Gesichtern nicht fälschlich zu sperren. Die Bewertung hängt von den Bildinhalten und dem Altersmodell des installierten InsightFace-Pakets ab. Sie ist eine technische Risikobegrenzung, keine Einwilligungsprüfung und keine Garantie gegen Fehlklassifikationen. Details zur Policy und zu den neutralen Diagnosecodes stehen in CONTENT_GUARD.md.

Cache-Verhalten

Interne CMK-Caches liegen unter:

ComfyUI/temp/cmk/

Ein erster Lauf nach Neustart, Codeänderung oder Cache-Bereinigung erzeugt erwartbar MISS → STORED. Unveränderte parallele Zweige und abgeschlossene Modulgrenzen sollen innerhalb derselben ComfyUI-Sitzung anschließend als HIT aufgelöst werden, ohne die teure Verarbeitung erneut auszuführen. Ein ComfyUI-Neustart leert diese Bild-Boundary-Caches; nur die ausdrücklich persistente Videoverarbeitung besitzt einen sitzungsübergreifenden Fortsetzungsvertrag.

Branch-Caches besitzen Revisionsmarker. Detailer- und FaceProcess-Boundaries akzeptieren einen HIT nur dann, wenn ihr Dependency-Manifest exakt zu den aktuell materialisierten Branch-Revisionen passt. Nach einer Änderung eines einzelnen Zweigs werden deshalb Merge und Boundary aktualisiert, während unveränderte Geschwister innerhalb derselben Sitzung aus ihrem Branch-Cache kommen.

CMK SEGS CONCAT übernimmt jedes vollständig komponierte Branch-Bild ausschließlich innerhalb des räumlichen Supports seiner tatsächlich zugeordneten SEG-Crop-Regionen. Eine Pixel-Differenzmaske wird nicht verwendet; dadurch können Quell- und Ergebnisbild nicht mehr als Salz-und-Pfeffer-Muster ineinander verschachtelt werden. Persistente Detailer-/FaceProcess-Branches liefern dafür ein cache-stabiles internes Vollbild-/Support-Artefakt. FaceProcess-Branches enthalten ausschließlich ihre ausgewählten Gesichter. Frische Ausführung und Cache-Hit verwenden denselben Merge-Pfad.

Die UI von CMK FaceProcess -Pipe- zeigt abhängig von PROCESS MODE ausschließlich die gemeinsamen Parameter sowie den aktiven Restore- oder Detailer-Parametersatz. Die Werte des inaktiven Satzes bleiben intern erhalten und werden beim Zurückschalten wiederhergestellt.

Caches sind temporäre Beschleuniger und kein portables Projektformat.

Videoverarbeitung

CMK Split Video into Segments wählt Videos aus input/video/, schreibt quellengetrennte Segmente nach output/video/segments/<video_name>/ und liefert den persistenten Arbeitskontext CMK_VIDEO_SEGMENTS für nachfolgende Video-Workflows.

CMK Merge and Save Video setzt die Segmente overlap-bereinigt nach output/video/merged/<video_name>/ zusammen, zeigt das Ergebnis im Player und veröffentlicht es optional ohne erneutes Encoding. CMK FaceSwap Video Loader ergänzt den persistenten Split-Pfad um Video- und Source-Auswahl.

CMK FaceSwap Video ist die historische Legacy-Referenz, mit der die Entwicklung von CMK begann. Der Workflow stammt aus CMK 1.0, wurde bewusst nicht auf die CMK-2.5-Architektur modernisiert und bleibt unverändert im aktuellen Umfeld lauffähig.

Dokumente

| Dokument | Aufgabe | |---|---| | ARCHITECTURE.md | verbindlicher aktueller Schnittstellen- und Architekturvertrag | | CMK_Design_Guidelines.md | UI-, Benennungs- und Darstellungsregeln | | README.md | Installation und Projektüberblick | | README.en.md | englische Installation und Projektübersicht | | CHANGELOG.md | historische Änderungen; keine aktuelle API-Definition | | WORKFLOWS.md | Subgraph-, Workflow- und Installationsübersicht | | SUBGRAPH_AUDIT.md | Nutzungsinventar und sicherer Bereinigungsplan der Subgraphs | | TOOLBOX.md | Produktgrenze, Funktionsinventar und Pflegeplan des offenen Baukastens | | CMK_FLOW_COMPATIBILITY.md | Entwurf des Integrationsvertrags für externe Baukasten-Nodes und Flow-Module | | CONTENT_GUARD.md | verbindliche lokale FaceSwap-Schutzpolicy, Abbruchregeln und Grenzen | | RELEASE_AUDIT_CMK_2_5.md | Abschlussaudit der CMK-2.5-Verträge, Tests und Release-Abweichungen |

Lizenz

CMK Flow ist freie Software unter der GNU General Public License, Version 3 oder – nach eigener Wahl – jeder späteren Version (GPL-3.0-or-later). Das bedeutet insbesondere:

  • CMK Flow darf kostenlos privat und kommerziell verwendet werden;
  • der Quellcode darf untersucht, verändert und weitergegeben werden;
  • weitergegebene Versionen und Änderungen müssen unter derselben Lizenz verfügbar bleiben und ihren Quellcode offenlegen;
  • Copyright- und Lizenzhinweise müssen erhalten bleiben;
  • die Software wird ohne Gewährleistung bereitgestellt.

Der vollständige Lizenztext steht in LICENSE. Lizenzen externer Custom Nodes, Modelle und anderer Abhängigkeiten gelten unabhängig davon weiter.

Entwicklungsregel

Eine funktionierende technische Lösung ist noch keine CMK-Lösung, wenn sie:

  • unnötige Anwenderentscheidungen erzeugt;
  • Fehlverkabelungen leicht ermöglicht;
  • interne Komplexität in den Hauptworkflow verlagert;
  • oder unveränderte teure Module erneut ausführt.

In solchen Fällen gewinnt die Architektur.