ComfyUI Workflows

Fabin LTXV 2.3 Simple workflow

Workflow for LTXV 2.3 v1.1 i2v and t2vupdate: 2026-05-22 v1.0AllInOne version include a workflow that you can use checkpoints AIO or diffusion models and you can use to I2V and T2V all in one workflow.the workflow also includes Random prompts and Load Img from Dir.update: 2026-06-03 v1.1I made some adjustments to the T2V section.

✦ NIGHTRUN ✦ Overnight Forge Randomizer (Low-High VRAM Optimized)

Installation — Folder StructureNightrun expects to live two levels inside your WebUI folder:YOUR-WEBUI-FOLDER\ workflows\ nightrun_2.0\ ← hereA local Forge companion that builds structured prompt batches, runs them overnight, manages metadata-based upscales, and watches the boring parts, so your PC can do the babysitting for once.GitHub Link: https://github.com/Bluenochian/NightrunNightrun 2.0A portable workflow system for Stable Diffusion Forge / Forge-Neo.Nightrun is not a model. Not a LoRA. Not a prompt file.It is the system that sits beside Forge and turns a messy local generation setup into something that can run for hours — without you checking whether the prompt broke, a LoRA name was wrong, the GPU is cooking itself, or the batch slowly turned into repetitive garbage.Nightrun is built for long local runs, editable prompt pools, metadata replay, LoRA-aware batching, upscale workflows, cooldown logic, and controlled randomness.Set the run. Leave it alone. Come back to something organized, replayable, and worth sorting through.What Nightrun DoesNightrun builds prompts from editable pools, sends jobs through Forge, writes replayable metadata, manages upscales, scans LoRAs, protects long runs with cooldown logic, and keeps the whole thing configurable.It is made for people who want big batches without babysitting every prompt, every upscale, every progress bar, and every local setup problem.Controlled chaos. Not prompt soup.What's New in 2.0Modular ArchitectureThe engine was split from a single ~2055-line file into a purpose-driven module system:nightrun_runtime.py — core shared logicprompt_engine.py — pool loading, weighted selection, prompt compositionlora_resolver.py — LoRA scanning, aliases, tag constructionforge_client.py — Forge API, txt2img/img2img, GPU guardsrunner.py — execution modes, output folders, cleanup, cooldowns, summariesvalidation.py — pool validation and dry-run reportingnightrun_engine.py — compatibility shim for older importsnightrun.py is now a thin entrypoint that only imports and runs main().Three-Engine Prompt RoutingPrompt generation now routes through three distinct builders, selected by weighted random choice (default 1/1/1). You can control routing via prompt_engines in config, or disable it to revert to legacy behavior.Classic — Standard pool sampling with optional world module support. Closest behavior to 1.5, cleaned and optimized.Combinator — Builds on Classic output by applying controlled transformations:Internal combinators modify existing elements (e.g. a katana becomes a burning variant)External combinators inject additional motifs (e.g. surreal, cursed, steampunk layers)At least one combinator fires per prompt, capped at twoFranchise — Forces generation through a world module from franchise_catalog.py. All visual elements are sourced from that universe for full coherence. Falls back to Classic if no module is available.Prompt Cleanup PipelineA post-processing stage via prompt_cleanup now runs after every engine:Duplicate comma-tag removalConcept-family repetition controlCompact SD-style prompt length enforcementRemoval of redundant subject labels when already impliedConsistent prompt structure across all three engines.Prompt Pools — Full RebuildAll pools were rebuilt for SD-style tag efficiency. Verbose prose entries are gone. 2.0 uses compact, composable tags throughout.Pool 1.5 lines 2.0 lines concept.txt 3,601 154 genre.txt 8,317 2,743 glamour_pose.txt 4,241 761 clothing.txt 1,801 721 character.txt 701 44 body_focus.txt 1,105 481 sensual_layer.txt 1,921 529 hair.txt 2,401 790Removed: character_loras.txt, style_loras.txt, lora_sampler_speed.txtAdded: genre_core.txt (69 lines), genre_root.txt (475 lines)A curated weighting system (curated_top_count / curated_top_weight) boosts high-quality early entries without removing full pool diversity.Franchise Catalog — Expanded to ~50 ModulesModules now use full dictionary-based definitions instead of compact tuples. The catalog grew from ~24 to ~50 entries:alien batman bloodborne cowboy_bebop doctor_who dungeons_and_dragons elder_scrolls evangelion final_fantasy_vii game_of_thrones halloween hellraiser lord_of_the_rings matrix midsommar nier_automata nightmare_on_elm_street persona pokemon scream shadowrun terminator the_conjuring the_ring the_witcher vampire_masquerade x_men zeldaNew filtering controls without touching the catalog directly: enabled_module_ids / disabled_module_ids / enabled_source_names / disabled_source_names / label_allow_patterns / label_block_patternsSelection Memory — RetunedLarger recent history windows across categoriesReduced repetition penalties for more natural variationAdded concept-level tracking via recent_conceptsDedicated repetition control for candle/light motifsCurated weighting for high-quality biasingConfig Changesfixed_suffix updated for sharper SD output:Before: clean coherent design, sharp focus, high detail, polished lightingAfter: crisp linework, sharp focus, high detail, clear material texture, clean color separation, high micro-contrast, dramatic lightingbase.steps_min raised: 30 → 50Output folders now use nightrun-YYYYMMDD-HHMMSS--reset-local now preserves local tuning instead of overwriting itNew VRAM Profile — tuned_6gbSetting Value Base resolution 1344×768 Upscale resolution 3072×1728 Steps 65 LoRA cap 7 VRAM threshold ≤ 6144 MBNSFW — sensual_layer ExpansionThe sensual_layer pool was fully reworked to properly support explicit NSFW generation paths. It now includes dedicated nudity, erotic styling, body exposure, lingerie, fetish-adjacent aesthetic, and mature composition tags designed to integrate cleanly with the SD-style prompt system and franchise/genre routing.NSFW is enabled by default. For SFW-only runs, open config.json, find sensual_layer, and set "chance": 0.Core FeaturesEditable Prompt PoolsNightrun uses plain .txt prompt pools instead of one giant hardcoded prompt. Edit pool files to change how the whole machine behaves:concept genre genre_core genre_root character hair eyes clothing pose glamour_pose expression sensual_layer body_focus equipment environment lighting camera effects style_layer color_grade composition detail and more.The world module system is deeper and optional. The pool system is where most users should start.Controlled RandomnessNightrun is random — but not stupid-random. You can configure:Pool chances and pick countsBoosted chances when related pools appearBase step rangesLoRA chances, weight ranges, and capsWorld module and fusion mode chancesCooldown timing and upscale behaviorSelection memory and color repetition penaltiesYou are not stuck with one fixed behavior. Tune the machine until it behaves like your machine.Selection MemoryDuring a run, Nightrun remembers recent choices and penalizes repetition. It tracks broad color families — blue, cyan/teal, red, purple, green, gold, black, silver, iridescent — so if a batch starts drifting into one color mood, it pushes away.This is one of the main reasons long runs do not feel repetitive.Rare Detail ControlSome details are only interesting when they stay rare. Heterochromia, for example, can be configured so it does not take over an entire batch. Special things stop feeling special when every third image has them.LoRA HandlingNightrun does not blindly slap LoRAs into the prompt. It can:Scan local LoRA folders and resolve namesUse aliases and soft-match ugly filenamesSkip missing LoRAs without crashing the runRandomize LoRA weights within configured rangesAdd synergy/support LoRAs with controlled chancesCap random and total LoRA countsDeduplicate final LoRA tagsLocal LoRA libraries are messy. Civitai names, trigger names, and local filenames are often all slightly different. Nightrun tries to survive that.Coherent World ModulesThe normal prompt pools are the everyday engine. The world module system is the coherence layer.When it activates, Nightrun selects a world/franchise module and pulls related elements from the same source family — character archetypes, outfits, environments, props, factions, technology, magic systems, lighting mood, color palettes, cinematic language, and more.The goal is not to replace the normal pools. The goal is to give the run a coherent themed spine when that system activates.Fusion mode allows controlled cross-world combinations while reducing risky generic pool chances — unusual mixes without the machine blindly dumping everything into one prompt.Long-Run SafetyGPU temperature pause — Nightrun watches GPU temperature through nvidia-smi. If the GPU gets too hot, it pauses. When it cools below the configured resume threshold, it continues.VRAM chill sessions — For big batches, Nightrun schedules random cooldown sessions. Run several generations, pause for a few minutes, let the system settle, continue. Small thing. For overnight workflows it matters.Between-image rest — Configurable sleep time between images so the machine is not being tortured nonstop.Nightrun is not just "go fast." It is "keep going safely."Upscale WorkflowNightrun supports both scheduled upscale workflows and metadata-based re-upscaling. It can:Generate base images and upscale during full runsAuto-upscale low-step base rendersAccept drag-and-drop metadata for upscalingRecreate from metadata if neededWrite new metadata beside upscaled imagesChain later upscales from previous upscale metadataA fast base image does not have to stay a rough base image. Low-step renders can go through upscale logic and recover quality without burning time on every single base generation.Metadata ReplayEvery image gets a metadata sidecar with everything important saved:seed prompt negative prompt selected pools selected modules LoRAs LoRA sources base steps status upscale reason errors GPU infoSo later, you are not staring at a good image wondering what made it. The answer is saved beside it.Validation and Dry-RunValidation mode checks pool loading, prompt formatting, LoRA resolution, missing resources, alias behavior, and generation logic — before wasting GPU time.Dry-run mode writes prompt and metadata without calling Forge image generation. See what the run would do before committing to a real batch.Measure twice. Render once.Prompt Variety AnalyzerA built-in tool scans old metadata and reports:Repeated categories, colors, and modulesRepeated prompt fragmentsWorld module usage patternsExact prompt repeatsSigns that a batch is becoming too sameyTune the machine instead of guessing.OutputsEach run creates an organized folder:nightrun-YYYYMMDD-HHMMSS/ 0001_base_WIDTHxHEIGHT.png 0001_upscale_WIDTHxHEIGHT.png 0001_prompt.txt 0001_metadata.json summary.json run.log contact_sheet.jpg validation_report.json Exact files depend on the run mode.Basic UsageTask Launcher First-time setup Run First Setup.bat Validate before rendering Run Validation Stress Test.bat Preview one prompt, no render Run One DRY TEST.bat Base generation only Run Nightrun BASE only.bat Full run with scheduled upscale Run Nightrun FULL upscale.bat Re-upscale from metadata Run 2x Upscale From Metadata.bat Analyze prompt variety Run Prompt Variety Analyzer.bat Stop cleanly after current image Stop After Current Image.batMetadata Upscalingpy upscale_from_metadata.py "D:\renders\0001_metadata.json" --config config.local.json --scale 2 Force base image as source:py upscale_from_metadata.py "D:\renders\0001_metadata.json" --config config.local.json --source base --scale 2 Use an existing upscale as source:py upscale_from_metadata.py "D:\renders\0001_metadata.json" --config config.local.json --source upscale --scale 2 Dry-run the upscale:py upscale_from_metadata.py "D:\renders\0001_metadata.json" --config config.local.json --scale 3 --dry-run First-Run SetupThe setup script creates a local config for your machine. It will:Ask for your Forge / Forge-Neo path and output folderDetect your VRAM profileCheck checkpoint path and count local LoRAsCheck for Ultimate SD UpscaleCreate config.local.json and desktop shortcutsThe shared config.json stays portable. Your private machine paths stay in config.local.json. The project can be shared without leaking your local folder structure.Recommended ForNightrun is useful if you:Use Forge / Forge-Neo locallyGenerate in large batches or overnight runsWant editable prompt pools instead of hardcoded promptsUse many LoRAs and want safer handlingWant metadata replay for good imagesWant upscaling tied to generation metadataWant less repetitive outputs over long runsWant a workflow you can tune instead of replaceNotesNightrun does not include checkpoints, LoRA files, model files, Forge itself, or Ultimate SD Upscale. You need your own local Forge / Forge-Neo setup and your own models.Franchise and world module names are used as inspiration labels for prompt organization only.License / Usage noteUse this with models, LoRAs, and extensions you are allowed to use.Franchise module names are inspiration labels for prompt organization. Nightrun does not include model files, LoRA files, checkpoints, or copyrighted assets.Nightrun is a prompt generation and batch runner tool. It does not include, distribute, or download any AI models, checkpoints, LoRAs, extensions, or generated images. All content is produced locally using software and model files you have installed yourself.You are solely responsible for the models and extensions you use, the content you generate, compliance with third-party license terms, and compliance with the laws of your jurisdiction.NSFW generation is supported. It is your responsibility to ensure any explicit content you generate is legal in your jurisdiction. This tool must not be used to generate illegal content of any kind.Nightrun is provided as-is, without warranty of any kind.Built for the dark hours between intention and discovery.

ComfyUI - Chroma-unlocked-v48-detail-calibrated - Easy to use, (By: Rafaelldestilo)

A simple workflow I created for my own use and have been refining over several days until reaching its current state.Easy selection of image aspect ratios:1:12:3 Civitai4:316:9Scale upscaling, which in my opinion is better in Chroma, especially with Lexica and NMDK. Lexica provides a strong sharpening effect, adding more detail, while NMDK performs scale upscaling with very good detail refinement.The 2x version of NMDK would be the same as the 4x, but with scale down, thus remaining at 2x and saving disk space.Mode 10 is already enabled in aesthetic mode; I always use it, but you can easily disable it if you want.Enable the Sage Attention patch if you have it; otherwise, just disable it.Option to generate in 512x and HD 1024x (select only 1 image aspect ratio at a time)Easy seed selection.Supports LoRa Loader; if you don't have it, simply disable it with Bypass."Includes LoRa Loader, where you simply select the LoRa image using the LoRa Manager. The image already comes in the correct size and with the activation keys synchronized by Civitai; only the size needs to be configured separately. In my opinion, it's the best LoRa selector currently available.I don't use LoRa in Chroma; the model itself is magnificent, the best model with the M.I.D.J.O.U.R.N.E.Y aesthetic in my opinion.This workflow is designed for use with the "Chroma-unlocked-v48-detail-calibrated" model.

LTXV2.3 GGUF I2V/T2V/FFLF+IDaudioLora 12gb Vram sageattn

A simple, color-coded GGUF workflow for running LTXV-2 in ComfyUI.Designed to be straightforward and lightweight.Common IssuesError: LTXVEmptyLatentAudio – AttributeErrorUpdate Kijai Node Pack to v1.2.8Checkerboard / patterned noise outputUpdate all nodes + ComfyUI(Outdated GGUF loader or ComfyUI build)Required Node PacksComfyUI-GGUFhttps://github.com/city96/ComfyUI-GGUFComfyUI-KJNodeshttps://github.com/kijai/ComfyUI-KJNodes (install & update it to nightly)additional install via manager📦 Downloads🧩 Kijai’s Repo (ALL files except diffusion models — choose ONE LoRA)https://huggingface.co/Kijai/LTX2.3_comfy/tree/mainIncludes:Distilled LoRA (REQUIRED)Text Projection (embedding connector)🧠 Diffusion Models (GGUF)https://huggingface.co/unsloth/LTX-2.3-GGUF/tree/mainChoose based on VRAM:Q4_K_M → lower VRAM (recommended)Q8_0 → higher quality, more VRAM⚠️ Very low quants = basically unusableIncludes:VAE (audio + video)GGUF models✍️ Text Encoders (REQUIRED)Option 1 – Gemma (recommended for low VRAM)https://huggingface.co/Comfy-Org/ltx-2/tree/main/split_files/text_encodersOption 2 – Full version (higher VRAM, better quality)➡️ You still ALSO need:Text Projection (from Kijai’s repo)🔍 Latent Upscalerhttps://huggingface.co/Lightricks/LTX-2/tree/main/Files:ltx-2-spatial-upscaler-x2-1.0.safetensorsltx-2-temporal-upscaler-x2-1.0.safetensors⚠️ Important NotesUse DEV GGUF diffusion models (no distilled base model yet)Distilled LoRA is still REQUIREDMost issues = outdated nodes or ComfyUI.

Wan2.2 Animate Action Transfer V7 in ComfyUI | Motion-To-Character Video

Makes your characters move exactly like real people—fast and controlled.Who it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewWith this advanced motion mapping setup, you can transform any performer’s movement into vivid character animation while keeping full identity consistency. The workflow enables smooth action transfer from reference clips using pose, face, and ControlNet support. It provides repeatable testing, optimized RunComfy integration, and fast MP4 export. Ideal for animators needing precise motion replication. Perfect for creators focusing on expressive, controllable motion transfer videos.NotesWan2.2 Animate Action Transfer V7 in ComfyUI | Motion-To-Character Video — see RunComfy page for the latest node requirements.

FLUX Redux ACE Face Swap in ComfyUI | Photo Identity Transfer

Create consistent, natural identity swaps with advanced reference image control.Who it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewThis compositing workflow helps you create flawless face replacements using guided reference matching and image-to-image diffusion. It preserves lighting, pose, and background layout, ensuring natural integration. Designed for artists who need identity consistency across frames or styles. Adjust prompts to refine expressions or stylize the final composition. Perfect for character continuity, portrait design, and photo-based storytelling. Efficient, flexible, and visually coherent.NotesFLUX Redux ACE Face Swap in ComfyUI | Photo Identity Transfer — see RunComfy page for the latest node requirements.

Upscaler+FaceDetailer+easy stylesSelector

Easy to understand, has everything you need for high-quality images

Consistent AI Portrait Animator (AnimateDiff + IPAdapter Plus)

Professional AI Pipeline: Identity-Preserved Temporal AnimationThis is a custom ComfyUI workflow engineered for high-end digital character creation. It provides a robust solution for the "identity drift" problem in AI video, ensuring 100% facial consistency across dynamic frames.Technical Architecture & Features:Neural Identity Mapping: Implements a precise identity-locking mechanism using IPAdapter Plus to maintain the user's unique facial features.Temporal Coherence Engine: Utilizes a customized AnimateDiff-Evolved setup to generate fluid, flicker-free movement.Modular Phase Design: The workflow is logically structured into three distinct phases—Data Ingestion, Motion Synthesis, and High-Res Refinement—allowing for granular control over the output.Production-Ready Output: Optimized for generating high-fidelity video sequences (H.264/MP4) suitable for professional digital portfolios.Developer's Note: This project serves as a technical demonstration of advanced AI pipeline integration, focusing on the intersection of portrait photography and temporal neural synthesis.

LTX-2.3-Video-Face-Swap in ComfyUI | Realistic Face Replacement Workflow

Swap faces in video with natural results and zero flicker.Who it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewWith this advanced face replacement workflow, you can effortlessly swap faces in video while maintaining natural expressions, consistent lighting, and temporal accuracy. Ideal for creators and VFX artists, it ensures stable identity tracking and coherence across every frame. Leveraging LTX 2.3’s diffusion-driven design, it minimizes flicker and improves realism. You can fine-tune control prompts for creative flexibility and polished outcomes. Perfect for AI filmmakers seeking professional-grade face-swapping without complex manual work.NotesLTX-2.3-Video-Face-Swap in ComfyUI | Realistic Face Replacement Workflow — see RunComfy page for the latest node requirements.

Wan 2.1 Video Restyle | Transform Video with First Frame for Consistent Stylization

Transform your video style by applying the restyled first frame using Wan 2.1 video restyle workflow.Who it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewUpdated 6/16/2025: ComfyUI version updated to v0.3.39 for improved stability and compatibility, with SageAttn installed for 30% faster generation. Wan 2.1 video restyle is a powerful video-to-video workflow designed for Wan 2.1 models. It allows users to apply the look of a stylized first frame to an entire video sequence, achieving high-quality transformations without complex manual adjustments. Ideal for animations, cinematic scenes, and creative projects, this workflow ensures seamless and coherent stylization across all frames.Important nodes:Green:Purple:NotesWan 2.1 Video Restyle | Transform Video with First Frame for Consistent Stylization — see RunComfy page for the latest node requirements.

Wan 2.1 Fun Motion Control | AI Photo-to-Video Animation

Design motion paths to animate still photos into videos.Who it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewWan 2.1 Trajectory Control is a specialized workflow within the Wan 2.1 Fun family that enables motion-controlled video generation from a single input image. By drawing or defining a trajectory path, users can guide the camera or subject movement across frames to produce cinematic effects, animations, or dynamic storytelling scenes. This method unlocks powerful control over motion planning while keeping the artistic direction intact. Built for the Wan 2.1 Fun model ecosystem, this workflow makes high-quality AI video synthesis accessible and intuitive.Important nodes:Positive Prompt:Negative Prompt:NotesWan 2.1 Fun Motion Control | AI Photo-to-Video Animation — see RunComfy page for the latest node requirements.

Wan 2.1 Fun | Image-to-Video and Text-to-Video AI Generation

Empower your AI videos with Wan 2.1 Fun.Who it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewUpdated 6/16/2025: ComfyUI version updated to v0.3.39 for improved stability and compatibility. This Wan 2.1 Fun workflow supports both image-to-video and text-to-video generation modes, offering a versatile creative toolkit for AI-powered motion content. From transforming static images into dynamic scenes to crafting imaginative sequences from pure text prompts, this setup uses the Wan 2.1 Fun model’s capabilities to deliver coherent, cinematic results. It supports prompt-based transitions, frame prediction, and flexible durations, making it perfect for digital storytelling, AI animation, or experimental media art.Important nodes:Positive Prompt:Negative Prompt:NotesWan 2.1 Fun | Image-to-Video and Text-to-Video AI Generation — see RunComfy page for the latest node requirements.

Wan FusionX Workflow ComfyUI | Ultimate Video Generation

Most powerful video generation solution yet! Cinema-grade detail, your personal film studio.Who it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewThis comprehensive Wan FusionX workflow represents the new king in video generation technology. Built on the fusion of CausVid, AccVideo, MoviiGen1.1, and MPS Reward LoRA, this all-in-one solution delivers cinema-grade video quality in just 6 steps. The workflow integrates complete Text-to-Video and Image-to-Video capabilities, plus the full VACE 14B 5-function solution (reference-based subject replacement, dual-image video generation, first/last frame control, object modification, and video expansion). This represents the pinnacle of current video generation technology, offering unprecedented speed, quality, and versatility in a single unified workflow.Important nodes:AccVideoMoviiGen1.1Positive Prompt:Negative Prompt:CFG:Steps:Shift:Sampler:Frames:TeaCache:Lower Shift (1-2):Higher Shift (3-9):Frame Rate:Model Selection:Enhanced Quality:Enhanced Reference Image + ControlNet:Depth Control:OpenPose Control:NotesWan FusionX Workflow ComfyUI | Ultimate Video Generation — see RunComfy page for the latest node requirements.

Flux Kontext Character Turnaround Sheet LoRA

Generate 5-pose character turnaround sheets from single imageWho it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewTransform any illustrated character into a complete turnaround sheet with five distinct poses using this Flux Kontext Character Turnaround Sheet LoRA workflow. Generate front, profile, 3/4, and back views from a single input image, perfect for 3D modeling pipelines, animation projects, or comprehensive character references. Works best with stylized and illustrated characters.Important nodes:Load ImageCLIP Text Encode (Positive Prompt)Save ImageNotesFlux Kontext Character Turnaround Sheet LoRA — see RunComfy page for the latest node requirements.

ComfyUI Flux Kontext 360 Degree LoRA Workflow

Generate immersive 360-style images with depth and spatial control.Who it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewThis ComfyUI workflow produces seamless 360-degree-styled images with enhanced depth, perspective accuracy, and artistic consistency via Flux Kontext 360 Degree LoRA. Ideal for VR content creators, 360 photographers, and digital artists looking to create immersive panoramic visuals and virtual reality experiences.Important nodes:Always use 2:1 aspect ratioDefault 2.5Lower (1.5-2.0)Higher (3.0-4.0)Enable "Half Tile" overlap2x upscaleNotesComfyUI Flux Kontext 360 Degree LoRA Workflow — see RunComfy page for the latest node requirements.

Consistent-Face-3x3-Generator | FLUX and Depth LoRA

Generate 3x3 consistent character faces using FLUX and Depth LoRAWho it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewThe Consistent-Face-3x3-Generator creates a 3x3 grid of the same character in nine varied poses. Built using the FLUX model in combination with its dedicated Depth LoRA, this Consistent-Face-3x3-Generator ensures high structural consistency across each variation. It's perfect for character exploration, design documentation, or building datasets where identity preservation across multiple perspectives is essential.Important nodes:ComfyUI/output/YYYY-MM-DD/NotesConsistent-Face-3x3-Generator | FLUX and Depth LoRA — see RunComfy page for the latest node requirements.

ComfyUI FLUX Kontext LoRA Workflow | Style Transfer + Visual Remix

Mix 13 art styles instantly or plug in custom LoRAs!Who it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewThis FLUX Kontext LoRA workflow empowers designers with layered style transfer, color tweaks, and advanced visual transformation tools. Choose from 13 curated Kontext LoRA models or plug in your own custom LoRAs for unlimited creative possibilities.Important nodes:Load ImagePower Lora Loader (rgthree)CLIP Text EncodeSave ImageNotesComfyUI FLUX Kontext LoRA Workflow | Style Transfer + Visual Remix — see RunComfy page for the latest node requirements.

FLUX Kontext OmniConsistency LoRA

22 unique styles, perfect consistency, clean results, all done faster.Who it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewBuilt on the powerful Kontext Dev ecosystem, this ComfyUI workflow integrates the OmniConsistency LoRA to deliver 22 distinct artistic styles with remarkable consistency. Enhanced with Nunchaku acceleration, transform your images into stunning artwork in just moments. Experience lightning-fast style transfers while maintaining the essence and details of your original content.Important nodes:LoadImageSaveImageNotesFLUX Kontext OmniConsistency LoRA — see RunComfy page for the latest node requirements.

FLUX Kontext Preset ComfyUI | AI Scene Control

Master scene creation with curated one-click AI presets.Who it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewThis ComfyUI workflow unlocks the power of FLUX Kontext Preset with carefully crafted scene presets spanning creative arts, commercial advertising, social media, and lifestyle photography. From teleporting subjects to new environments to precise style control, this system intelligently fuses your input with AI-generated prompts for consistent, professional results. Whether you're creating fashion shoots, product photography, or artistic concepts, the preset system eliminates guesswork while maintaining creative control over every parameter.Important nodes:kontextpresets.pyNotesFLUX Kontext Preset ComfyUI | AI Scene Control — see RunComfy page for the latest node requirements.

FLUX Dev ControlNet Union Pro| Multi-Condition

Controlled FLUX Dev image generation with Pose, Depth, Canny, and ReColorWho it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewGain advanced control in ComfyUI with FLUX Dev ControlNet, powered by the FLUX.1-dev-ControlNet-Union-Pro-2.0 model. This powerful workflow supports simultaneous Canny, Depth, Soft Edge, Pose, and Grayscale conditioning. Use FLUX Dev ControlNet standalone or combine it with other ControlNets for refined image generation. It's perfect for directing AI outputs for motion, character consistency, or background shaping, adapting seamlessly to your multimodal control needs.Important nodes:FLUX Dev ModelSampler SettingsNotesFLUX Dev ControlNet Union Pro| Multi-Condition — see RunComfy page for the latest node requirements.

RTX Video Super Resolution: Instant Video upscale

Online Workflow：https://www.runninghub.ai/post/2032093104060239873/?inviteCode=rh-v1121Register through the link and receive 1000 coins. Log in daily and earn 100 coins. Play for free!You can also bind directly using the invitation code: rh-v1121

Wan2.2 Remix v3 + SVI2 +Qwen3.5全自动提示词图生长视频V1

Online Workflow：https://www.runninghub.cn/post/2035642836963565570/?inviteCode=rh-v1121https://www.runninghub.cn/post/2035643056212414465/?inviteCode=rh-v1121https://www.runninghub.cn/post/2035643021630377985/?inviteCode=rh-v1121https://www.runninghub.cn/post/2035642903317454849/?inviteCode=rh-v1121https://www.runninghub.cn/post/2035642798367580161/?inviteCode=rh-v1121https://www.runninghub.cn/post/2035651804888829954/?inviteCode=rh-v1121Register through the link and receive 1000 coins. Log in daily and earn 100 coins. Play for free!You can also bind directly using the invitation code: rh-v1121

Wan 2.1 Workflow in ComfyUI | Premium Text & Image to Video Creation

Create incredible videos from text or images with breakthrough AI running on everyday CPUs.Who it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewUpdated 6/16/2025: ComfyUI version updated to v0.3.39 for improved stability and compatibility. Wan 2.1 surpasses all competitors in video creation benchmarks. Its 1.3B model needs only 8.19GB VRAM, supporting both Text-to-Video and Image-to-Video workflows to produce 480P videos in 4 minutes on standard hardware. The Wan 2.1 14B model offers enhanced 720P quality via RunComfy's cloud. As the first model generating both Chinese and English text in videos, Wan 2.1 expands creative options while its Wan-VAE backend efficiently handles 1080P video processing with temporal consistency.Important nodes:High-quality output:Hardware accessibility:Versatile generation:Multilingual support:VAE efficiency:Fast processing:Inputs:Best for:Characteristics:KSampler:WanImageToVideo:ModelSamplingSD3:EmptyHunyuanLatentVideo:Memory Optimization:Quality Optimization:NotesWan 2.1 Workflow in ComfyUI | Premium Text & Image to Video Creation — see RunComfy page for the latest node requirements.

Push-In Camera - A Motion LoRA for Wan 2.1

One image in, blockbuster push-in shots out. Zero complexity.Who it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewTransform your AI videos from static to cinematic with this Push-In Camera - A Motion LoRA for Wan 2.1 workflow. Trained on 100 real film clips through 40+ iterations, this LoRA adds professional push-in drone camera movements that breathe life into your generations. Just load your image and hit run - the workflow handles everything automatically, delivering Hollywood-quality push-in shots that sweep from establishing views to dramatic close-ups. No complex prompts needed, just pure cinematic motion.Important nodes:Push-in cameraNotesPush-In Camera - A Motion LoRA for Wan 2.1 — see RunComfy page for the latest node requirements.

InstantCharacter ComfyUI Workflow | FLUX DiT Personalization

One photo, endless characters. Perfect identity preservation.Who it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewInstantCharacter is a ComfyUI workflow based on the InstantCharacter framework built on Diffusion Transformers (DiT), particularly FLUX. It allows users to generate high-quality and identity-consistent character images from a single reference image, guided by creative text prompts. The model strikes a strong balance between identity preservation and prompt-based control, allowing for dynamic, stylized, or contextual character generation with high fidelity.Important nodes:InstantCharacter DiT FLUX AdapterInstantCharacter Sampler SettingsNotesInstantCharacter ComfyUI Workflow | FLUX DiT Personalization — see RunComfy page for the latest node requirements.

Wan 2.2 + Lightx2v V2 ComfyUI Workflow | Fast Image & Text to Video

Dual Light LoRA setup, 4X faster.Who it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewThis ComfyUI Wan 2.2 + Lightx2v V2 workflow combines the power of Wan 2.2 14B model with Lightx2v V2 LoRA for lightning-fast image-to-video and text-to-video generation. Transform static images into dynamic videos or create videos directly from text prompts using advanced distillation techniques. Generate high-quality results in 8-14 steps with reduced sampling parameters, dramatically cutting generation time while maintaining excellent output quality. Choose from optimized configurations: 8 steps (maximum speed), 12 steps (balanced), or 14 steps (optimal quality), perfect for rapid prototyping and efficient video creation workflows.Important nodes:EmptyHunyuanLatentVideoCLIP Text Encode (Positive Prompt)LoadImageNotesWan 2.2 + Lightx2v V2 ComfyUI Workflow | Fast Image & Text to Video — see RunComfy page for the latest node requirements.

Flux Kontext Pulid | Consistent Character Generation

Create consistent characters using FLUX Kontext with a single face reference image.Who it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewFlux Kontext Pulid is a specialized character generation workflow that utilizes FLUX DiT architecture in combination with Kontext and Pulid modules. With just one reference face image, it allows users to produce consistent characters across multiple scenarios. Ideal for creators, animators, and illustrators seeking reliable character identity in stylized or photorealistic outputs. This ComfyUI-native workflow offers modular flexibility while keeping visual identity intact throughout generations.Important nodes:Load Image"a female character in a red coat, standing in snowfall""extra hands, distorted face, blurry"WeightStart AtEnd AtComfyUI > outputNotesFlux Kontext Pulid | Consistent Character Generation — see RunComfy page for the latest node requirements.

Wan 2.2 Low Vram Kijai Wrapper | ComfyUI Video Generation

Low VRAM. No longer waiting. Kijai wrapper included.Who it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewWan 2.2 Low VRAM is a memory-efficient ComfyUI workflow based on Kijai's wrapper implementation of the Wan 2.2 video generation model. It features an OpenAI-powered prompt refinement node and a two-stage sampling system (4 steps each for high and low noise). This approach balances quality with performance, enabling smooth video interpolation between frames even on VRAM-constrained setups. Perfect for creators who need efficient video generation without sacrificing quality.NotesWan 2.2 Low Vram Kijai Wrapper | ComfyUI Video Generation — see RunComfy page for the latest node requirements.

ComfyUI Wan 2.2 Image Generation | Complete Workflow Pack

MoE Mix + Low-Only with upscale. Pick one.Who it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewThis ComfyUI workflow pack gives you two complete Wan 2.2 image generation setups in one file. MoE Mix-Mode combines high-noise and low-noise models for absolute maximum quality. Low-Only Mode runs faster with an integrated upscaling pipeline featuring 4x Ultrasharp and refinement sampling. Simply enable the group you want and disable the other.Important nodes:Empty Latent by Ratio (WLSH)CLIP Text Encode (Positive Prompt)KSamplerAdvancedNotesComfyUI Wan 2.2 Image Generation | Complete Workflow Pack — see RunComfy page for the latest node requirements.

Instagirl Wan 2.2 LoRA | ComfyUI Workflow

A Wan 2.2 workflow for demoing the Instagirl LoRA by Instara.Who it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewInstagirl is a LoRA model created by Instara, integrated here into a Wan 2.2 workflow for demonstration purposes. This setup enables you to create high-quality videos in the Instagirl style directly in ComfyUI. Simply load your prompts, adjust settings, and enjoy detailed, stylistic outputs.Important nodes:beautiful young woman, cinematic lighting, ultra detailed, 8kblurry, low quality, distorted face, extra limbscomfyui/outputsNotesInstagirl Wan 2.2 LoRA | ComfyUI Workflow — see RunComfy page for the latest node requirements.

Wan 2.2 Fun Control | ComfyUI Video Generation

Structured video generation with Wan 2.2 Fun Control using Canny, Depth, Pose, and inputs for precise creative guidance.Who it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewThe Wan 2.2 Fun Control workflow in ComfyUI enables multimodal control by leveraging depth, canny edges, pose, and trajectory inputs to drive structured, expressive video generation using the new Wan 2.2 Fun Control model. It offers precise motion and styling control beyond prompt-only methods, perfect for animation, pose-driven content, or stylized transformations, all powered by Wan 2.2’s next-gen MoE-based cinematic generation.NotesWan 2.2 Fun Control | ComfyUI Video Generation — see RunComfy page for the latest node requirements.

FLUX Kontext Dev ComfyUI Workflow | AI Image Editing Tool

Kontext Dev = Controllable + All Graphic Design Needs in One ToolWho it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewThis ComfyUI FLUX Kontext Dev workflow enables precise AI-powered image editing with unprecedented control. Transform styles, maintain character consistency across edits, remove or add objects, and perform targeted modifications while preserving image quality. The 12-billion parameter open-source model excels at iterative editing, allowing multiple successive modifications with minimal visual drift.Important nodes:Load ImageLoad Image (from Outputs)Image StitchFluxKontextImageScaleSave ImageNotesFLUX Kontext Dev ComfyUI Workflow | AI Image Editing Tool — see RunComfy page for the latest node requirements.

FLUX Kontext Face Swap | ComfyUI workflow

Photoreal face replacement with prompt-guided control and natural blendingWho it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewFLUX Kontext Face Swap empowers creatives with accurate, natural face replacement using automatic alignment, refined control, and localized regeneration.Important nodes:Key nodes in Comfyui FLUX Kontext Face Swap workflowAutoCropFaces (#119 and #122)Detects faces and produces crop metadata for alignment and pasting. If the face is partially missed or includes hair you do not want, increase crop size slightly or lower detection confidence to pick up more context.FaceAlign (#121)Uses InsightFace landmarks to warp the source face onto the base face geometry before merging. Switch the analysis device in FaceAnalysisModels (#120) to GPU when available for faster alignment.Image Paste Face (#125)Blends the aligned face into the base image using the crop data. If edges look sharp or color is off, try a slightly larger crop box or reduce any post-prompt aggressiveness so FLUX does less overpainting around the border.FluxKontextImageScale (#134)Rescales the composite to the native shape expected by Kontext so the VAE can encode without distortion. Leave this in place to prevent stretching or drift in the refined output.UNETLoader (#140)Loads the Kontext-tuned FLUX UNet. Use this together with the LoRA for the intended behavior of FLUX Kontext Face Swap. Changing the checkpoint will noticeably alter skin texture and overall fidelity.LoraLoaderModelOnly (#141)Applies Put it here LoRA to localize reconstruction. If the swap drifts or edits spill outside the face, increase the LoRA influence slightly. If the look feels locked, reduce it for more creative freedom.DualCLIPLoader (#8) and CLIPTextEncode (#6)Provide text conditioning. Keep prompts short and targeted to the face region and expression. Avoid global style cues if you want to preserve the base image background and clothing.FluxGuidance (#5)Balances how much the sampler trusts the reference composite. Raise it to preserve the base composition more tightly, lower it for stronger prompt-driven edits within the face area.NotesFLUX Kontext Face Swap | ComfyUI workflow — see RunComfy page for the latest node requirements.

Pose Control LipSync with Wan2.2 S2V in ComfyUI | Audio2Video

Turn images into talking, moving characters with pose and audio control.Who it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewThis workflow lets you create expressive and controllable character animations with audio-driven lip synchronization and pose-based motion. Starting with a static image, a pose reference, and an audio clip, it generates seamless videos where characters move naturally and speak in sync. You can tailor movement and expressions with high precision, making it great for avatars, digital storytelling, or music videos. Backed by the Wan 2.2 model, it delivers natural body tracking and smooth speech alignment. It is designed for creators who need efficient, high-quality video generation with creative control.Important nodes:Key nodes in Comfyui Pose Control LipSync with Wan2.2 S2V workflowWanSoundImageToVideo (#55)The heart of the workflow that conditions Wan2.2‑S2V with your prompt, vocals, subject image, and pose control video. Adjust only what matters: set width, height, and length to match your subject image and audio length, and plug a preprocessed pose video for motion control. Leave ref_motion empty unless you plan to inject a separate camera track. The model’s speech‑to‑video behavior is described in Wan‑AI/Wan2.2‑S2V‑14B and Wan‑Video/Wan2.2.DWPreprocessor (#78)Generates pose maps using YOLOX for detection and DWPose for whole‑body keypoints. Strong pose cues help Wan follow limbs and torso while audio controls lips and expressions. If your reference has heavy camera motion, use a pose video that aligns viewpoint and timing with the intended performance. DWPose and its variants are documented in IDEA‑Research/DWPose.KSamplerAdvanced (#64)Executes denoising for the latent sequence. With a LightX2V LoRA loaded, you can keep steps low for fast previews while retaining motion coherence; increase steps when pushing for maximum detail. Scheduler choices affect motion smoothness versus crispness, and should be tuned together with LoRA usage as outlined for Wan in the Diffusers documentation.VHS_LoadVideo (#80)Imports and scrubs your pose reference. Use its in‑node frame selection tools to pick the exact segment that matches your audio segment. Keeping framing and subject size consistent with the reference image will stabilize motion transfer. The node is part of VideoHelperSuite: ComfyUI‑VideoHelperSuite.…NotesPose Control LipSync with Wan2.2 S2V in ComfyUI | Audio2Video — see RunComfy page for the latest node requirements.

Flux Kontext Zoom Out in ComfyUI | Clean Canvas Expansion

Zoom Out LoRA enlarges images seamlessly with natural continuation.Who it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewThis workflow lets you effortlessly expand photos while keeping the subject intact. By rescaling and sampling, it creates wider compositions with smooth edges and matched lighting. You can enlarge frames for thumbnails, portraits, or product shots without distortion. The system balances preservation and natural continuation with guidance controls. It is designed for quick setup, high fidelity results, and scene consistency. Ideal if you want reliable zoomed-out visuals that look clean, cinematic, and natural.Important nodes:Key nodes in Comfyui Flux Kontext Zoom Out LoRA workflowFluxKontextImageScale (#42)Prepares the input by scaling and framing for context-aware outpainting. Use it as the only place to change how much canvas you want to add. If you need more breathing room, increase the scale-out amount; if edges look too new, reduce it to keep more of the original pixels.LoraLoaderModelOnly (#191)Loads and applies kontext/zoomout-fal-v1.safetensors onto the Flux 1 Kontext UNet. If your outputs look under- or over-biased, adjust the LoRA strength here. Keep changes modest to preserve the Zoom Out LoRA’s intended behavior.ReferenceLatent (#177)Locks composition and identity by conditioning the sampler on the VAE-encoded original. If you see subtle drift in subject pose or scale, route conditioning through this node as provided and avoid removing it. Pairing this with a neutral or minimal prompt maximizes fidelity.FluxGuidance (#35)Controls how much the reference and prompt guide the sampler. Raise guidance when the extended areas mismatch lighting or perspective; lower it if you want slightly more creative background fill. Treat it as a balance knob between strict preservation and organic continuation.NotesFlux Kontext Zoom Out in ComfyUI | Clean Canvas Expansion — see RunComfy page for the latest node requirements.

Wan 2.2 Video Restyle | Try First Frame Style Transfer in ComfyUI Workflow

Change the first frame, folks, your style makes the whole video look amazing. Pure magic.Who it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewWan 2.2 Video Restyle locks in your video’s look from the first frame with Flux Kontext or custom styles, then keeps it consistent across every scene. Perfect for cinematic effects, anime vibes, or bold artistic transformations.NotesWan 2.2 Video Restyle | Try First Frame Style Transfer in ComfyUI Workflow — see RunComfy page for the latest node requirements.

Generate ENTIRE AI WORLDS (Vace Wan 2.1) in ComfyUI | Video World-Building

Turn simple footage into immersive cinematic AI landscapes instantlyWho it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewThis workflow lets you turn raw footage into cinematic environments with complete control over background replacement. It maintains original camera movement while transforming settings into detailed, immersive scenes. Designed for filmmakers and VFX artists, it offers consistent depth and perspective accuracy. The tool enables fast and efficient world-building directly from video. You can create entire landscapes without losing motion fidelity. Perfect for anyone needing realistic and creative scene generation for storytelling projects.Important nodes:Key nodes in Comfyui Generate ENTIRE AI WORLDS (Vace Wan 2.1) workflow…NotesGenerate ENTIRE AI WORLDS (Vace Wan 2.1) in ComfyUI | Video World-Building — see RunComfy page for the latest node requirements.

Wan2.1 Stand In in ComfyUI | Character-Consistent Video Workflow

Keeps characters consistent across video from just one reference image.Who it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewThis workflow helps you produce character-driven videos where identity remains consistent from frame to frame. With just one image as input, it generates outputs that preserve facial features, style, and personality across sequences. Ideal for animators, storytellers, and creators of avatars, it ensures both high fidelity and strong continuity. You gain stable results without needing multiple reference images. It saves time, reduces rework, and improves reliability for long-form creative projects. Designed for practical usability, it gives you control over story-driven visuals with dependable results.Important nodes:Key nodes in Comfyui Wan2.1 Stand In workflowWanVideoModelLoader (#22). Loads Wan 2.1 14B and applies the Stand In LoRA at model initialization. Keep the Stand In adapter connected here rather than later in the graph so identity is enforced throughout the denoising path. Pair with WanVideoVAELoader (#38) for the matching Wan‑VAE.WanVideoAddStandInLatent (#102). Fuses your encoded reference image latent into the image embeddings. If identity drifts, increase its influence; if motion seems overly constrained, reduce it slightly.WanVideoSampler (#27). The main generator. Tuning steps, scheduler choice, and guidance strategy here has the largest impact on detail, motion richness, and temporal stability. When pushing resolution or length, consider adjusting sampler settings before changing anything upstream.WanVideoSetBlockSwap (#70) with WanVideoBlockSwap (#39). Trades GPU memory for speed by swapping attention blocks between devices. If you see out‑of‑memory errors, increase offloading; if you have headroom, reduce offloading for faster iteration.ImageRemoveBackground+ (#128) and ImageCompositeMasked (#108). These ensure the subject is cleanly isolated and placed on a neutral canvas, which reduces color contamination and improves the Stand In identity lock across frames.VHS_VideoCombine (#180). Controls encoding, frame rate, and file naming for the main MP4 output. Use it to set your preferred FPS and quality target for delivery.NotesWan2.1 Stand In in ComfyUI | Character-Consistent Video Workflow — see RunComfy page for the latest node requirements.

Wan2.2 Fun Camera in ComfyUI | Cinematic Panning Zoom Rotation

Turn still images into lively cinematic shots with smooth camera moves.Who it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewLooking to breathe life into your static images? This workflow lets you animate with cinematic depth, adding smooth camera pans, zooms, and rotations. Perfect for generating engaging motion without tedious video editing. It gives you easy creative control with professional-quality results. Whether you want subtle movement or energy-packed visuals, this tool streamlines the process. Turn ordinary images into storytelling visuals in no time.Important nodes:Key nodes in ComfyUI Wan2.2 Fun Camera workflowWanCameraEmbedding (#87, #108)Defines the motion plan for Wan2.2 Fun Camera. Choose a camera preset and set resolution and clip length for the whole shot. If you see cropping or letterboxing, adjust width and height here. Longer clips require more compute and may benefit from the LoRA path for speed.WanCameraImageToVideo (#80, #98)The core driver that fuses prompts, VAE, start image, and the camera embedding into motion-aware latents. Treat this as the bridge between your creative intent and the diffusion samplers. If motion feels too strong or too subtle, revisit the camera preset or prompt verbs rather than the sampler first.KSamplerAdvanced (#71 and #78, #102 and #103)Runs a two-stage schedule: a high-noise sampler to establish motion, then a low-noise sampler to refine. For stronger structure use a few more steps in the first pass, for crisper details invest steps in the second pass. Keep guidance balanced so motion remains natural and does not overfit to the prompt.VHS_VideoCombine (#116, #117)Packages decoded frames into a single video file for quick review. Adjust the frame rate to match the feel of your camera move and tune CRF if you need higher quality exports. Use a clean filename prefix to keep versions organized while exploring Wan2.2 Fun Camera variations.LoraLoaderModelOnly (#88, #90)Enables the LightX2V 4 Steps LoRA pair. Turn these on for faster iterations or lower VRAM pressure. Disable them for maximum motion richness when finalizing a Wan2.2 Fun Camera shot.NotesWan2.2 Fun Camera in ComfyUI | Cinematic Panning Zoom Rotation — see RunComfy page for the latest node requirements.

Wan2.2 S2V in ComfyUI Workflow | Audio to Talking Video

Turns your audio clip into lifelike, synced video from one imageWho it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewThis workflow lets you create video from sound and one image, making speech-driven or music-driven visuals possible. You can quickly generate talking avatars, music loops, or expressive clips without manual animation. It preserves image fidelity while syncing lips and expressions to audio. You just provide voice or music plus a reference image, and it produces a matching video. Easy setup means less tinkering, more creating. It’s designed for seamless audio-matched animation.Important nodes:Key nodes in Comfyui Wan2.2 S2V workflowWanSoundImageToVideo (#55)Drives audio-synchronized motion from a single image. Set ref_image to the portrait or scene you want animated, connect audio_encoder_output from the encoder, and provide a length in frames. Increase length for longer clips or reduce for snappier previews. If you change FPS elsewhere, update the frames value accordingly so timing stays in sync.AudioEncoderLoader (#57) and AudioEncoderEncode (#56)Load and run the Wav2Vec2-based encoder that turns speech or music into features Wan can follow. Use clean speech for lip sync, or percussive/beat-heavy audio for rhythmic motion. If your input language or domain differs, swap in a compatible Wav2Vec2 checkpoint to improve alignment.CLIPTextEncode (#6) and CLIPTextEncode (#7)Positive and negative prompt encoders for UMT5/CLIP conditioning. Keep positive prompts concise, focusing on subject, style, and shot terms; use negative prompts to avoid unwanted artifacts. Overly forceful prompts can fight the audio, so prefer light guidance and let Wan2.2 S2V handle motion.KSampler (#3)Samples the latent sequence produced by the Wan2.2 S2V node. Adjust sampler type and steps to trade speed for fidelity; keep a fixed seed when you want reproducible timing with the same audio. If motion feels too rigid or noisy, small changes here can noticeably improve temporal stability.VHS_VideoCombine (#66)Creates the final video and attaches the audio. Set frame_rate to match your intended FPS and confirm the clip length matches your length frames. The container, pixel format, and quality controls are exposed for quick exports; use higher quality when you plan to post-process in an editor.NotesWan2.2 S2V in ComfyUI Workflow | Audio to Talking Video — see RunComfy page for the latest node requirements.

Wan2.2 VACE Fun in ComfyUI | Image Animation Workflow

Turn still photos into lifelike animated videos with custom prompts.Who it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewThis workflow helps you turn any still image into an animated video guided by written prompts. It allows you to maintain subject identity while adding expressive actions or motions. You can easily bring reference photos to life and control how your subject moves. Designed for storytelling, it makes concept visualization faster and more engaging. It is perfect for creating unique animations for social content, presentations, or creative projects. By combining efficiency with precision, it delivers reliable results even for complex ideas.Important nodes:Key nodes in Comfyui Wan2.2 VACE Fun workflowWanVaceToVideo (#43)The heart of Wan2.2 VACE Fun: it binds prompt semantics to your reference image and produces the initial video latents. Adjust width, height, and length here via the shared settings to match your creative target and VRAM budget. Keep the reference subject centered and well-lit for best identity retention. If motion feels off, revise the positive prompt to emphasize actions, camera moves, and timing words.KSamplerAdvanced (#108, #107, #109)A staged sampler chain that progressively improves composition, detail, and motion smoothness. Increase steps when you need more detail or temporal stability, and reuse the same seed to compare changes fairly. The final pass on the LOW variant often cleans subtle artifacts; if results look too soft, shift some steps to the earlier passes. sampling_shift is exposed to nudge the schedule toward either motion emphasis or finer texture.RMBG (#73)Automatic background removal improves subject adherence for Wan2.2 VACE Fun, especially with busy or low-contrast scenes. Use high-quality, non-blurry references to minimize cutout errors. If you want natural backgrounds, replace them later in post or composite a plate behind the decoded frames.TrimVideoLatent (#65)Keeps the latent sequence aligned to the requested length. If you extend or shorten a clip, let this node handle the bookkeeping; it prevents subtle frame drift across the sampler stages.VHS_VideoCombine (#69)Encodes the final frames to MP4. Tune frame_rate to control clip duration relative to length (duration equals frames divided by fps). Raise quality for final delivery or lower it for rapid previews; higher quality increases file size and encode time.NotesWan2.2 VACE Fun in ComfyUI | Image Animation Workflow — see RunComfy page for the latest node requirements.

Wan2.2 Animate in ComfyUI | Full Motion Video from Images

Turn images into lifelike, moving characters with natural body and face motion.Who it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewThis workflow helps you animate static images into complete motion videos that preserve character identity. By combining body pose transfer and facial mocap, it produces natural movement and expressive realism. You can take a driving video and a reference image to create lifelike character animations. It's especially useful for generating avatars, recreating performances, or storytelling projects. The workflow ensures seamless synchronization between reference identity and dynamic movements. With precise facial expressions and smooth body actions, outputs feel true to life. The process is efficient, creative, and designed for high-quality results.Important nodes:Key nodes in Comfyui Wan2.2 Animate workflowVHS_LoadVideo (#63)Role. Loads the driving video, outputs frames, extracts audio, and reports the frame count for downstream consistency.Tip. Keep the reported frame total aligned with the sampler’s generation length to prevent early cutoff or black frames.Sam2Segmentation (#104) + PointsEditor (#107)Role. Interactive subject masking that helps Wan2.2 Animate focus on the performer and avoid background entanglement.Tip. A few well‑placed positive points plus a modest GrowMask tends to out‑stabilize complex backgrounds without haloing. See SAM 2 for video‑aware segmentation guidance. PaperDWPreprocessor (#177) + FaceMaskFromPoseKeypoints (#120)Role. Derive robust face masks and aligned crops from detected keypoints to improve lip, eye, and jaw fidelity.Tip. If expressions look muted, verify the face mask covers the full jawline and cheeks; re‑run the crop after adjusting points. RepoWanVideoModelLoader (#22) and WanVideoSetLoRAs (#48)Role. Load Wan2.2 Animate and apply optional LoRAs for relighting or I2V bias.Tip. Activate one LoRA at a time when diagnosing lighting or motion artifacts; stack sparingly to avoid over‑constraint. Models • LoRAsWanVideoAnimateEmbeds (#62) and WanVideoSampler (#27)Role. Fuse image, face, pose, and text conditioning into video latents and sample the sequence with Wan2.2 Animate.Tip. For very long clips, switch to context‑window mode and keep its length synchronized with the intended frame count to preserve temporal coherence. Wrapper repo…NotesWan2.2 Animate in ComfyUI | Full Motion Video from Images — see RunComfy page for the latest node requirements.

Wan Alpha in ComfyUI | Alpha Channel Video Workflow

Alpha magic: instant transparent background videos for VFX and design.Who it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewThis workflow helps you generate high-quality video clips with built-in transparency, eliminating the need for manual masking or green screen removal. You can easily place characters, objects, or animated elements over any background of your choice. Its output is highly flexible, making it perfect for VFX, motion graphics, and compositing work. You will save time and streamline your creative process by working with ready-to-use transparent video assets. Designed for professionals, it ensures seamless integration into existing design pipelines. Built on the Wan 2.1 model, it delivers fidelity and precision with each render.Important nodes:Key nodes in Comfyui Wan Alpha workflowEmptyHunyuanLatentVideo (#40)- Role: defines spatial and temporal resolution of the generated clip. Tune width, height, frames, and fps to match delivery. Larger canvases and longer durations raise VRAM needs; consider shorter drafts for look development, then scale up for finals.KSampler (#3)- Role: the main denoiser for Wan Alpha. Adjust seed for explorations, steps to trade speed for detail, sampler and scheduler for stability, and cfg to balance prompt adherence with natural motion. With LightX2V LoRA active, you can reduce steps significantly while preserving quality thanks to step-distillation. See LightX2V for context on fast sampling. ModelTC/LightX2VLoraLoaderModelOnly (#59)- Role: loads the LightX2V LoRA that accelerates Wan2.1 sampling. Use the strength control to blend its effect if you see oversharpening or tempo artifacts. Keep this LoRA closest to the base model in the chain so downstream LoRAs inherit its speed benefits.LoraLoaderModelOnly (#65)- Role: loads an additional LoRA for style or domain refinement. Moderate strength to avoid overpowering motion coherence; combine with your prompt rather than replacing it. If artifacts appear, lower this LoRA before changing the sampler.VAELoader (#39) RGB- Role: provides the RGB VAE used by RGB VAE Decode (#8). Keep this paired with the Wan‑Alpha alpha VAE to ensure both decoders interpret latents coherently. Swapping to unrelated VAEs can misalign edges or soften transparency. Background on the joint RGB–alpha design is in the Wan‑Alpha report. Wan‑Alpha (arXiv)VAELoader (#51) Alpha- Role: provides the alpha VAE used by Alpha VAE Decode (#52). It reconstructs the matte from the same latent space as RGB so transparency matches motion and detail. If you customize VAEs, test that RGB and alpha still align on subpixel edges like hair.…NotesWan Alpha in ComfyUI | Alpha Channel Video Workflow — see RunComfy page for the latest node requirements.

Wan 2.2 Lightning T2V I2V ComfyUI | Ultra Fast Video Gen

Wan 2.2 now 20x faster! T2V + I2V in 4 steps.Who it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewThis ComfyUI workflow features the upgraded Wan 2.2 Lightning distillation model, replacing the previous lightx2v lora with native Wan 2.2 compatibility. Generate professional-quality videos in just 4 steps with 20x speed improvement while maintaining the same visual fidelity. Create complex motion sequences, animate static images, and produce cinematic content at lightning speed. Perfect for rapid prototyping, content creation, and real-time video generation workflows.Important nodes:WanVideoTextEncodeWanVideoEmptyEmbedsNotesWan 2.2 Lightning T2V I2V ComfyUI | Ultra Fast Video Gen — see RunComfy page for the latest node requirements.

Wan 2.1 Ditto in ComfyUI | Video Stylization and Motion Consistency

Transform videos into stunning artistic styles with perfect motion flow.Who it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewThis workflow helps you transform existing or generated videos into new artistic styles while keeping motion stable and structure accurate. You can apply cinematic, painterly, or abstract visual effects directly in your video pipeline. It offers strong temporal coherence for smooth transitions between frames. With intuitive controls, it streamlines your creative process and ensures consistent, high-quality results. Perfect for editors and designers seeking refined, stylized video outputs.Important nodes:Key nodes in Comfyui Wan 2.1 Ditto workflowWanVideoVACEModelSelect (#128)Choose which Ditto weights to use for stylization. The default global Ditto model is a balanced choice for most footage. If your goal is anime‑to‑real conversion, select the sim‑to‑real Ditto variant referenced in the node note. Switching Ditto variants changes the character of the restyle without touching other settings.WanVideoVACEEncode (#126)Builds the visual conditioning from your input frames. The key controls are width, height, and num_frames, which should match the prepared video for best results. Use strength to adjust how assertively Ditto’s style influences the edit, and vace_start_percent and vace_end_percent to limit when conditioning applies across the diffusion trajectory. Enable tiled_vae on very large resolutions to reduce memory pressure.WanVideoTextEncode (#111)Encodes positive and negative prompts via the mT5‑XXL encoder to guide style and content. Keep positive prompts concise and descriptive, and use negatives to suppress artifacts such as flicker or over‑saturation. The force_offload and device options let you trade speed for memory if you are running large models.WanVideoSampler (#119)Runs the Wan 2.1 backbone with Ditto stylization to generate the final latents. The most impactful settings are steps, cfg, scheduler, and seed. Use denoise_strength when you want to preserve more of the original structure, and keep slg_args connected to balance content fidelity against style strength. Increasing steps or guidance may improve detail at the cost of time.ImageScaleByAspectRatio V2 (#76)Sets a stable target size for all frames before conditioning. Drive the long‑side target with the standalone integer so you can test small, fast previews and then increase resolution for final renders. Keep the scale consistent between iterations to make A/B comparisons meaningful.…NotesWan 2.1 Ditto in ComfyUI | Video Stylization and Motion Consistency — see RunComfy page for the latest node requirements.

FLUX.2 [klein] 4B & 9B in ComfyUI | Unified High-Speed Workflow

Blazing-fast visual creation with unified editing control.Who it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewWith this compact Klein-based workflow, you can create visuals faster than ever. It merges text-to-image and image-to-image generation in one unified process. You can edit, compose, or reimagine images instantly, whether using a single or multiple references. Its models balance speed and visual fidelity, perfect for real-time design exploration. Experience efficient iteration with consistent, high-quality results suited for any creative workflow.Important nodes:Key nodes in Comfyui FLUX.2 [klein] 4B & 9B workflowText to Image (Flux.2 Klein 4B) (#75)- Role: Generates images purely from text on the compact 4B model. Internally pairs a FLUX.2 scheduler with CFG guidance and decodes with the shared VAE.- Tune: Adjust your prompt and noise_seed for exploration. If you upscale canvas dimensions, consider switching to the 9B edit routes for downstream refinements.Image Edit (Flux.2 Klein 4B) (#81)- Role: Single‑reference editing that preserves layout and identity while applying prompt‑driven changes. Encodes the reference into latent conditioning and matches latent size to the input automatically.- Tune: Use concise, goal‑oriented prompts that specify what changes and what must stay the same. For aggressive style changes, add a negative prompt to protect unwanted regions or artifacts.Image Edit (Flux.2 Klein 4B Distilled) (#84)- Role: Faster version of the 4B edit route for rapid iteration. Good for testing prompt wording or selection of the best direction before finalizing with a base or 9B pass.- Tune: Lock the noise_seed when A/B testing small prompt edits to isolate prompt effects from stochasticity.Image Edit (Flux.2 Klein 9B) (#100)- Role: High‑capacity edit path that improves global coherence and difficult transformations. Recommended for camera angle changes, large background swaps, or brand integrations.- Tune: When mixing two references, ensure both are well framed and similar in scale. Use the prompt to explain the relationship between image1 and image2, for example “apply the logo from image 2 to the object in image 1.”Image Edit (Flux.2 Klein 9B Distilled) (#109)- Role: Interactive 9B editing with lower latency. Balances quality and speed when you need frequent updates during art direction sessions.- Tune: If results drift too far from the reference, strengthen constraints in the prompt with language like “keep pose, framing, and lighting unchanged” and re‑run with the same noise_seed.NotesFLUX.2 [klein] 4B & 9B in ComfyUI | Unified High-Speed Workflow — see RunComfy page for the latest node requirements.

FLUX.1 Dev LoRA Inference in ComfyUI | RunComfy Workflow (Training-Matched Results)

Run your AI Toolkit-trained FLUX.1 Dev LoRA in ComfyUI with training-matched behavior using a single RCFluxDev custom node.Who it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewFLUX.1 Dev LoRA Inference is a ComfyUI workflow built for running AI Toolkit-trained FLUX.1 Dev LoRAs with minimal preview drift. Instead of wiring a generic FLUX sampler graph, it uses the RC FLUX.1 Dev custom node to route generation through a model-specific inference pipeline aligned with AI Toolkit preview sampling. This approach stabilizes results with FLUX.1 Dev-correct defaults and repeatable sampling across runs.Important nodes:RC FLUX.1 Dev (RCFluxDev)SaveImageNotesFLUX.1 Dev LoRA Inference in ComfyUI | RunComfy Workflow (Training-Matched Results) — see RunComfy page for the latest node requirements.

Stable Diffusion 1.5 LoRA Inference in ComfyUI | RunComfy Workflow (Training-Matched Results)

Run AI Toolkit-trained Stable Diffusion 1.5 LoRAs in ComfyUI with training-matched behavior using a single RCSD15 custom node.Who it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewStable Diffusion 1.5 LoRA Inference is a ready-to-run ComfyUI workflow for applying AI Toolkit-trained LoRAs to SD1.5 on RunComfy. Rather than recreating the job as a generic sampler graph, it runs generation through RC SD 1.5 (RCSD15), which wraps a Stable Diffusion 1.5 pipeline aligned with AI Toolkit preview sampling. Start from a preview-matching baseline, then tune prompts and LoRA strength once the pipeline-aligned output is stable.Important nodes:SaveImageRC SD 1.5 (RCSD15)NotesStable Diffusion 1.5 LoRA Inference in ComfyUI | RunComfy Workflow (Training-Matched Results) — see RunComfy page for the latest node requirements.

FireRed Image Edit in ComfyUI | High-Fidelity Photo Editing Workflow

Sharp photo fixes with faithful tone and perfect detail control.Who it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewWith the FireRed edit workflow, you can refine, restore, and restyle photos while keeping perfect visual consistency. It’s built for accurate, instruction-following edits—from object tweaks to realistic restoration. You can keep your image’s creative essence while making targeted changes. Great for creators needing reliable open-source editing power. Perfect for tasks like virtual try-on or subtle visual adjustments. It helps you achieve professional-grade results without losing quality.Important nodes:Key nodes in ComfyUI FireRed Image Edit workflowAny Switch (rgthree) (#91)Routes the graph through either the BF16 FireRed Image Edit UNet or the GGUF variant without changing downstream wiring. Use it to A/B quality and speed or to route CPU and GPU workers through the same graph. Project link: rgthree/rgthree-comfyLoraLoaderModelOnly (#74)Applies the Qwen-Image-Edit-2511-Lightning LoRA on top of the selected FireRed Image Edit model. Increase strength when you want snappier previews at lower steps, and reduce it if you notice over-assertive changes. Keep it enabled for ideation, then disable or soften for final, highest-fidelity renders. Model link: lightx2v/Qwen-Image-Edit-2511-LightningTextEncodeQwenImageEditPlus (Positive) (#68)Transforms your instruction into conditioning while ingesting up to three reference images. Write direct, unambiguous commands and explicitly reference image numbers for compositing, attribute transfer, or layout constraints. The more specific your nouns and verbs, the more reliably FireRed Image Edit follows them.TextEncodeQwenImageEditPlus (Negative) (#69)Lets you forbid artifacts, off-styles, or changes you do not want. Use it to preserve typography, brand colors, or identity even when the main instruction pushes a strong transformation. Combine with clear positives to balance creativity and preservation.EmptySD3LatentImage (#116)Creates a latent canvas at your chosen resolution. Match image 1’s size for faithful composites or set a custom resolution for outputs destined for print or specific aspect ratios. Consider modest upscales after the edit rather than editing at extremely high resolutions.KSampler (#65)Drives the denoising process that realizes your instruction. Adjust steps, scheduler, and seed to balance speed and fidelity. With the Lightning LoRA enabled, fewer steps often suffice for strong previews, while the BF16 path with more conservative settings is ideal for finals. Core node reference: ComfyUINotesFireRed Image Edit in ComfyUI | High-Fidelity Photo Editing Workflow — see RunComfy page for the latest node requirements.

Blender to ComfyUI AI Renderer 2.0 Workflow | Cinematic Video Output

Turn Blender renders into rich, cinematic AI-driven animations fast.Who it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewTransform your Blender animations into cinematic AI outputs with this workflow. It reads depth, outline, and auxiliary passes to generate motion-consistent video sequences. Designed for animators and VFX artists, it accelerates the creative process while preserving structure and motion. Enjoy precise prompt control, visual fidelity, and seamless motion transfer. Perfect for creating polished, AI-rendered animations with detailed scenes and natural flow.Important nodes:Key nodes in Comfyui Blender to ComfyUI AI Renderer 2.0 workflowWanVacePhantomSimpleV2 (#3255)Orchestrates the Wan 2.1 VACE generation by routing model, VAE, prompts, control video, and reference frames. Adjust only the essentials: working width and height to match your control, and sequence length to match the target shot. If you use several strong references, keep prompts descriptive rather than over‑specific to avoid fighting the reference guidance.WanVideoVACEStartToEndFrame (#3261)Builds the control video that VACE follows. Provide a start image, optional end or reference stack, and the preprocessed control video. Set the number of frames using the Wan rule of 4n+1 so trimming stays consistent through the sampler; this avoids off‑by‑one artifacts at the tail.PreprocessSwitch (#3239)Selects which control feed reaches the sampler. Toggle between original frames, depth, canny, or pose depending on what you exported from Blender or built in Preprocess. Use depth when you need spatial fidelity, canny for clean composition control, and pose for character‑focused motion.VHS_LoadVideo (#93)Handles video ingest and exposes frame properties used across the graph. It is the reliable way to keep fps and sizing consistent from Blender through to render. If you need to trim or skip heads and tails, do it here so all downstream paths remain aligned.KSampler (#3253)Produces the final latent sequence given the Wan model and conditioning. If you change guidance strength or the sampler method, recheck the first and last 10 frames for stability, then render the full shot.NotesBlender to ComfyUI AI Renderer 2.0 Workflow | Cinematic Video Output — see RunComfy page for the latest node requirements.

Capybara ComfyUI Workflow v0.1 | 4-in-1 Image and Video Generator

Create, edit, and animate — all in one smart generation pipeline.Who it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewDesigned for creators who need efficiency and consistency, this unified Capybara setup enables seamless transitions between text-to-image, image editing, and video tasks. You can generate visuals, animate them, or refine videos using prompts in one integrated pipeline. The template family supports optimized resolutions and aspect ratios for reliable quality. Built on Capybara v0.1, it ensures fast experimentation and coherent visuals. Perfect for artists looking to handle image and video workflows within a single environment.Important nodes:Key nodes in Comfyui Capybara ComfyUI WorkflowImage Edit (Capybara v0.1) (#103)A compact, instruction‑based editor that preserves structure using vision features while applying your text edit globally. Adjust the text prompt to describe what should change and what must stay, then use steps for quality/smoothness and cfg to balance prompt strength against the source image. Increase steps for more detail; moderate cfg values usually keep edits faithful.HunyuanVideo15ImageToVideo (#115)The bridge from stills to motion and the engine behind prompt‑based video edits. It creates a short latent sequence conditioned on your prompt and, when provided, a start image. Tune length for duration and width/height to match a preset; larger sizes increase detail and render time. This node is the backbone of both the Image‑to‑Video and Video Edit groups, leveraging the HunyuanVideo design for stable temporal generation while Capybara handles denoising.VHS_VideoCombine (#145)The finalizer that turns generated frames into an MP4. Use frame_rate to control motion cadence and crf to trade quality for file size. Lower crf yields higher quality but bigger files; keep it consistent across projects so your Capybara ComfyUI Workflow outputs have a uniform look.NotesCapybara ComfyUI Workflow v0.1 | 4-in-1 Image and Video Generator — see RunComfy page for the latest node requirements.

FLUX LoRA (RealismLoRA) | ComfyUI Workflow

Blend FLUX-1 model with FLUX-RealismLoRA for photorealistic AI imagesWho it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewUpdated 6/16/2025: ComfyUI version updated to v0.3.39 for improved stability and compatibility. The ComfyUI FLUX-RealismLoRA workflow elevates AI image generation to new heights of photorealism. By combining the FLUX-1 text-to-image model with FLUX-RealismLoRA, trained on a curated dataset of high-resolution photographs and captions, this workflow enables the creation of incredibly lifelike images from text prompts alone. Experience the power of AI-generated realism without the need for complex prompts.Important nodes:The readme describes this graph as combining the FLUX-1 text-to-image model with the FLUX-RealismLoRA adapter for photorealistic results. On RunComfy, related checkpoints are referenced as flux/flux-schnell, flux/flux-dev, and flux/realism_lora.safetensors (see readme for machine-size notes).NotesFLUX LoRA (RealismLoRA) | ComfyUI Workflow — see RunComfy page for the latest node requirements.

FLUX.2 Dev LoRA ComfyUI Inference | RunComfy Workflow (Training-Matched Results)

Run your AI Toolkit-trained FLUX.2 Dev LoRA in ComfyUI with training-matched behavior using a single RunComfy RC custom node.Who it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewFLUX.2 LoRA ComfyUI Inference is a ready-to-run RunComfy workflow for applying an AI Toolkit-trained LoRA to FLUX.2 Dev inside ComfyUI. Instead of rebuilding FLUX.2 with a generic sampler graph, it routes generation through Flux2Pipeline, a model-specific wrapper aligned to the AI Toolkit preview pipeline. This pipeline-level alignment keeps LoRA injection consistent and preserves FLUX.2-correct defaults for repeatable, training-matched outputs. Load a single adapter from ComfyUI/models/loras (local download) or a direct .safetensors URL, then match lora_scale and your sampling values to your training samples when needed. Output images are saved via SaveImage for easy side-by-side comparison with training previews.Important nodes:Load PipelineSaveImageNotesFLUX.2 Dev LoRA ComfyUI Inference | RunComfy Workflow (Training-Matched Results) — see RunComfy page for the latest node requirements.

FLUX.2 Klein 9B LoRA ComfyUI Inference | RunComfy Workflow (Training-Matched Results)

Generate training-matched FLUX.2 Klein 9B LoRA outputs in ComfyUI through AI Toolkit's pipeline-aligned inference nodes.Who it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewFLUX.2 Klein 9B LoRA ComfyUI Inference gives you a ready-to-run ComfyUI graph for applying AI Toolkit-trained LoRAs on FLUX.2 Klein 9B with pipeline-level accuracy. Flux2Klein9BPipeline wraps the Klein 9B inference pipeline-Qwen3-8B text encoding, flow-match scheduling, and internal adapter injection-so ComfyUI generation behaves the same way AI Toolkit renders training previews. Adapter loading supports local files in models/loras or direct .safetensors URLs, controlled by lora_path and lora_scale. Because Klein 9B is not guidance-distilled, guidance_scale directly shapes output quality; matching it to your training sample config avoids the most common source of preview mismatch. The workflow outputs standard images through SaveImage for straightforward side-by-side comparison with training previews.Important nodes:Load PipelineSaveImageRC FLUX.2NotesFLUX.2 Klein 9B LoRA ComfyUI Inference | RunComfy Workflow (Training-Matched Results) — see RunComfy page for the latest node requirements.

ComfyUI Wan2.2 Fun Inp Workflow | First-to-Last Frame Interpolation

From 2 images to stunning videos with smooth, controllable transitions.Who it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewThis workflow lets you turn two images into smooth, prompt-controlled video clips with fine detail or fast previews—ideal for designers seeking cinematic control.Important nodes:Key nodes in Comfyui Wan2.2 Fun Inp workflowWanFunInpaintToVideo (#111 and #148)The core engine that blends your start_image and end_image into a continuous latent trajectory. It accepts width, height, and length to set video size and duration, then emits a latent sequence plus updated positive/negative conditioning. Start here when tuning continuity, pacing, or composition across the shot.UNETLoader (#101, #102)Chooses the Wan 2.2 Fun Inpaint model variant. Use high noise for bolder motion and more transformative interpolations. Use low noise when preserving the start and end frame identity and texture is the priority. Pair either with or without the 4-step LoRA depending on speed needs.ModelSamplingSD3 (#93)Configures the sampler schedule used downstream. Keep it aligned with the chosen LoRA or fp8 path. If you see temporal flicker, modest adjustments to the sampler mode or steps can smooth transitions without over-sharpening details.KSamplerAdvanced (#150)Applies a refinement pass to the latent sequence. Increase steps slightly if you need crisper micro-detail on faces, hands, or thin structures; reduce steps for softer, dreamier motion. Avoid extreme CFG or step counts that can destabilize temporal consistency.VHS_VideoCombine (#159)Merges rendered frames to MP4. Adjust frame_rate for motion feel and playback speed, and keep the default pix_fmt for broad player compatibility. Lower CRF yields larger files with finer gradients; higher CRF compresses more aggressively.NotesComfyUI Wan2.2 Fun Inp Workflow | First-to-Last Frame Interpolation — see RunComfy page for the latest node requirements.

image_conditioning

ComfyUI ReActor Face Swap | Professional AI Face Animation

Professional face swapping toolkit for ComfyUI that enables natural face replacement and enhancement.Who it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewUpdated 6/16/2025: ComfyUI version updated to v0.3.40 for improved stability and compatibility. Transform your video content with this professional face swapping workflow in ComfyUI. Powered by advanced models inswapper_128 and retinaface_resnet50, it creates seamless face animations with enhanced detail preservation. The workflow integrates face boosting and RealESRGAN upscaling for superior quality, along with frame interpolation for smooth motion. Perfect for creating character animations, video content transformation, or any project requiring high-quality face replacement in motion. Achieve professional results with intuitive controls and efficient batch processing.NotesWorkflow 1174 — see RunComfy page for the latest node requirements.

Flux 2 Dev in ComfyUI | High-Fidelity Visual Generation

Next-level image realism with advanced generation control powerWho it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewThis workflow empowers you to create ultra-clear, 4-megapixel images with advanced realism and design control. Ideal for product visualization, ads, and character renders, it maintains consistent styles across scenes. You can blend text and image inputs for precise creative direction. Its efficiency makes it suited to professional design pipelines. Get realistic lighting, coherent composition, and production-grade quality with every render.NotesWorkflow 1315 — see RunComfy page for the latest node requirements.

SkyReels V3 ComfyUI Workflow | Image2Video + Lip-Sync Animation

Transform images into high-quality, smooth, cinematic motion videos.Who it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewWith the power of the SkyReels V3 model, this workflow helps you turn images, audio, or existing clips into story-driven, cinematic videos with smooth movement and accurate lip-sync. You can animate portraits, extend scenes, or synchronize voices to faces. It’s built for creators seeking strong subject consistency and fluid visual storytelling. Perfect for animators, designers, and filmmakers who want fast, reliable, high-quality results. Everything runs seamlessly within the ComfyUI environment for maximum control and flexibility.NotesWorkflow 1369 — see RunComfy page for the latest node requirements.

Video Character Replacement (MoCha) in ComfyUI | Seamless Character Swap

Swap video characters fast with realistic motion and lighting control.Who it's for: creators who want this pipeline in ComfyUI without assembling nodes from scratch. Not for: one-click results with zero tuning — you still choose inputs, prompts, and settings.Open preloaded workflow on RunComfyOpen preloaded workflow on RunComfy (browser)Why RunComfy first- Fewer missing-node surprises — run the graph in a managed environment before you mirror it locally.- Quick GPU tryout — useful if your local VRAM or install time is the bottleneck.- Matches the published JSON — the zip follows the same runnable workflow you can open on RunComfy.When downloading for local ComfyUI makes sense — you want full control over models on disk, batch scripting, or offline runs.How to use (local ComfyUI)1. Load inputs (images/video/audio) in the marked loader nodes.2. Set prompts, resolution, and seeds; start with a short test run.3. Export from the Save / Write nodes shown in the graph.Expectations — First run may pull large weights; cloud runs may require a free RunComfy account.OverviewWith this workflow, you can transform existing videos by replacing actors or characters while maintaining natural motion, lighting, and camera perspective. Built for creators who need cinematic realism, it supports detailed appearance mapping and consistent movement. You can easily tailor character identity and expression to fit any scene. Ideal for storytellers, visual artists, and filmmakers seeking AI-assisted production efficiency. The process ensures rich, lifelike video output with minimal editing effort.NotesWorkflow 1304 — see RunComfy page for the latest node requirements.