Just my personal workflow, i am not responsible for creating the model or the nodes!!!

Use the nodes and models below in the description!!!

Nodes > https://github.com/XT-404/XT-404_SKYNET

Lora Loader https://github.com/HenkDz/rgthree-comfy

Models> https://civarchive.com/models/2244942?modelVersionId=2527274

🤖 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

🇺🇸 ENGLISH DOCUMENTATION

🇫🇷 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 stride) to avoid re-encoding the same CLIP Vision input.

🛠️ Phase 6: Post-Processing & Automation

Wan Compressor (Omega): Thread-safe H.265 encoding. Limits CPU threads to 16 to prevent Threadripper/i9 crashes.
Wan Cycle Terminator: Uses Windows API EmptyWorkingSet to flush RAM standby lists (prevents OS stutter).
Auto Wan Optimizer: Smart resizer that enforces Modulo 16 dimensions (required by Wan) and protects against OOM (>1024px).

Files with SHA256: fa4a73c81c8b49b30688243554e4b3fedc49d567873b1307d835f2981f407c12