Wan 2.2 - FFLF - XT 404 - Master UI

🤖 XT-404 Skynet Suite: Wan 2.2 Integration

The "Omega Edition" for ComfyUI

The XT-404 Skynet Suite is a highly specialized, battle-tested collection of custom nodes for ComfyUI, specifically engineered for Wan 2.1 and 2.2 video diffusion models.

Unlike standard nodes, this suite focuses on "Visual Supremacy" —achieving 8K, OLED-grade quality with mathematical precision. It abandons generic processing for heuristic, context-aware algorithms that protect signal integrity, manage VRAM surgically, and eliminate digital artifacts.

⚠️ Requirements

ComfyUI: Latest version recommended.

Wan 2.2 Models: Ensure you have the VAE, CLIP, and UNet/Transformer models.

Python: 3.10+.

FFmpeg: Required for the Compressor node (usually via imageio-ffmpeg ).

Caution

INFILTRATION PROTOCOL (GGUF): To utilize GGUF Quantized Models with the Cyberdyne Model Hub , the ComfyUI-GGUF engine is REQUIRED . 📥 Download Engine: city96/ComfyUI-GGUF Without this engine, the Cyberdyne Model Hub will operate in Safetensors-only mode.

🚀 Key Features

Zero-Point Noise Injection: Eliminates static "snow" in video generation.

ARRI Rolloff Tone Mapping: Prevents white clipping even in high-contrast scenes.

Nano-Repair (Genisys): Real-time tensor monitoring to prevent black screens/NaNs caused by TF32 precision.

OLED/8K Workflow: Dedicated pipeline for deep blacks, organic grain, and micro-detail hallucination.

Sentinel Telemetry: Real-time console logs ( "The Mouchard" ) that analyze saturation, clipping, and VRAM usage per step.

📦 Installation

Navigate to your ComfyUI custom nodes directory:

cd ComfyUI/custom_nodes/

Clone this repository:

git clone https://github.com/YourUsername/XT-404-Skynet-Suite.git

Install requirements:

pip install imageio-ffmpeg scikit-image

🛠️ Module Breakdown

1. The Core Engine ( XT404_Skynet_Nodes.py )

The heart of the generation process. Replaces standard KSamplers with a hybrid engine optimized for Wan's Flow Matching.

Zero-Point Fix: Ensures 0 + Noise = Pure Noise , clearing the latent before injection.

Wan Sigma Calculator: Uses the specific shift formula required by Wan 2.1/2.2.

Chain Architecture: Facilitates "Hires Fix" by passing the master sigmas clock between nodes.

2. Universal Loader ( cyberdyne_model_hub.py )

A unified loader for Checkpoints, SafeTensors, and GGUF models.

Recursive Search: Finds models in subdirectories automatically.

GGUF Delegation: Detects GGUF files and routes them to the appropriate backend.

Smart Offload: Aggressively offloads unused models to RAM to free VRAM for the sampler.

3. Visual Supremacy Suite ( wan_visual_supremacy.py )

The "Secret Sauce" to cure the "AI Plastic Look."

Latent Detailer X: Injects micro-details before decoding while preventing signal saturation.

Temporal Lock Pro: A post-decode stabilizer that blends low-delta frames to eliminate flicker.

OLED Dynamix (ARRI Rolloff): Logarithmic compression curve that preserves highlight textures.

4. Nano-Repair System ( wan_genisys.py )

Node: Cyberdyne Genisys [OMNISCIENT]

Function: Solves "Black Screen" issues in TF32/BF16 by calculating tensor drift and clamping values before they hit NaN.

5. T-X Interpolator ( wan_tx_node.py )

Function: Generates video between a Start and End image.

Innovation: Uses Inverse Structural Repulsion to force the model to hallucinate a transformation path rather than a simple blend.

🎛️ Recommended Workflow Strategy

For the ultimate 8K OLED look, chain the nodes in this specific order:

Loader: Cyberdyne Model Hub (Load Model & VAE).

Prompt: Wan Text Cache & Wan Vision Cache .

Generation: WanImageToVideoUltra → XT-404 Skynet 1 (Master) .

Refinement: XT-404 Skynet 3 (Refiner) (Denoise 0.3).

Decode: VAE Decode .

Visual Supremacy Stack:

Temporal Lock Pro (Stabilize pixels).

OLED Dynamix (Sculpt light).

Organic Skin (Add texture).

Final Polish: Wan Chroma Mimic (Validate signal & sharpen).

Encode: Video Combine → Wan Compressor .

📟 The Console HUD (XT-Mouchard)

Don't ignore the console! The suite communicates signal health:

🟢 GREEN: Signal is healthy.

🟡 YELLOW: High signal detected (Rolloff is active).

🔴 RED: Critical saturation/clipping (Lower specular_pop ).

Example Log:

[XT-MIMIC] 🎨 FINAL VALIDATION | DynRange: [0.000, 0.982] └── Signal Integrity: OK (Clip: 0.00%)

This indicates mathematically perfect blacks and whites capped at 98.2% to allow for display bloom.

📜 Credits

Architect: XT-404 Omega

Corp: Cyberdyne Systems

Status: GOLD MASTER (V3.8)

"There is no fate but what we make."

Maintained by Cyberdyne Research Division. Open an issue for "Infiltration Reports."

🤖 XT-404 Skynet : Wan 2.2 Sentinel Suite (OMEGA EDITION)

Cyberdyne Systems Corp. | Series T-800 | Model 101

"The future is not set. There is no fate but what we make for ourselves."

⚠️ CRITICAL SYSTEM DEPENDENCY

Caution

INFILTRATION PROTOCOL (GGUF): To utilize GGUF Quantized Models with the Cyberdyne Model Hub , the ComfyUI-GGUF engine is REQUIRED .

📥 Download Engine: city96/ComfyUI-GGUF

Without this engine, the Cyberdyne Model Hub will operate in Safetensors-only mode.

🚀 WHY CHOOSE XT-404 SKYNET? (Competitive Analysis)

Standard nodes rely on generic implementations. XT-404 Skynet is a custom-engineered architecture built specifically for the quirks of Wan 2.2 .

Feature Standard Nodes / Competition 🤖 XT-404 Skynet Architecture Precision Standard FP16/BF16 (Prone to Banding) Hybrid FP32/TF32 Contextual Switching (Zero Banding) Interpolation Basic Linear Fades (Static/Frozen) T-X Dual-Phase Wrapper (Native VAE Injection) Color Science RGB Clipping LAB Space Transfer & OLED Dynamics (Cinema Grade) Caching Basic TeaCache (Motion Freeze Risk) T-3000 Genisys w/ Kinetic Momentum & Nano-Repair Scaling Bilinear (Blurry) Lanczos/Bicubic FP32 (Pixel Perfect) Memory High VRAM Usage (OOM Risk) Surgical Pinned Memory (DMA) & Aggressive Purge

🌍 NEURAL NET NAVIGATION

🇺🇸 ENGLISH DOCUMENTATION

Visual Engineering (Wan Chroma Mimic)

Infiltration (Model Loader)

Neural Net Core (XT-404 Samplers)

T-3000 Genisys (Omniscient Cache)

Mimetic Rendering (I2V Ultra & Fidelity)

Polymetric Alloy (T-X Dual-Phase) 🆕

Sensors & Accelerators (Omega Tools)

Post-Processing & Automation

🇫🇷 DOCUMENTATION FRANÇAISE

Consultez la version française pour les détails techniques complets.

🇺🇸 ENGLISH DOCUMENTATION

🎨 Phase 0: Visual Engineering (Wan Chroma Mimic)

File: wan_chroma_mimic.py

The Ultimate Color Grading Engine. This is not a simple filter. It operates in real-time on the GPU , converting image tensors to the LAB Color Space to separate luminance from color information, allowing for cinema-grade referencing without destroying lighting data.

🔥 Key Features & Configuration

Architecture: 100% PyTorch GPU. 0% CPU latency.

Morphological Filter: Removes micro-artifacts (black/white dots) generated by video diffusion before they expand.

OLED Dynamics: Applies a non-linear S-Curve centered on 0.5 to deepen blacks while preserving peak highlights.

Parameter Recommended Description reference_image REQUIRED The source image (style reference). The mood is extracted from here. effect_intensity 0.25 Blending strength of the LAB transfer. oled_contrast 0.00 The "Netflix" Look. Boosts dynamic range. 0.0 = Neutral. skin_metal_smooth 0.25 Smart Surface Blur. Smoothes skin/metal but detects edges to keep sharpness. detail_crispness 0.2 Cinema Piqué. Enhances micro-details using a difference-of-gaussians approach.

🛡️ Phase 1: Infiltration (Cyberdyne Model Hub)

File: cyberdyne_model_hub.py

A unified loader bridging Safetensors and GGUF architectures. It solves the "Dual-UNet" requirement of Wan 2.2 automatically.

Recursive Scanner: Finds models in subfolders.

Skynet Protocol: Active VRAM management. It calculates the checksum (SHA256) and purges memory before loading to prevent fragmentation.

Hybrid Loading: Can load a High-Res FP16 model and a Low-Res GGUF model simultaneously.

🧠 Phase 2: Neural Net Core (XT-404 Samplers)

File: XT404_Skynet_Nodes.py

The "Sentinel" engine. Unlike standard samplers, these are hard-coded with the simple (Linear) scheduler required by Wan 2.2, preventing the "fried output" issues seen with standard KSamplers.

🔴 XT-404 Skynet 1 (Master)

Shift Value (5.0): The critical setting for Wan 2.2 latent timing.

Bongmath Engine: A custom texture-noise injection system.

True : Adds analog film grain coherence.

False : Pure digital cleanliness.

🟡 XT-404 Skynet 2 (Chain)

Seed Lock: Automatically inherits the seed from the Master node via the options dictionary. Ensures temporal consistency across generation passes.

🟢 XT-404 Skynet 3 (Refiner)

Resample Mode: Injects controlled noise at the end of the chain to hallucinate high-frequency details.

💀 Phase 3: T-3000 Genisys (Omniscient Cache)

File: wan_genisys.py

Superior to TeaCache. Standard TeaCache freezes video motion when the difference is too low. T-3000 uses "Kinetic Momentum".

Kinetic Momentum: If motion is detected, it forces the next X frames to calculate, preventing the "mannequin challenge" effect.

Nano-Repair: Detects NaN or Inf values (black screen bugs) in the tensor stream and surgically repairs them using soft-clamping (-10/+10) instead of hard clipping.

HUD: Displays real-time signal integrity and drift metrics in your console.

🎭 Phase 4: Mimetic Rendering (I2V Ultra & Fidelity)

Files: nodes_wan_ultra.py / wan_fast.py

🌟 Wan Ultra (The Quality King)

Nuclear Normalization: Sanitizes input images to strictly 0.0-1.0 range using Bicubic-AntiAlias.

Detail Boost: Applies a sharpening convolution matrix before VAE encoding to counteract compression blur.

Motion Amp: Uses a "Soft Limiter" (Tanh curve) to amplify motion vectors without breaking physics.

⚡ Wan Fidelity (The Speed King)

Optimization: Uses torch.full instead of concatenations for memory efficiency.

Logic: Restores the original Wan 2.1 context window logic for perfect temporal coherence.

🧪 Phase 6.5: Polymetric Alloy (T-X Dual-Phase) [NEW]

File: wan_tx_node.py

The Interpolation Singularity. Standard I2V models struggle to reach a specific end frame (often freezing or losing style). The T-X Engine uses a Native VAE Injection Wrapper to bridge the timeline perfectly.

Keyframe Injection: Temporarily overrides the VAE's internal logic to encode [Start Frame -> Empty Void -> End Frame] without corrupting the latent space.

Fluid Morphing: Forces the Wan 2.2 model to solve the physics equation between Point A and Point B, preventing "slideshow" effects.

Smart VRAM Scanner: Automatically detects GPU capacity to switch between "Safe" (512px tiling) and "Ultra" (1280px tiling) modes.

Parameter Description start_image The origin frame (Frame 0). end_image The target frame (Frame N). The T-X engine forces convergence to this image. motion_amp Amplifies the latent motion vectors between keyframes. detail_boost Pre-processing sharpening to retain texture during VAE compression.

⚡ Phase 5: Sensors & Accelerators (Omega Tools)

🚀 Wan Hardware Accelerator (Anti-Burn V4)

File: wan_accelerator.py The "Secret Sauce" of performance.

Problem: Enabling TF32 on Wan 2.2 normally "burns" images (contrast issues) due to normalization errors.

Solution (Contextual Switching): This node enables TF32 globally for speed, but intercepts GroupNorm and LayerNorm layers to force them into FP32 precision.

Result: 30% speed boost of TF32 with the visual quality of FP32.

👁️ Wan Vision & Text Cache (DMA)

File: wan_i2v_tools.py

Pinned Memory: Uses CPU Page-Locked memory (DMA) to transfer text embeddings to GPU instantly.

Vision Hash: Hashes the image content (including...

Pack de nœud · Registry