Nodes & Models Highlight

• The RTX Video Super Resolution node upscales images and video frames up to 4×, either by a multiplier or to target dimensions up to 8192 px. The same node can also denoise or deblur a source without changing its resolution.

• The RTX Video Frame Generation node creates new frames between adjacent pairs, for frame-rate conversion or slow motion. It works at 2× to 16× or at a specific timestep.

• The RTX Video HDR node converts SDR images to BT.2020 HDR data, with HLG or PQ output. Contrast, saturation, middle gray, and peak luminance from 400 to 2000 nits are all adjustable, and a debanding pass is on by default.

With the NVIDIA VFX Nodes, you can now run a full professional grade VFX pipeline end-to-end. Chaining the nodes from Video Super Resolution → Frame Generation → Video HDR is a quick and simple way to level up your footage and prepare it for the rest of your VFX pipeline.

The RTX Video Super Resolution node is a great option for efficient upscaling and has 19 modes that can handle different kinds of source material.

• Standard modes upscale typical compressed footage.

• High-bitrate modes upscale clean or lossless sources without unnecessary artifact suppression.

• Streaming modes are tuned for broadcast and webcam streams.

• Denoise and deblur modes clean up noise, compression artifacts, or softness and keep the input resolution.

• A plain bicubic mode is also available when you don’t need AI processing.

Most modes run from LOW to ULTRA, trading speed for detail. An optional 10-bit encoding preserves more precision. The frame count and frame rate are unchanged, which sets your footage up for the next step in the workflow.

The RTX Video Frame Generation node offers two ways to generate new frames within an input video. Frame-rate multiplier mode fills every gap evenly, from 2× to 16×. To keep the original duration, encode the output at the source frame rate times the multiplier. Specific-timestep mode inserts one frame per pair at any point between the two frames, which suits custom timing in downstream workflows. The Quality parameter runs from LOW, MEDIUM and HIGH. Shot changes are detected automatically, and a manual option marks a known cut. Like RTX Video Super Resolution, the node offers an optional 10-bit encoding for more precision.

In the final step of the workflow, use the RTX Video HDR node to convert SDR images to BT.2020 HDR at their original dimensions. You can tune the conversion with three tone controls. The Contrast and saturation parameters work as they do in any grade. Middle gray sets the reference level for midtones, which decides how bright the overall image sits. Peak luminance tells the node how bright the brightest highlights should get. Set it to match the display you’re grading for, anywhere from 400 to 2000 nits. A debanding pass is on by default, which helps smooth out the visible steps that can show up in gradients like skies when SDR footage is stretched to a wider range. The output is a standard ComfyUI image with no color-space metadata, so downstream Create Video nodes need to be told whether the data is HDR or HDR PQ. The color management and EXR support in this release also handle that step.

Finally, the node pack’s example_workflows folder has a starter workflow for each node: image upscaling, video upscaling, frame generation, and HDR conversion, plus one for converting longer videos to HDR using the loop nodes. To see all three nodes working together, try the full VFX pipeline below.

Nvidia VFX Nodes Workflow

Better EXR support for VFX pipelines

In addition to Nvidia’s VFX nodes, we’re improving support for EXR files format. EXR is the standard format in VFX pipelines, and this release makes it much easier to work with in ComfyUI.

• The Save Image (Advanced) node can now write half-float (16-bit) EXRs, now the default, as well as full-float (32-bit) EXRs.

• The Load Image node has been improved to ensure images remain intact. It now reads half-float and full-float EXRs. Superwhites above 1.0 and negative values come through untouched instead of being silently clipped, so the full range of data is preserved.

• Color management gets an upgrade as well. The Convert Image Color Space node handles sRGB, scene-linear Rec.709, HDR HLG and PQ (Rec.2020), ARRI LogC3 (EI 800) and ACEScct.

Preview & Download EXRs

EXRs also get a major quality-of-life improvement: they are now easier to inspect and to download. Since web browsers can’t display EXR files, our new asset management system attaches a JPEG preview to every EXR output. The preview is visible in the save and load nodes, in the Assets panel, and in the Jobs history. The small sun button in the load and save nodes also opens the EXR file in the HDR Viewer for more comfortable viewing.

Remark: Previews are only available when ComfyUI starts with the command line argument--enable-asset. The flag is set by default in Comfy Desktop since version 1.1.7 and in ComfyUI portable since 0.40.0.

Finally, when a save node outputs a sequence of images, the new Download images action lets you pick frames, or hit “Download all”, and download them as a single zip.

Getting Started

1. Update ComfyUI to the latest version.

2. Install the Nividia VFX custom nodes from the ComfyUI Manager.

3. Load the example workflows from the custom nodes templates, or download the workflows here.

Try it on Comfy Cloud, and let us know what you make. As always, enjoy creating!

Try the Workflow on Comfy Cloud

ComfyStreamerH3

Background

Live video has been the talk of the town on AI twitter these days. From Fal’s post trained H3 Max model that competed on quality and topped the charts last month, to the FastH3 model that optimized on cost. Video models have come a long way since people joked about AI models being unable to animate Will Smith Eating Spaghetti!

As impressive as these recent model are, there exists a problem. And that problem is cost. Running these models continuously can cost an upwards of 6k per day! This makes these models completely unusable for the average consumer.

The goal

So the question I asked is how far can these models be pushed? What if you had an agent search the internet for every optimization, every speed up, every cost savings, and definitely every dirty hack that sacrificed quality for speed. And then what if you put it all together into a single custom comfy node that runs on a single consumer GPU? My requirements were the following:

• Hardware: one RTX 5090 with 32 GB of VRAM

• Speed: generate 15 seconds of video in 15 seconds or less

• Resolution: 448×256 resolution

• Quality: keep it watchable, even if the clips have rough edges

The RTX 5090 was a useful target: some high-end gaming PCs have one, and rentals can be found for around 70¢ an hour at the cheapest end of the market.

Benchmarks

Examples: Same spaghetti. Three styles.

Anime

Stylized 3D

Watercolor

The clips clearly have some rough edges and artifacts. But its not a completely horrible result for a single GPU you can rent for under 70 cents an hour!

But enough with the talk, lets get into the nitty gritty details. Casual viewers be warned, I don’t even understand some of these, as they were simply what my agent was able to pull from other projects. Astra Codex be praised!

Implementation Details

I used FastVideo’s FastH3 V2 checkpoint in a four-step setup. For comparison, FastVideo’s Preview V1 generated a 15-second, 1344×768 clip in 47.2 seconds on one B200 (hint: much more expensive GPU).

Here’s what we optimized to run the workflow on one RTX 5090:

• Four sampling steps. Each step is another round of model work to refine the video. Using four means less work for each clip.

• Sparse attention. Attention lets parts of the video share information as it is generated. VSA focuses full attention on the selected 20% of video blocks—skipping about 80%—while still including the prompt.

• A smaller text encoder. The encoder turns your prompt into information H3 can use. NicoLab28’s ClipProj adapts Qwen3-VL-4B to stand in for H3’s 32B encoder: it uses about 4.5 GB instead of 15.7 GB.

• A smaller checkpoint. FastVideo’s pruned INT8 checkpoint combines pruning (removing selected weights) with INT8 storage (8-bit numbers), reducing the GPU memory the model needs.

• A fused FP4 MLP. The MLP handles a lot of the model’s repeated calculations. Using four-bit math for this part and fusing its operations means less memory for the weights and fewer temporary results to move around; this builds on ByronLeeeee’s H3 optimizations.

• Decode and encode together. Kijai’s INT8 H3 video decoder rebuilds the video in tiles. NVENC starts writing each finished tile while the decoder prepares the next, so the steps overlap. The workflow keeps only the last frame for the next job instead of caching every decoded frame.

These optimizations both improved speed and memory uses, bringing VRAM requirements down from 80GB to < 30GB, safely fitting within a RTX 5090’s 32 GB of GPU memory.

Demo

If you want to test out the results for yourself the custom comfy node is released open source here: https://github.com/Comfy-Org/comfystreamerh3

Additionally you can rent GPUs from the Comfy Developer Platform.

Comfy API handles GPU hosting, models, and dependencies, so your app can request video without needing a GPU of your own. And you can follow the instructions to sign up and deploy this demo to Comfy API in the readme here.

Final Thoughts

There is clearly significant room to improve image detail, consistency, and resolution of these videos. But getting H3 to generate even partially legible video in real time on one RTX 5090 shows how far these models can be pushed when it comes to the frontier of single-GPU live video. One next step would be to pass each clip through a cost optimized video upscaling model, such as the recently release SolRefinery : IE generate quick initial videos at 448 × 256 and then cheaply upscale to a higher resolution. My preliminary testing with this model shows a 7× pixel density increase using only 3X the GPUs. So given the possibility of future optimizations, we might have cost efficient, semi-usable live video sooner than you’d think!

Upscaled Results

Gemini Nano Banana 2.1 is Google’s image generation and editing model, and the successor to Nano Banana 2. It is built to balance price and performance. Give it a prompt and up to 14 reference images, and it returns a finished image at up to 4K.

If Nano Banana 2 is already the default in your graph, Gemini Nano Banana 2.1 drops into the same slot. The resolution tiers carry over, the aspect ratio list gains 9:21, and each run costs less.

Model Highlights

• Three thinking levels. Minimal, Medium and High. Use Minimal to explore quickly, High for dense layouts and prompts that stack several constraints, and Medium when you want something in between. Higher levels take longer and use more tokens.

• Up to 14 reference images. Pass products, characters, style references and backgrounds in a single prompt. Give each one a clear job in the prompt.

• Search grounding. The model can pull from Google Search and image search, which helps with real landmarks, niche objects and specific real-world details.

• Text that renders as written. Signage, multi-line notices, exact alphanumeric strings, cursive handwriting and Japanese come back as specified. Spell out every word you want in the image.

• Targeted and multi-turn edits. Recolors, material swaps, object removal and text replacement land without disturbing the rest of the frame, and edits can build on each other across turns.

• Seamless tiling. Tileable textures and patterns wrap cleanly at the edges.

• Flexible output. 1K, 2K and 4K, from 1:1 through 21:9 and 9:21, plus 4:1, 1:4, 8:1 and 1:8 for banners and long panoramas.
  
  

  Try Nano Banana 2.1 Today

Getting Started

1. Update ComfyUI to the latest version, or open Comfy Cloud.

2. Double-click the canvas and search for “Gemini Nano Banana 2.1”, or load the ready-made workflow from the Template Library.

3. Set resolution, aspect ratio and thinking level, add your prompt and any reference images, and run.

As always, enjoy creating!

YUI is the first animated short film created with Comfy Agent by well-known AI animation artist 852話 Hakoniwa. The story has been in Hakoniwa’s mind for a long time, since she started working with artificial intelligence. Today, we would like to share how she created it with the ComfyUI team.

Our story with Hakoniwa

We got to know Hakoniwa in the community in early 2023, and met her in Tokyo in 2024. She has been a passionate artist in the diffusion model community in Japan, and has always been one of the first people to try out open-source models and workflows. Her techniques shine very differently because of her own style.

Long before AI, Hakoniwa was a freelance illustrator working under the name meola. In the early days of Hatsune Miku and the Vocaloid scene, she took illustration commissions from Vocaloid producers, and also worked on video production. She composed music as a Vocaloid producer herself and contributed lyrics as well. She then kept making small indie games on her own.

In July 2022, she encountered Midjourney and was stunned. She saw a chance to bring AI into her own game development. At the same time, she felt that the concept art and background work she had kept doing on the side might disappear as AI arrived. She decided to steer firmly toward working with AI, and she has been one of the first to try new models ever since.

Hakoniwa has a strong passion for animation, usually in Japanese style. And 70-80% of her AI video work has been generated in ComfyUI. Right now, she is also co-running AndIdea, a Tokyo-based AI company that handles everything from animation production to generative AI adoption support, consulting, and development. Here is a project we did together two years ago: artwork displayed on event signage in Harajuku, Tokyo, filmed with a real camera.

The Challenge: A story about a girl and the wall

When we were first about to release Comfy Agent, Hakoniwa was the first artist we talked to. After we mentioned the vision to help with “craft” in the creative process, Hakoniwa came back with something more than a product demo. She said “there had been a story I’ve wanted to create for a long time”, and it was about her understanding of storytelling.

We immediately wanted to do it together, as a challenge but also a celebration for both her and ComfyUI. And here it is, the behind-the-scenes story of YUI.

How the character YUI got her look

The main character’s name is YUI. It comes from the last three letters of ComfyUI. Hakoniwa told us there is more in it: 結 means to tie, to connect, and also for effort to bear fruit. “I found YUI within ComfyUI,” she wrote, “and through her, I found new possibilities.”

She was not always YUI. We did 2 versions of characters, and 5 variations of outfits, from option A to option E.

The first protagonist was HIBANA, a red-haired girl Hakoniwa created two years ago in just a few hours. HIBANA was the base of the demo, and from there the character-making with Comfy began. We redesigned her around Comfy: a yellow and purple palette, and a C-shaped logo charm on the zipper.

She mainly used GPT Image 2.5 through the Agent for character design and stills

Video Production

YUI realizes she is the protagonist of a story. And as a red timer appears in her world, this world ends in three minutes. She runs to the edge of the world and finds the fourth wall.

Such a story of a girl escaping and fighting the world involves a lot of highly dynamic and complicated scenes. The artist needs to put a lot of ideas and care into composition, environment, character pose, movement, expression, and overall pacing. “That’s where the creator’s personal taste really shines through,” she said.

The storyboard and the character sheet were also a big part of the preparation.

And the world did not end. In the film, the timer freezes at 0:01 for about fifteen seconds and never reaches zero. The story doesn’t stop there either: it continues into the making-of video, which shows how YUI was made.

Behind the scenes

What we liked is that the artist does not hide the work. Here are a few numbers from the video, stated by Hakoniwa:

• About 200,000 Japanese yen total cost, not including labor.

• Three days of focused work by one person.

• About 2/3 of those three days went to generation (with the help of Comfy Agent) and 1/3 to editing.

• From start to finish, the whole project took 7 to 10 days, including the back-and-forth with Comfy, the character-making, and waiting time.

HIBANA, the character she designed two years ago, took only a few hours and is not counted in these numbers.

And Comfy Agent was helpful in these areas:

• Regenerating shots. In the rough cut, she wanted to smooth the transitions and fix moments where the visual story was unclear. The final film runs 4:20. Regenerating single shots is the constant chore of a film like this. The Agent builds the workflow and runs it, and she moves on to the next shot.

• Comparing models. She compared video models such as Wan, MiniMax H3 and Seedance on the same shot and picked the winner per shot. The main film was made mostly with Seedance 2.5, and the making-of video with MiniMax H3. Doing that comparison by hand takes a lot of time. With Comfy Agent it became a step in the loop. She did the same for upscalers, shown side by side in the channel.

• Quality checks. She used the Agent to check outputs and to pull YUI closer to her official character sheet. Consistency is what breaks AI animation. She told us the hardest challenge she knows is a coherent multi-character sequence where nothing falls apart.

• Sketch-guided composition. She often used hand-drawn layouts to steer the framing, then went through trial and error until, in Hakoniwa’s words, “each shot matches the intended direction.”

The pattern is simple. The Agent took the repetitive labor, so the artist could spend her time on the actual review, the creative choices, and discussion: which take has the right energy, which face reads as panic, when to stop.

Finally, here is an emoji pack that Hakoniwa created as a gift to the audience and the community.

YUI is the first short animation film made with Comfy Agent, and there will be more.

“The story continues,” as YUI says in the film.
The next one could be made by you.

As always, enjoy creating!

Try Agent on Cloud

Generation got easy. Craft didn’t.

There are many ways to generate an image or a video now. But making something as specific as what’s in your mind, is still hard.

Great work comes from iterations: trying models, adjusting composition, fixing details, comparing approaches, and doing it again until it feels right.

ComfyUI has always been the tool for that level of control, but too much creative time still goes into finding tools, wiring workflows, debugging errors, and communicating technical terms to other creatives.

But you shouldn’t have to. We strongly believe creators shouldn’t have to choose between ambition and complexity. Comfy Agent is our answer to that.

A teammate right inside the app

Comfy Agent is right inside ComfyUI. It knows the latest models, ComfyUI extensions, and workflows. It can plan and evaluate techniques, build workflows, fix errors, find assets, and handle technical terms, so that you can focus on the creative idea itself.

You can create and use public or private skills while you work. You can also have up to 5 chats in parallel, with full chat history.

Things you can ask it today:

• “Update this same generation to compare 3 more video models.”

• “Explain what this workflow does and where it’s slow.”

• “Re-run my product-shot workflow on these 20 images.”

Try Agent on Cloud

Two of you on one canvas

The agent works directly on your canvas while you edit the workflow too. We designed it this way so both of you won’t have to wait for or interrupt each other. Real-time collaboration is fun:

• Reference another workflow, drag an asset from the library, or mention a node

• It can understand assets visually

• You can watch the graph assemble. Move things and it will notice

Every control ComfyUI gives you is still there. Open any node and check every parameter.

What creators are making

Three creators worked with Comfy Agent ahead of launch.

Animation by 852話 | Andidea: the story of an original character YUI. Characters and imagined worlds in one creative workflow. The agent helped shape the look, explore scenes, and compare generation results. One artist, 100 hours, working with Comfy Agent.

VFX use case by Doug Hogan: Isolate, Mask, and Refine. A shot taken from image to compositing passes. Isolate the subject, generate masks, and work with depth and normals in one workflow.

Try Agent on Cloud

Get started

1. Log in at cloud.comfy.org

2. Open the “Agent” panel to claim free initial chats.

3. Ask it for something real: “Take this product photo and make 20 on-brand ad variants in 4 aspect ratios.”

Comfy Agent is free to try and uses the Comfy Credits you already have. Check pricing here.

What’s next?

Local Comfy will soon be fully agentic. Your GPU, your models, your custom nodes. The agent walks you through setup, picks models that fit your hardware, and customizes your environment.

We are also working on agent-built custom nodes. The agent will bring customized editing tools for you.

We are also adding new features, including more model options, better public skills and knowledge, and more external integrations.

Feedback

Comfy Agent is currently in beta. We are actively developing new features and fixing issues. Tell us what works and what doesn't and it is the best way to help us prioritize the right things to build.

• Feedback: https://links.comfy.org/agentfeedback

• Discord: join our server and find us in #comfy-agent channel

As always, enjoy creating!

Turn a workflow you built in ComfyUI into the engine behind an app, tool, or service. Package the workflow with its custom nodes, LoRAs, models, and Python dependencies, then deploy it as an autoscaling API endpoint.

Until now, putting a ComfyUI workflow into production meant rebuilding its environment somewhere else. Teams had to rent GPUs, install every custom node and model again, untangle Python dependencies, and write the scaling logic around it.

Comfy API handles that work without changing the workflow or ComfyUI. Your graph stays yours, the engine stays open source, and your Builds remain portable to hardware you own.

Comfy API runs on the Developer Platform

Your Builds, deployments, usage, spend, and API keys live in one console at platform.comfy.org. You can work in the browser, from the terminal, or with a coding agent.

Get Started

Turn your workflow into an API

Start with a workflow JSON or export a snapshot from Comfy Desktop. Builder reads the workflow, finds the models and custom nodes it needs, and helps resolve conflicting Python dependencies. You can override any version it picks.

The Build captures the ComfyUI version, custom nodes, models, and Python dependencies your workflow expects. Cut an immutable release from that Build, then deploy the release as a managed endpoint with its own URL.

Because the release is immutable, the environment you test is the environment you deploy. When you need to make a change, update the Build and cut a new release without changing the one that’s live.

—Allie Wrubel, Head of Technology at Silverside AI

Build from the terminal

Using comfy-cli and Comfy Skills, you or your coding agent can package and deploy a local ComfyUI install:

$ comfy build init
✓ Scanned this ComfyUI install - custom nodes, models, pinned deps
$ comfy build push --release

Or skip the setup. Copy the agent prompt on the Comfy API page, paste it into your coding agent, and let it package and deploy the workflow.

The Comfy SDK supports running workflows on Comfy API and Comfy Cloud API today. To use the same SDK with a self-hosted ComfyUI deployment, run the proxy service and set one environment variable.

What you can build

Deploy your ComfyUI workflows as APIs behind customer-facing products, internal tools, and automated creative pipelines. Build the experience your users need without exposing the graph.

• Give your team a tool. You’ve tuned a product photography workflow with custom nodes and a fine-tuned LoRA. Put a simple interface in front of it so the rest of your team can run it without opening ComfyUI.

• Add a feature to your product. Your app lets customers restyle an image. The app sends each request to a ComfyUI workflow you control, and the deployment scales with traffic.

• Automate repeatable creative work. New products land in your catalog every week. A script sends each one through your workflow and saves the outputs, without anyone watching the graph.

Browse apps built with Comfy

From one builder to a production team

The person who builds the workflow often isn’t the only person who needs to run it.

Comfy API is built for that handoff.

• Share one versioned environment. On Team and Enterprise plans, teammates can work from the same Build, with the ComfyUI version, models, custom nodes, and Python dependencies pinned together.

• Scale with demand. Set the minimum to zero and the deployment uses no GPU time when no workers are running. Keep workers warm when requests can’t wait for a cold start.

• Track usage and spend. See workflow runs, GPU usage, and costs from the Developer Platform console.

• Bring the workflow you already use. Package public or private custom nodes, model checkpoints, LoRAs, and pinned Python dependencies into the Build.

• Govern what teams can use. Enterprise customers can use Managed Builds and governance controls to standardize approved ComfyUI versions, models, custom nodes, and dependencies across teams. Learn more at Comfy for Enterprise.

Why not wire it together yourself?

If you already run ComfyUI on RunPod or Modal and it works, keep it. If you need GPUs for more than ComfyUI, a general-purpose platform may be the right call.

Comfy API earns its place when ComfyUI is the part you keep managing. RunPod and Modal remove the need to manage infrastructure. Comfy API also removes the work of managing ComfyUI environments: custom nodes, models, Python dependencies, and version drift.

It’s built for ComfyUI by the team behind ComfyUI and Comfy Cloud, so the path from a local workflow to a deployed endpoint is part of the product, not an integration you maintain.

Pricing

Comfy API is available on paid Comfy plans, starting with Standard. Usage is billed separately.

GPU time is billed by the second. Storage is prorated hourly.

See full Comfy API pricing.

What this means, and what’s next

ComfyUI gave people control over every step of how an image or video gets made. Every node is visible. Every parameter is adjustable. But getting that workflow in front of a team or a customer still meant rebuilding it somewhere else and hoping it behaved the same way.

Comfy API closes that gap. You build the workflow in ComfyUI. Comfy API packages the environment and runs it behind an endpoint. Your team or product calls it without seeing the graph.

Comfy is building an open standard for visual AI. For that standard to hold up in production, the workflow can’t lose its custom nodes, models, or dependencies on the way there. That’s why Builds are versioned, the engine stays open, and your work remains portable.

Get Started

Start building on Comfy API today

• Get started

• Read the Comfy API docs

• Browse apps built with Comfy
  

Integrate frontier image, video, 3D, and audio models once. Then choose the provider for each job, for better availability and better prices.

Day one access includes Seedance 2.5, MiniMax H3, Nano Banana Pro, GPT Image 2, Kling, and Black Forest Labs, with more coming.

These are the same models 3M+ ComfyUI users already use, now behind one API.

Router runs on the Developer Platform.

Router runs on the Comfy Developer Platform, giving you one place to access frontier models today. And soon, to deploy and scale your own ComfyUI workflows with Comfy API.

Router is how you call the frontier models you do not run yourself. Your API keys and run history live in one place and cover both, so the workflows you deploy and the models you call land on the same account.

Get an API key

Integrate once. Add models as you go.

Comfy has Day 0 access to many of the latest frontier models. Router puts that access behind one API, so you can start building with new releases without adding another SDK, key, or job lifecycle.

Build that once through Router, and the next model is one line.

from comfy_sdk import Comfy

client = Comfy(api_key="comfyui-...")

result = client.models.run(
    "openai/gpt-image-2",
    arguments={"prompt": "aerial view of a neon coral reef at dusk"},
    provider="fal",
)

Change the model string to call a different model. Change the provider to run it somewhere else. Everything around those two strings stays put.

Choose the provider for better availability or pricing.

The same model often runs on more than one provider, and on the day you need them, providers are not interchangeable. One is rate limited. One is cheaper this week. One is faster for your region.

The provider is a parameter. Where a model is supported on more than one of fal, Runware, WaveSpeed, and Higgsfield, you move between them with one line.

When you name a provider, Comfy does not switch the route. If that provider is unavailable, the request fails there. There is no silent substitution, and every job reports the provider that ran it.

Not every model runs on more than one provider yet. Where a model has one provider, you still get the single integration and the shared key.

Hit a concurrency limit? Queue the job.

The queue automatically retries jobs that hit 429 rate limits and other transient errors. Use submit to send a job and receive a request ID immediately; the queue keeps the job moving until it completes. If you want Comfy to wait for the result, subscribe submits the job and polls until it completes.

Queueing is available for all supported models, and the concurrency limits documentation covers the ceilings. Your job runs when a slot opens.

What you can build

Three jobs Comfy Router is built for.

A product feature that calls one model. You ship image generation on fal. Traffic spikes and fal rate limits you. If that model is supported elsewhere, you move the same call by changing one parameter. No new SDK, no new key, nothing else redeployed.

A pipeline that mixes your own workflow with someone else’s model. Your ComfyUI workflow runs on the Comfy API. A frontier video model runs on Router. Both calls come from the same code, on the same key, with both runs in the same history. The alternative is Comfy for your workflow and a separate contract, key, and dashboard for the model.

Batch work that outruns your limits. Queue a few hundred jobs with submit, hold the IDs, and retrieve results as they land. Nothing sits in a retry loop holding a connection open.

Why not call fal, Runware, WaveSpeed, or Higgsfield directly?

You can, and plenty of teams do. If you use one provider and one model, a direct integration is the right call and Router is overhead you do not need.

Router earns its place when you need more than one: the same model on more than one provider, one key and one job surface, and a route you pick. Each provider routes to itself. Comfy Router gives you one surface across them.

If you know OpenRouter, the shape is familiar. The difference is what generative media needs: large assets, model-specific controls, and jobs that run for minutes.

Pricing and data

Router uses the same Comfy credits that cover Partner Nodes, Comfy Cloud workflow runs, and other supported model calls. There is no subscription required.

Per-model pricing is listed in the model catalog, so you can see the cost for each model before you run it.

On retention: inputs are kept for 24 hours after upload and outputs for 24 hours after generation, then they are deleted.

What this means, and what’s next

ComfyUI gave people control over every step of how an image or a video gets made. Every node visible, every parameter adjustable. That’s why more than three million creatives use it.

Calling a model over someone else’s API has always meant giving that up. You send a request to a machine you do not control and take what comes back. Most routing layers widen that gap by picking the provider for you and calling it optimization.

Comfy Router closes it. You pick the model. You pick the provider. You can always see which one ran.

Comfy is building an open standard for visual AI. Standards work when the people using them can see how they run and swap what they do not like, so provider choice is the foundation here rather than a setting we added later.

More models and more providers are coming soon, including:

• Comfy workflows. Run a ComfyUI workflow from the same SDK, just like models

• Routing strategies. Choose a policy such as reliable, fast_start, fast_finish, or lowest_cost and let Comfy select the provider. This is optional. Choosing a provider yourself remains the default, and every job reports which provider ran it.

• Route by use case. Request an upscale, a background removal, or an animation, and Comfy picks a model or workflow that can do it

Comfy Router

Start building on Comfy Router today

• Get an API key

• Browse models

• Read the docs

What changed, the technical details

• A fused encoder kernel, on by default. Between convolutions the encoder normalized each frame, applied an activation and padded the edges, each one a separate pass over hundreds of megabytes. That is now a single pass, writing straight into the memory layout the convolution wants next. ~1.5x faster, with identical output.

• Convolutions that honor --fast fp16_accumulation. PyTorch sends convolutions to cuDNN, NVIDIA’s library, and there is no way through it to ask for fp16 accumulation, so the flag only ever applied to matrix multiplications and the encoder got nothing from it. The new custom convolution does honor it, with the bias and skip connection folded into it. That takes the encoder to ~2.2x.

• An int8 decoder. With the int8 VAE file the decoder’s weights are 8-bit, and the normalization, activation and skip connection fold into the matrix multiplications, so intermediate results never reach memory. Attention runs in 8-bit too. 1.4x faster over what int8 VAE used to be.

The numbers

Measured on an RTX 5090 at 1344x768, 129 frames, comparing each configuration against itself before this update. Nothing here is specific to that card, the fused encoder kernel removes memory traffic, which helps any NVIDIA GPU.

The --fast fp16_accumulation path helps on the consumer cards where fp16 accumulation runs at double rate.

Quality

You will most likely not see a difference by eye.

Every VAE loses a little detail when it compresses a video and reconstructs it, and that loss is there always. What the faster int8 paths add on top of it is roughly 30x smaller loss again, well under anything that shows up in a frame.

Encoding still runs in fp16 even with the int8 VAE, the fused kernel is lossless, it just computes the same values in a different order.

In technical terms: the int8 decoder matches the standard decoder at 67.7 dB PSNR and the faster encoder at about 68 dB, against roughly 38 dB for the VAE’s own reconstruction of real footage.

Getting it

• Update ComfyUI to v0.36.0 or above. The fused encoder kernel needs nothing else.

• Start ComfyUI with --fast fp16_accumulation for the faster encoder and decoder.

• Download the workflows below, or find them in the template library.

Download MiniMax H3 I2V Workflow

Download MiniMax H3 R2V Workflow

Download MiniMax H3 T2V Workflow

• Load the int8 MiniMax-H3 VAE file for the fastest decode. It is a drop-in replacement for the standard one.

All figures are same-day A/B measurements against the pre-change build, taken through the VAE Encode and VAE Decode nodes.

Try on Comfy Cloud

Qwen-Image 2.1 is the latest image model from Alibaba’s Qwen team. It runs 7B parameters on an optimized MMDiT architecture — the same class as Qwen-Image 2.0, which shipped in February 2026 with native 2K output, images with transparency, high quality text rendering and editing capabilities that takes up to 10 input images at once At 7B, inference is fast and the weights fit comfortably on consumer cards.

Model Highlights

• RGBA output. Four channels, alpha included. Sprites, logos, icons, and product cutouts come out of the sampler ready to composite. No background removal node, no matting model, no edge cleanup. No other major open model does this.

• Native 2K generation. 2048×2048 direct output. Generated at that resolution, not upscaled into it.

• Up to 10 reference images. The Text Encode Qwen Image 2.1 node opens image inputs as you fill them, to 10. Character, product, background plate, style reference — all read by the text encoder and spliced into the sequence as VAE latents.

• One checkpoint. Generation and editing in the same model.

• 7B parameters. Fast inference, low cost, consumer VRAM.

Getting Started

1. Update ComfyUI to the latest version, or open Comfy Cloud.

2. Download the Qwen-Image-2.1 weights from Hugging Face and drop them in your models folder.

3. Load the Qwen-Image-2.1 template from the Templates panel, or download the workflow here.

4. Write your prompt, attach reference images to image_1 onward, and run

Try it on Comfy Cloud, and let us know what you make. As always, enjoy creating!

But then momentum stalls. The prototype lives on one person’s machine and it’s hard to scale. It can’t take the brand’s real assets, can’t run a hundred versions in the wild, it's not exactly production ready. The distance between “we proved it” and “it’s in the pipeline” turns out to be the entire job!

If that sounds familiar, then let me introduce you to the new Forward Deployed Creative offering, because this is how Comfy is helping you close that gap. A Comfy expert embeds with your team, builds the workflows inside your environment, and helps your people take ownership of them.

How a FDCT engagement runs

1. Validate. First we prove the outcome is achievable using your own work, your own products, your own brand constraints. Sometimes during this discovery phase the honest answer we arrive at is “well you can’t do that yet, and here’s specifically what’s missing.” But that answer is worth getting early instead of spending weeks spinning your wheels in production.

2. Build. If the idea is validated, then next we move inside your Comfy Enterprise environment, working with your models and your assets, in a iterative process where we hone in on the Comfy workflow of your production dreams!

3. Enable. FDCTs develop and host bespoke training with your team to get them on their feet and self-sufficient, which we measure by whether they can change the workflows, not whether they can just click “run” it.

4. Own. Lastly, and this is the fun part, the workflow(s) are delivered and they’re yours! The direct FDCT line stays open under your enterprise agreement of course, but the goal is that you don’t need to use it often unless the next big idea comes up.

This is the difference between creating a workflow that ships once and creating one that’s still in use next quarter across dozens, or hundreds, of production cycles.

Enablement is the deliverable, not a nice-to-have

In my years as a VFX artist, I’ve watched plenty of good tools die in production. Not because they didn’t work, but because the few people who understood them rolled off the show, leaving behind a workflow no one else knew how to use.

AI hasn’t changed that. If a workflow becomes a black box, teams eventually abandon it and go back to what they know.

That experience shapes the teaching sensibility we bring to every engagement:

• Build it in front of them, not for them. A workflow that simply appears, finished, is a workflow nobody feels ownership of and doesn’t help anyone. If your team watches it get assembled, they know where the bodies are buried.

• Name things like a production artist. Node titles, group labels, reroutes. The graph should read like a sentence six months from now, to someone who wasn’t in the room.

• Leave the seams visible. Resist collapsing everything into one clever node just to hide the wires. The obvious version an artist can edit quickly beats the elegant version they’re afraid to touch.

• Teach the failure, not just the happy path. Anyone can demo the good render. Real enablement is showing what it looks like when the mask slips, the seed drifts, or the model runs out of VRAM…and what to do about it.

The talent bench

Forward Deployed Creatives come from the real production world, and we are matched to the creative required for the Enterprise engagement based on the type of work, the tech stack, and the timeline. So let me introduce you to your FDC team!

Chris V.

Sits between artist and engineer. He’s worked with global brands, walked Fortune 500 keynote stages, and architected custom VFX and AI pipelines. He’s the one you want when the pipeline question and the aesthetic question are the same question.

Rob Losch

Has been in ComfyUI since day one, with a deep library across marketing and advertising. Describe what you’re trying to make and he can point at the exact graph.

Robert Paige

Came up through rapid-growth companies like Instacart and Lyft, building production infrastructure for creative organizations. He lives in the systems layer that makes a good idea survive contact with an org chart.

Doug Hogan

That’s me! I’m come from the world of VFX and studio production. That’s Nuke compositing, Python tooling, and feature and episodic work across Netflix, Universal, Warner Bros., and Samsung. I love solving both creative and technical problems to produce rock solid production pipelines.

The best ones are the ones you never knew were there

Speaking from a personal perspective for a moment, coming from the world of VFX, there’s a line every artist repeats like a mantra: “the best visual effects are the ones you never noticed.” Not the creature or the collapsing building. It’s the removed rig, the extended set, the sky that was never there. If the audience walks out talking about the effects, somebody upstream had a rough day!

I’ve come to think about Forward Deployed Creative work the same way.

The measure of a good Enterprise engagement isn’t how much of us is left in the finished workflow or how much you need us to run it. It’s how little.

Six months on, the graph has your team’s naming conventions on it, three nodes we never wrote, and a stage we would have argued about. Somebody who joined after we left uses it every week and has no idea it started as a proof of concept with an outside name attached.

That’s the whole goal. Validate it. Build it. Teach it. Then let it become theirs.

So if your team has a creative problem it has already half-solved but can’t get into production, that’s exactly the conversation we’re excited to have with the new Forward Deployed Creative program here at Comfy.

Forward Deployed Creatives

The brief for the Comfy × MiniMax H3 Sync Sound Challenge may have looked simple, but was a challenge to do well: make something in ComfyUI with MiniMax H3 where the audio and the video come out of the same generation. If the character claps, the clap has to be born in the same pass as the hands. No music bed laid on afterwards, no dubbing, though reference audio was welcomed.

Entries opened August 20 and closed September 1. Eight creative technologists at Comfy scored every submission on two rubrics, Best Creative and Best Technical, then the top five in each category went in front of our guest judges on the September 3 livestream: POM (Banodoco founder), Emma Catnip (animation director and AV artist), and Yachimat (animation and manga artist). Their scores were averaged and added to the Comfy team’s, and a fourth title, Built with MCP, was judged on its own track.

Watch the livestream replay here.

Huge thanks to MiniMax for making an open-weight model our community loves, to our three guest judges, and to everyone who spent their last week of August fighting with reference audio! Here’s how it landed.

The Winners

Best Overall · “Spin Cycle” by Visual Frisson 🇺🇸

Prize: RTX 5090 32G

A laundromat, a woman in a puffer vest, and a rhythm built entirely out of machines. Visual Frisson generated a large volume of H3 clips using their own recorded audio as the reference for every pass, then cut the results together like a stomp video, so every thud and cycle on screen is sound that H3 produced with the picture rather than something added later.

It was the only entry to post a perfect 15/15 from the Comfy team in both categories, and the Comfy MCP was used to drive much of its process. Combined with the guest judges’ scores, it finished with the highest total in the challenge.

From the artist: “Always have fun and learn something new competing in contests like this, keep them coming.”

Watch → vimeo.com/1223207725
Workflow → Google Drive
Follow → instagram.com/visualfrisson

Best Creative · “Every Sound Leaves a Mark” by toki 🇯🇵

Prize: RTX 5060 Ti

A small clay creature that changes into something new every time it hears a sound (glass, wool, ice, porcelain), until by the time it gets home it can’t move anymore. All of the audio came out of H3 alongside the video on every shot, with nothing layered on afterwards. Our judges praised the fine details of toki’s work, saying it “gave them chills” on the first transformation, has a lot of commercial appeal, and feels really delicate and crafted.

The judges scored it highest of any Creative finalist, and the repository is unusually generous: it includes the eight API graphs that actually ran, the same eight converted to UI format with annotations, a process log with every measurement, and the scripts that produced those numbers. toki is also clear about scope, noting that MCP drove the finishing pass, not the original shot generation.

Watch → youtube.com/watch?v=Rv5HOgCac-w
Workflow → github.com/tokimwc/every-sound-leaves-a-mark
Follow → @toki_mwc

Best Technical · “Sonder Editor / References” by SonderSaid 🇲🇽

Prize: RTX 5060 Ti

SonderSaid didn’t just build a workflow, they built the tooling around it. The entry runs on custom nodes of their own design, wired into a reference-driven H3 pipeline that scored a clean 15/15 on novelty, workflow quality, and community value from the Comfy team, and the highest guest judge average in the Technical bracket. Notably, the work includes an entire custom node pack just to do the editing and the reference work, praised as “a whole new UI” to good to keep secret. While SonderSaid’s work takes the prize for best technical, our guest judges also noted how much they loved the storytelling, suspense, and element of surprise.

Watch → youtu.be/n-NdAQk7I8A
Workflow → Hugging Face
Follow → @SonderSaid

Built with MCP Bonus · “Two Prisoners” by Jay Choi 🇰🇷

Prize: RTX 5060 Ti

The Built with MCP bonus went to whoever used the Comfy MCP most effectively to make something visually and technically compelling, and Jay Choi used it end to end. Working locally on an RTX 5090 with Hermes Agent driving ComfyUI through the MCP, they trained a LoRA, built their own orchestration on top, and by their own account spent most of the time setting up and tuning the MCP layer itself. The film that came out the other side, two blindfolded prisoners in a rain-dark cell, is a long way from “prompt and run.”

From the artist: “Thanks for the challenge! I learned more than I ever could in the past two weeks!”

Watch → youtu.be/FlK0dDZdzRU
Workflow → Google Drive
Follow → @permafrost_2021 · @jaychoirenderender

The Finalists

Ten entries made it to the livestream. Six of them didn’t take a title, and every one of them is worth your time.

Best Creative — Top 5

“Neb” by Nebsh 🇫🇷

Hand-drawn energy and a graffiti wall that says the title, built locally in ComfyUI. Nebsh’s note to us was three words and a heart, which felt about right. Our guest judges praised Nebsh’s work for its mixed-media feel, harking back to MTV days, and impressive work syncing with the paper sounds. Under the hood, Nebsh’s workflow chained vtogether eight segments with no visible drift between them- cited as “very clean work” by our judges.

Watch → YouTube
Workflow → Google Drive
Follow → @nebsh83

“The Museum of Impossible Sounds” by scvxzf 🇨🇳

A perfect 15/15 from the Comfy team on the Creative rubric, and one of the entries that ran the Comfy MCP end to end! Noted by our judges, H3 is very good at the kind of sound effects showcased in scvxzf’s work rather than talking or singing, and they chose exactly the right concept for the challenge.

Watch → YouTube
Workflow → Google Drive · github.com/scvxzf1
Follow → youtube.com/@钛龙白口-j6d

“Mister Meow” by sorryaboutyourcats 🇺🇸

Two reference photos of Mumu the cat, a stack of WAVs fed in as reference audio to steer each generation, and glitch texture added in the edit. If the name rings a bell, sorryaboutyourcats also makes the game mow meow. Judges said “I could watch this forever,” had it stuck in their heads, and noted impressive capabilities from H3 nailing lipsync for cats, and not just humans.

Watch → youtube.com/watch?v=AxUu8rabC6M
Workflow → Google Drive
Follow → @sorryaboutyourcats

“Rings of Sorrow” by Slop Diffusion 🇪🇸

A 5/5 on both audio sync and creative execution, and a reminder of what patience looks like: the generation took two hours and thirty-five minutes on a 5090. Our judges praised Slop Diffusion’s work for its storytelling, noting they were curious to see where the story would go next. One judge noted, “it’s slop by name, but not by nature.”

Watch → Reddit
Workflow → Google Drive
Follow → @SlopDiffusion

Best Technical — Top 5

“Feel It” by Aïe Aïe Aïe! 🇫🇷

Came at the brief backwards: we asked for audio-driven video and they told the story of a young deaf woman who invents a world where she makes the music. The score is Aïe Aïe Aïe’s own composition, fed into H3 as reference stems (the clap track went in on its own and the gorilla claps exactly in time). Judges praised the work for its captivating story, clever inversion of the challenge’s brief, the display of H3’s strengths by way of the musicians’ physical expressions intensifying along with the song, and the bridging of the real world. The artist learned the final frame’s sign language on YouTube, filmed themself signing, and used this as a video reference.

Under the hood, Claude drove ComfyUI through the MCP to design a two-pass H3REF system that generates at full resolution twice as fast and reaches 13–15 second shots where the stock workflow runs out of memory, plus a preview node that shows the video while it’s still sampling. All of it is MIT-licensed, custom nodes included.

Watch → youtube.com/watch?v=S0v1pWN4Hq4
Workflow → github.com/Hyper-Neural/h3-sync-two-phase
Follow → @AïeAïeAïe

“Brand New Day” by RareTutor 🇮🇳

One of the cleanest graphs we opened: latent upscale, a model preview override, and an optional video-extend group, laid out so you can follow it cold. RareTutor’s YouTube is full of tutorials if you want to learn from them directly!
Judges highlighted RareTutor’s workflow, noting “there are many tips in here to copy,” such as using the latent upscale as a previewer so you can kill a bad run before sinking more time in.

Watch → youtube.com/watch?v=TNhJI8dzaVA
Workflow → Google Drive
Follow → @raretutor_

“Comfy Cora ft. Max Mini: Back to the Basics” by wur7el 🇦🇹

A short music video with self-imposed constraints: no external resources, everything generated in a single workflow, no custom node packs. The result is well annotated and approachable, the kind of graph a new user could open and reasonably figure out, and it posted the highest Creative score of any Technical finalist. Judges praised the work for being a standout example of how to make a music video where the characters are actually rapping the parts in the song.

Watch → wamms.at
Workflow → sync-sound-challenge.json
Follow → wamms.at

About the Comfy MCP

Several finalists and many entrants leaned on the Comfy MCP, which lets an agent (Claude, Cursor, Codex, Hermes, whichever you use) drive ComfyUI in plain language.

The feature entrants used most was the hardware check: it looks at the GPU you actually have, reads the nodes and models already on your disk, and tells you which version of a model is worth running before you spend time or credits. It works on both local ComfyUI and Comfy Cloud from one account.

It’s open source at github.com/Comfy-Org/comfy-mcp, and the fastest way to start is to tell your agent: “help me set up the local Comfy MCP connection.”

Every entry

Placed or not, every submission is in the challenge megathread on r/comfyui with its workflow attached. Go open a few. Some of the most interesting audio work in the pool never made the top ten, and there are entries in there in Chinese, Japanese, and French that deserve more eyes than they got.

The livestream recording, including the judges’ live reactions, is on YouTube.

Thanks for making this one a smash! #ComfyH3

Both Trellis.2 (Xiang et al., 2025) and Pixal3D (Li et al., 2026) now run natively in ComfyUI. No custom nodes, no compiled CUDA extensions, no PyTorch downgrades, and no non-commercial dependencies.

This is more than a model integration. It ships with a rebuilt 3D pipeline: new Load/Preview/Save 3D nodes, a set of mesh post-processing nodes, and an extended PBR texturing stage that bakes normal and ambient occlusion maps for a complete material set. Everything runs on consumer hardware, and everything is free to use, including commercially.

Try on Comfy Cloud

Why Trellis.2 still matters, ten months later

When Microsoft open-sourced Trellis.2 in December 2025, it immediately became the best open-source model for 3D generative AI. A 4-billion-parameter model built on a compact structured latent representation (O-Voxel). It generates high-fidelity 3D assets from a single image at effective resolutions up to 1536³, handling complex topologies that earlier methods struggled with. It also shipped with a PBR texturing model generating base color, roughness, and metallic maps.

Ten months is an eternity in generative AI, yet Trellis.2 hasn’t just aged well, it has become foundational. Several open-source 3D models released since build directly on it, the most notable being Pixal3D whose implementation uses the Trellis.2 backbone.

The community got there first

As always, the ComfyUI community was quick to bring Trellis.2 into the graph. Within days of the release, custom node packs appeared, the most popular being ComfyUI-TRELLIS2 by Andrea Pozzetti and ComfyUI-Trellis2 by VisualBruno, which together gathered well over a thousand stars. We’re grateful to both authors as they proved the demand and carried the community for months.

Despite their efforts, running Trellis.2 remained a challenge for two reasons.

Installation

The original implementation targets environments built around PyTorch 2.6.0 with CUDA 12.4, which for many users meant downgrading their existing ComfyUI environment. On top of that sit a stack of compiled CUDA extensions (flash-attention, FlexGEMM sparse convolutions, the O-Voxel kernels, CuMesh, nvdiffrast) each of which must match your exact Python, PyTorch, and CUDA combination. The custom node authors did heroic work shipping prebuilt wheels per configuration, but every PyTorch or CUDA update meant a new round of compilation failures, and installs regularly broke. This is now solved with the native integration in ComfyUI. Follow our installation tutorials for Trellis.2 and Pixal3D.

Licensing

Trellis.2’s own code and weights are MIT-licensed, but its original pipeline depends on NVIDIA’s nvdiffrast (for mesh rasterization) and nvdiffrec (for Physically Based Rendering), both distributed under the NVIDIA Source Code License which restricts usage to non-commercial research and evaluation. In practice, a studio couldn’t ship assets from the reference pipeline without stepping into a legal gray zone. These dependencies have been removed from with the native integration.

Then came Pixal3D

In April 2026, Pixal3D from researchers at Tsinghua University and Tencent ARC Lab got accepted at SIGGRAPH 2026. It pushed open-source 3D generation another step forward with its pixel-aligned generation establishing direct pixel-to-3D correspondences. The result is near-reconstruction-level fidelity to the input view, with detailed geometry and the same PBR material set.

Pixal3D, simplified mesh with PBR material set

Pixal3D is heavily built on Trellis.2 as it uses its backbone and shares its VAEs and DINOv3 image conditioning. This is why integrating it together with Trellis.2 made sense. However Pixal3D generally performs better than Trellis.2 as the generated 3D mesh strictly aligns with the input image.

Model highlights

Trellis.2

• Single image to 3D asset. A 4-billion-parameter model that generates high-fidelity geometry and materials from one input image.

• O-Voxel structured latents. A native, compact omni-voxel representation encoding both geometry and appearance, generating assets at effective resolutions up to 1536³.

• Any topology. Handles open surfaces, non-manifold geometry, and fully-enclosed volumes.

• PBR materials built in. A dedicated texturing model generates base color, roughness, and metallic maps.

Pixal3D

• Pixel-aligned generation. Geometry is generated in direct correspondence with the input view. What you see in the image is what you get in 3D!

• Explicit image back-projection. Multi-scale image features are lifted into a 3D feature volume, delivering near-reconstruction-level fidelity.

• Cascaded refinement. A staged process progressively refines sparse structure, shape, and texture up to high resolution.

• Built on Trellis.2. Shares the Trellis.2 backbone, VAEs, and DINOv3 conditioning.

Generated results, no post-processing of the mesh, vertex painted

What ships in this integration

The goal was simple: make the best open 3D models run in ComfyUI the way every image or video generation model does. A major thank-you goes to Kijai for the implementation, and to yousef-rafat for the initial draft this work built on. In addition to the native implementation, this has been an opportunity to make 3D generation a first-class citizen in ComfyUI. Here is what shipped:

Pure native implementation

Both Trellis.2 and Pixal3D now run as core ComfyUI nodes. The 3D post-processing that required compiled extensions has been reimplemented from scratch in PyTorch and SciPy. No nvdiffrast, no nvdiffrec, no per-configuration wheels, no PyTorch downgrade. If your ComfyUI runs, these models run on your current PyTorch.

Rebuilt 3D nodes

While these were shipped in an earlier version of ComfyUI, the Load 3D, Preview 3D, and Save 3D nodes have been rebuilt from the ground up to support these models and modern mesh workflows. We’re grateful to Terry Jia for his remarkable work on these nodes. Check out the nodes:

• Load 3D (Advanced)

• Preview 3D (Advanced)

• Save 3D (Advanced)

Native mesh post-processing

Raw generative meshes are rarely production-ready, so this release introduces a new set of post-processing nodes:

• Remesh Mesh: fixes holes and mesh imperfections.

• Decimate Mesh: reduces face and vertex count to a target budget.

• Smooth Mesh Normals: smooths the mesh volume.

• Fill Holes: fill-in holes resulting from the generation

• And more: Merge Meshes, Paint Mesh, Render Mesh…

A complete PBR texture set

Trellis.2’s texturing model generates base color, roughness, and metallic maps. Our implementation goes further: a new UV unwrapping node prepares the mesh for texturing, and two additional maps are generated: a normal map and an ambient occlusion map, both baked from the high-poly mesh. Are these textures perfect? No. But they’re free, generated on consumer hardware, and yours to use as you wish.

Example results

An honest word on quality

Let’s be direct: the best closed-source 3D generators (Hunyuan 3D, Tripo, Rodin) still produce better results than Trellis.2 and Pixal3D. If you need the highest quality and an API fits your pipeline, those remain strong options (all of them are available through ComfyUI’s partner nodes).

What this integration offers is different: the best open 3D generation available, running locally, at zero cost per asset, with no licensing restrictions on what you make. For iteration, prototyping, stylized work, 3D-to-2D workflows, and anyone who wants full control of their pipeline without spending an afternoon to install.

Getting started

1. Update ComfyUI to the latest version 0.34.0 or go to Comfy Cloud

2. Download the workflows below, or find them in the template library.

3. Follow the note in the workflow to download the models and save them in the correct model directory.

4. Drop in an image and run.

Download Workflow

Model weights:

• Comfy-Org/TRELLIS.2

• Comfy-Org/Pixal3D

• Comfy-Org/BiRefNet (for background removal)

• Comfy-Org/MoGe (for camera FOV estimation)

Gemini Omni 1.1 Flash is now available in ComfyUI via Partner Nodes. It ships in the Gemini Video Omni node, where you select “Omni Flash 1.1” from the model dropdown and get text-to-video, image-to-video, reference-to-video, video editing, and scene extension from a single node. Resolution runs from 360p, up to 4K, every clip comes with a generated audio track, and the node accepts an image and a video input alongside your prompt.

Try on Comfy Cloud

Model Introduction

Gemini Omni 1.1 Flash is Google’s multimodal video model, built for fast generation, editing, and cinematic control. It is an improvement from the earlier Omni Flash version.

It is natively multimodal: text, image, audio, and video are processed together, which is what keeps output cohesive across modes. It supports conversational editing: describe a change in plain language and the model applies it while leaving the rest of the clip alone. And it carries Gemini’s world knowledge, pairing an understanding of physics with context from history, science, and culture, so scenes read as plausible rather than just photoreal.

In ComfyUI, the node exposes a prompt, resolution (360p, 720p, 1080p, 4K), aspect ratio (16:9 or 9:16), a task type selector (text_to_video, image_to_video, reference_to_video, edit, or extend), and optional image and video inputs.

Model Highlights

Resolution up to 4K

Output is available at 720p, 1080p, and 4K. Iterate on prompt and composition at 720p, then rerun the keeper at 1080p or 4K for delivery.

Video editing

Omni 1.1 Flash edits video by instruction. Connect a clip to the video input, describe the change, and the model applies it while preserving everything else. Short prompts work best here: “make this video anime,” “change the lighting to be more dramatic,” “change the text on the sign to say ‘Omni Flash’.” Adding “keep everything else the same” helps hold visual consistency when you are targeting one element.

Edits can be stacked. Because the model retains context from the previous result, you can adjust lighting in one pass and swap the background in the next without re-describing the scene.

Scene extension

Extend an existing clip and the model reads the prior motion and composition to carry continuity, character identity, and lighting through the added footage. “Continue the shot: the woman finishes the violin solo and takes a bow” picks up where the previous clip ends.

Prompting Omni 1.1 Flash

The model does a lot of its work from the prompt, so a few behaviors are worth knowing before you start.

Scene structure. By default the model composes a short narrative with several shots. If you want one continuous take, say so explicitly: “in a single unbroken scene,” “in a single continuous shot,” or “no scene cuts.” Detailed prompts that cover the scene, camera move, lighting, and mood outperform short ones.

Image inputs. When you supply an image, the prompt decides how it is used. The model can animate a product shot or photograph directly, or treat a drawing purely as a motion guide and produce realistic footage that does not show the sketch at all. Pair high-resolution inputs with specific motion descriptions; “make it move” will not get you far. To pin an image to a role, use tags in the prompt: <FIRST_FRAME> makes it the opening frame, and <IMAGE_REF_N> (indexed from 0) makes it a reference for a style, character, or object.

Editing prompts. Short instructions work best; overly descriptive edit prompts tend to introduce unintended changes. “Make this video anime,” “change the lighting to be more dramatic,” or “change the text on the sign to say ‘ComfyUI’” is the right register. When you are targeting one element, add “keep everything else the same.”

Timing. Events can be placed in natural language (”after 3 seconds, a woman enters the scene,” “every 2s cut to a new frame”) or with timecode brackets like [0-3s], [3-6s].

Audio. Every clip gets a generated soundtrack. It responds to direction, especially for music: “include calm background music,” “the video has a high energy techno beat.”

On-screen text. Rendered text is readable and controllable, so if a sign, label, or caption will appear, spell out what it should say.

Negatives. There is no separate negative prompt field. Put exclusions in the prompt itself: “no dialogue,” “no extra sound effects.”

Getting Started

1. Update ComfyUI to the latest version, or access Comfy Cloud.

2. Find the Gemini Video Omni node via the Node Library, or load a template from the Templates panel.

3. Select “Omni 1.1 Flash” as the model, add your prompt and any image or video inputs, set resolution and task type, and run.

Try it on Comfy Cloud, and let us know what you build.
As always, enjoy creating!

Open weights got you creating. Now, in partnership with MiniMax, Comfy is the one place to license H3 for local commercial work.

With full rights to your outputs, LoRA training included, and our Forward Deployed Creatives to help you do your best work.

When MiniMax H3 dropped with open weights earlier this month, we had it running in ComfyUI on day zero. Since then, the community response has been incredible. 2K video with native stereo audio, running locally on hardware as accessible as a 3060, is a big deal.

Open weights mean anyone can download H3 and start creating. But the moment you want to run it locally for business, client work, products, anything commercial… You need a commercial license.

Today we’re announcing the next step in our partnership with MiniMax: Comfy is now the first official reseller of MiniMax H3 commercial-use licenses. If you want to use H3 commercially, you get your license through Comfy.

Get an H3 Commercial License →

What’s included

Every H3 commercial license through Comfy comes with:

• Full commercial rights to your outputs. Everything you generate is yours to use, sell, and ship.

• Fine-tuning and LoRA training. Train the model on your characters, your style, your product. Fully allowed.

• Client and downstream work. Agencies and studios can use H3 for customer projects.

• MiniMax Audio & Music. Licenses cover MiniMax’s audio and music models too, not just video.

We offer a Professional plan and an Enterprise plan, and Enterprise customers get access to every H3 model version; including undistilled weights and new releases as they ship. For plan details and pricing, see the license page.

One thing to note: these licenses are for building your own products and content. They don’t cover running an inference platform or marketplace that sells H3 access to others.

Forward Deployed Creatives: we’ll build it with you

A license gets you the model. Our Forward Deployed Creatives get you to production.

Forward Deployed Creatives are Comfy experts who embed with your team. They can train LoRAs on your style, build production workflows in your environment, and teach your team to run, modify, and extend everything they build. And what they build is yours to keep.

If you’re licensing H3 for serious commercial work, Comfy is the fastest path from “we have the model” to “we’re shipping with it.”

Getting started

1. Already on Comfy Cloud? You’ve got commercial rights already. Nothing to buy! This license is for running H3 locally on your own hardware.

2. New to H3? Try it on Comfy Cloud or grab the workflows in the template library.

3. Ready to go commercial? Get your license here or contact us, we’ll help you pick the right plan.

4. Want hands-on help? Meet the Forward Deployed Creatives.

Open weights to experiment. H3 licenses to use now. All in one place.

As always, enjoy creating!

Get MiniMax License

Subscribe now

Wan 3.0 is the newest video generation model from Alibaba, and it is live in ComfyUI. Compared to its predecessor, it delivers native 30-second output, prompt input expanded to 20,000 characters, reference capacity increased to 10 images, 5 videos, and 5 audio clips, and web page input parsing. A newly added 480p tier covers lower-cost drafts, while ‘adaptive’ aspect ratio and ‘auto’ duration let the model pick the optimal aspect ratio and length on its own.

Generations run at 480p, 720p, or 1080p across 16:9, 9:16, 4:3, 3:4, and 1:1 aspect ratios. Output duration is anywhere from 2 to 30 seconds, and audio generation can be toggled off.

Try it on Comfy Cloud

Model Highlights

Native 30-second duration

Wan 3.0 generates up to 30 seconds in one pass — no stitching. That’s enough room for complete storytelling: continuous camera moves, single-take shots, and pacing that builds across a full scene rather than resetting every few seconds.

Omni Creation

Generation can draw from up to 20 reference assets at once — 10 images, 5 videos, 5 audio clips, and one file or URL. References are addressed directly in the prompt with @ syntax (@Image1, @Video2, @Audio1), so you can control exactly where each one applies: a character card for identity, a video for camera movement, an audio clip for voice timbre. Document and webpage parsing means a proposal doc or a wiki page can serve as the source material for a finished clip.

Precision video editing

Wan 3.0 edits existing video by instruction. Remove or replace elements, relight a scene, change motion, transform a subject, or reshape the narrative — “have the man pick up the guitar and start playing” — while everything else in the frame stays put. It also extends existing footage, with total input plus output up to 30 seconds.

Cost

Model pricing is very competitive and scales with resolution. The 480p tier is new in this release, which allows you to iterate quickly while keeping costs down.

Getting Started

1. Update ComfyUI to v0.33.4, or access Comfy Cloud.

2. Find the Wan 3.0 nodes via the Node Library, or load a template from the Templates panel.

   Wan 3.0 Reference to Video Workflow

   Wan 3.0 Image to Video Workflow

   Wan 3.0 Text to Video Workflow

3. Add your prompt and any reference assets, connect outputs, and run.

Try it on Comfy Cloud, and let us know what you build.

As always, enjoy creating!

MiniMax H3 is the first open weights omni-modal video model with state of the art native stereo generation on Comfy, so we’re teaming up to see what the community builds with it!

Submit Here

Fully virtual. Two weeks. Open to everyone, local rig or Comfy Cloud.

Winners will be announced live on 9/2 at 10am PT, and the top 10 submissions will be reviewed by our special guest judges! Join here.

Need help or inspiration? Visit Reddit or join the Comfy Discord #minimax-h3-challenge channel to see what the community’s been creating and chat with Comfy and MiniMax teams directly.

The Challenge

Build a short piece where sound and motion are inseparable. The audio has to come out of the same H3 pass as the video — dialogue, foley, ambient sound, a beat that drives the motion, whatever direction you want to take it. Feeding in a reference audio clip that does not contain unlicensed IP to steer the generation is completely fair game and often the best way to get strong audio out of H3. What’s not allowed is stitching a separately-made track onto the video afterward, outside of H3.

Good news- Comfy just got easier to use with the help of Comfy MCP, available locally and in Comfy Cloud. Use natural language and your agent (Claude, Cursor, etc.) to do a hardware check and adapt your workflow accordingly, tweak or debug without needing to know all the technical details, and more. Use Comfy MCP for a chance to win a special MCP bonus prize!

Timeline

[Day 1] Thurs. 8/20: Challenge & #minimax-h3 Discord channel launch

[Days 1–14] 8/20-9/1: Build and submit

[Day 16] 9/2: Comfy livestream with guest judges and winner announcement!

How to Enter

Submit Here

Every submission must include:

• Your final output: the video, with H3-generated synced audio

• Your ComfyUI workflow file: the actual .json so we can see how you built it

To submit:

• Fill out the submission form

• Post your video on our Reddit megathread

• (Optional) Share on your socials (X, Instagram, LinkedIn, YouTube, TikTok) tagging @ComfyUI @MiniMax #ComfyH3 so we can reshare our favorites!

Requirements:

• A major portion of your piece must be built in ComfyUI using H3. Beyond that, any tools, models, or techniques you want to combine it with are fair game.

• All submissions must be lawful, SFW, and must not contain unlicensed IP or likenesses

• By submitting, you agree to allow ComfyUI and MiniMax to feature your work (with credit) across our channels

• Limited to one submission per user, 90 seconds maximum length

Do I need to pay to use H3?

Nope. If you’re running H3 locally in ComfyUI, it’s free! Update to ComfyUI 0.30.0+, grab the model from here, and run it on your own GPU.

We’ve optimized H3’s memory footprint by 66%, so it’ll even run on consumer cards like an RTX 3060. Use Comfy MCP to ask your agent to suggest the right H3 version for your hardware or optimize your workflow for your machine.

Prefer not to deal with local setup, or don’t have the hardware? Run it through Comfy Cloud instead! New users gets 5 free GPU-powered runs with no card required, and it’s credit-based beyond that.

Prizes: 4 Ways to Win!

Grand Prize: Best Overall

RTX5090-O32G-G

Best Technical/Workflow

RTX 5060 Ti (16GB)

Best Creative

RTX 5060 Ti (16GB)

Built with MCP Bonus

RTX 5060 Ti (16GB)

All prizes will be shipped directly to the winners with customs costs covered by organizers. To the extent items cannot be shipped, a cash-equivalent prize will be offered.

Every entry is eligible for our spotlight reel, regardless of whether you place!

How Winners Are Chosen

Every submission is reviewed by a joint panel of creative technologists from Comfy, MiniMax, special guest judges, and community input using the criteria below.

Grand Prize: Best Overall

The top finishers from Best Creative and Best Technical advance to a final round where our panel of judges selects winners by discussion. We’re looking for the entry that best shows what H3 makes possible: strong to watch and built in a way others can learn from.

Best Creative

• Audio sync realism and intentionality (0-5)

• Creative execution and originality (0-5)

• Deliberate craft (0-5)

  Evidence that you’ve actually shaped the result beyond prompt engineering. Judges will look for modified/non-default parameters, multiple linked passes visible in the workflow structure, or a couple sentences describing what was tried and changed

Best Technical/Workflow

• Novelty of technique or approach (0-5)

• Workflow quality (0-5)

  Annotated, clean, replicable by someone else

• Community value (0-5)

  Would this actually help someone else?

Built with MCP Bonus

• Effectiveness (0-5)

  Did the agent meaningfully drive your process, not just generate one line?

• Insight value (0-5)

  How much the shared prompt teaches the community about prompting H3 through MCP

• Output quality (0-5)

FAQ

Can I use both local and Cloud?

Yes! Mix and match however you want. Just tell us which path you used when you submit.

What’s the Comfy MCP?

It lets you drive ComfyUI workflows locally or in Cloud through an MCP-connected agent/tool (Claude, Cursor, etc.) instead of (or alongside) the regular UI.

It allows you to use natural language and your agent (Claude, Cursor, etc.) to drive ComfyUI workflows both locally and in Cloud. Try doing a hardware check and adapting your workflow accordingly or tweaking or debugging without needing to know all the technical details. Use Comfy MCP for a chance to win a special MCP bonus prize!

Learn more here.

What happens to my workflow file after I submit it?

All submissions (workflow + output) are shared as-is in the H3 Reddit megathread for the community to browse, remix, and comment on. Winning entries get the full treatment: a dedicated write-up and feature across our channels!

Can I submit more than once?

Submissions are limited to one per person.

Can one entry win more than one category?

Yes! Best Overall/Grand Prize is pulled from the top finishers of Best Creative and Best Technical/Workflow, so to win Best Overall, your entry needs to have placed in one of those two tracks first. The Built With MCP Bonus is separate from all of that: any MCP-tagged entry is automatically in the running. So one entry could win a title as well as the Built With MCP Bonus.

Is there a public/community vote?

Not a formal vote, but the community isn’t just watching from the sidelines either. During the guest judge livestream on 9/2, community chatters and reactions from social will be part of what the judges weigh alongside the scoring criteria. We wanted a way for the community to genuinely have a say without opening up a survey or ballot that’s susceptible to botting.

What counts as “a major portion built in ComfyUI using H3?”

H3 needs to generate the core video and audio in ComfyUI. Everything else is fair game: upscaling or restyling the output, color grading, adding titles or credits, feeding in a separately-made first frame or reference image to steer H3, or cleanup in another tool after generation. Keep in mind that using tools outside of ComfyUI may make your workflow less replicable if you’re going for the Best Technical prize.

I’m in a country where I can’t receive the GPU. Am I still eligible to enter/win?

Yes! You can enter and win no matter where you’re based. If we’re unable to ship the GPU to your country because of import restrictions, export controls, or customs issues, we’ll offer a cash-equivalent prize instead. Winner is never contingent on where you live!

Will I get any feedback if I don’t place?

We can’t guarantee individual feedback given submission volume, but all entries are shared in the Reddit megathread for community input.

Can I submit a workflow I built before the challenge started?

We welcome you to start from a workflow you already had, including one built before the challenge.

Comfy MCP is now one MCP with both local and cloud. Everything the Cloud MCP connection does still works: build, edit, and run workflows in plain language, search models, nodes, and templates, save and re-run what works. Add the local connection and one agent covers both environments; it knows what your machine can do and what Cloud is better at, and picks accordingly.

Cloud or local? You don’t have to choose. Run both with one Comfy account and just tell your agent where a job should go, or let it decide.

Your agent now knows your local setup.

• It reads your hardware. Your agent looks at the GPU you actually have and tells you whether a model is worth running locally, before you commit to the download. No failed runs on a model that was never going to fit.

• It handles the setup. Model files, starting and managing your local instance, getting a workflow to the point where it runs. If you are new to local, this is what gets you from downloading to creating.

• It sees your install. Your agent reads every node loaded in your install, including custom nodes, plus every model on your disk. Anything you can install locally, it can build with.

Example: Build and run a MiniMax H3 workflow locally

Open-weight video is having a moment. MiniMax H3 and models like it are so good that people want to run them on their own hardware. But that is exactly where local ComfyUI gets steep: which version fits your card, where the weights live, which nodes the workflow needs, and whether any of it will run before you have spent an hour finding out.

The whole setup is one conversation:

“I want to run MiniMax H3 open source on my own machine. What’s the best model version for my hardware, and can you set up the workflow?”

Your agent checks that ComfyUI is up and reads your GPU. It comes back with which model version makes sense for your card—or tells you plainly if none do. It pulls the weights, finds a template to build from, checks the workflow against the nodes you actually have installed, and runs it. Outputs land in your own output directory.

Get started in 5 minutes

Fastest path: paste this into your agent and ask it to set up the local connection.

Help me set up the local Comfy MCP connection.
Follow the setup guide at https://docs.comfy.org/agent-tools/mcp.md#local-comfy-mcp-connection

Or consult our docs for manual installation instructions!

What this unlocks

Large batches on your own meter. On local hardware the only running cost is electricity. Queue before bed, review in the morning.

“Run entire variations of these scenes in the video, change it to realism and in Christmas theme, and add back the motion graphic components after swapping the assets.

A bridge to the rest of your desktop. Blender, Houdini, DaVinci, and ComfyUI share one file system, and now so does your agent.

“Take the render passes I just exported from Blender, do reference to video in ComfyUI, and drop the result back into my project folder.”

The custom-node ecosystem, on tap. Anything you can install, your agent can build with, and it does the installing too.

“Find a node pack that does depth-controlled restyling, install it, and add that stage to my workflow.”

Resource

• Learn more: https://comfy.org/mcp

• Github: https://github.com/Comfy-Org/Comfy-mcp

• Docs: https://docs.comfy.org/agent-tools/mcp

• Comfy Skills: https://github.com/Comfy-Org/comfy-skills/

Feedback

Tell us what works and what doesn’t. We’re listening and appreciate all feedback.

• Feedback survey: https://links.comfy.org/cloudmcpbeta

• Discord: #comfy-mcp-and-cli on the Comfy Discord

As always, enjoy creating!

Try on Comfy Cloud

MiniMax Music 3 is built for complete songs rather than loops or clips: conditioned on lyrics and a music description, it holds themes, rhythm, vocal identity, and arrangement progression together across the full track, and outputs 32 kHz, 16-bit stereo audio.

The architecture is a hybrid of two language models and a continuous synthesis stage. An 8B Global LLM (initialized from Qwen3-8B) models the song’s long-range semantic and structural progression. A 0.6B Local LLM restores fine-grained acoustic detail within each frame. Instead of decoding audio from discrete tokens alone, the synthesis module fuses the hidden states of both LLMs and passes them through a 2.4B Flow Matching stage and a 123M Flow-VAE decoder. Those continuous representations carry more acoustic information than tokens can which shows up in vocal articulation, instrumental texture, and temporal continuity.

Model Highlights

• Full songs with long-range coherence: Native support for generation up to five minutes. The model sustains complete song structures including intro, verse, pre-chorus, chorus, bridge, instrumental break, and outro, without losing the thread on melody, rhythm, or vocal identity.

• Lyrics with section tags: The lyrics input accepts explicit structure tags: [Intro], [Verse], [Pre-Chorus], [Chorus], [Post-Chorus], [Bridge], [Instrumental], [Solo], and [Outro]. You decide the song structure.

• Fine-grained control via Structured Captions — Beyond a plain-language description, the model accepts a Structured Caption with three sections: Global Metadata (genre, BPM, key, scale, emotional progression, production profile), Vocal Details (gender, timbre, performance style, harmony, backing vocals, effects), and Arrangement (instruments, section-level instrument evolution, groove, bass, percussion, textures, spatial effects). This lets you steer not just the overall style but how the song develops over time.

• Expressive vocals — Vocal performance is controllable down to timbre, harmony, and effects, and the hidden-state synthesis path is what keeps articulation clean across long passages.

• 32 kHz stereo output — 16-bit stereo WAV, with the Flow-VAE decoder retrained for the dynamic range and spectral characteristics of music.
  
  MiniMax also published an official music caption rewriter skill that turns a brief music description and optional tagged lyrics into a detailed Music 3.0 structured caption. The skill builds a coherent section-by-section arrangement with global metadata, vocal details, and arrangement descriptions, preserving explicit musical constraints while keeping the lyric text in the lyrics input. Install it with:
  npx skills add MiniMax-AI/MiniMax-Music3 --skill music-caption-rewriter

Examples

Gospel Soul

Rock (Instrumental)

Lo-fi Chillhop

Getting Started

1. Update ComfyUI to the latest version 0.33.0 or go to Comfy Cloud.

2. Download the workflow below, or find it in the template library.
   

   Download MiniMax Music 3 Workflow

3. Follow the note in the workflow to download the model weights and save them in the correct model directory.

4. Add your lyrics and music description, then run the workflow.

Model weights: 🤗 MiniMaxAI/MiniMax-Music3

As always, enjoy creating!

LTX-2.5 is the newest version of LTX’s open video model. The line has been built on a consistent premise: powerful video generation should be open, fast, and something you can actually run on consumer hardware. Weights are downloadable, the raw model can be fine-tuned on your own data, and it runs fast on local GPUs.

LTX-2.5 is an improvement across the full generation stack rather than a single-stage upgrade. It comes with significant improvements including a new rendering approach, a new video decoder, a custom text encoder, a better distilled variant, a prompt enhancer, and a base checkpoint built for adaptation. Native 4K, synchronized audio and video, and frame rates up to 50fps carry over from LTX-2.3.

Not only that, the LTX team also delivered a small experimental duration head model that automatically sets the length of the generated video.

Variants

LTX-2.5 comes in two forms in ComfyUI: open weights you run yourself, and hosted models available through Partner Nodes.

Open weights

• LTX-2.5 dev — the main model.

• LTX-2.5 distilled — a smaller, faster variant. Distillation has been reworked to carry more quality, prompt adherence, and motion than previous distilled releases, which makes it viable for deployment where the full model isn’t economical.

Via Partner Nodes

• LTX-2.5 (Fast) — the wider envelope. 2 to 20 seconds, 720p through 4K in landscape or portrait, and frame rates of 24, 25, 48, or 50. Clips over 10 seconds run at 720p or 1080p and 24 or 25fps.

• LTX-2.5 (Pro) — 2 to 10 seconds at 720p or 1080p, with frame rates of 24, 25, or 50.

Model Highlights

• Diffusion Fidelity Rendering. New in LTX-2.5, and the core change in this release. Rather than spending compute evenly across a scene, the model allocates it by complexity. Structure comes first: motion, composition, and framing are generated in an 8x temporally compressed latent space, alongside a set of high-fidelity keyframes — more keyframes for complex scenes, fewer for simple ones, within the available compute budget. A dedicated pixel-diffusion stage then renders the final video from the structure and keyframes together, carrying fine detail and texture across every frame. In practice that means textures, materials, intricate objects, and faces resolve with pixel-level precision, and busier shots automatically draw more rendering compute than static ones.

• Diffusion Video Decoder. Replaces standard VAE decoding. Sharper faces, legible text, and fewer smears in fast motion.

• Native multi-shot. One generation produces multiple connected shots, holding character, environment, lighting, voice, and style across the cuts. A sequence comes out of a single run instead of being assembled from separate generations that have to be matched afterward.

• Custom Gemma 4 12B text encoder. Purpose-built. Retains multiple subjects, actions, lighting details, and camera direction across a long prompt instead of dropping clauses as the prompt gets more complex.

• Dedicated prompt enhancer. A lightweight model that expands short prompts into detailed cinematic instructions, at near-zero additional compute.

• Auto duration. The model reads the action described in the prompt and predicts the right clip length before diffusion starts. With the prompt enhancer, that’s two fewer parameters to tune and less app-side logic to maintain in a pipeline.

Examples

Getting Started

1. Update ComfyUI to the latest version 0.32.0, or open Comfy Cloud.

2. Download the LTX-2.5 weights and place them in your models directory.

3. Load the LTX-2.5 template from the Templates panel, or download the templates below.
   

   Download LTX-2.5 T2V Workflow

   Download LTX-2.5 I2V Workflow

   Download LTX-2.5 FLF2V Workflow

4. Add your prompt, input images, and run.

As always, enjoy creating!

Model weights: 🤗 Lightricks/LTX-2.5

Wan Animate 2 is now supported natively in ComfyUI. This model uses a novel end-to-end character animation framework that directly consumes driving videos in a redesigned Diffusion Transformer, which achieves high-fidelity motion generation and strong identity preservation by eliminating intermediate motion extractors, with further text-driven viewpoint control to decouple the output camera perspective from the driving video. Wan Animate 2 Lite is the efficient variant of the same model, built for streaming character animation.

Two new nodes ship with them: WanAnimate2ToVideo, the conditioning node that takes your reference character and driving video, and WanAnimate2Cache, an optional node that caches the pose branch to cut generation time roughly in half.

Try it on Comfy Cloud

Model Highlights

• The driving video goes straight into the transformer. No intermediate motion extractor sits between your source footage and the model. That removes a lossy hand-off — anything the extractor failed to represent, like subtle expression or finger position, was gone before generation started.

• Higher-fidelity motion. Reading the driving video directly is what the Wan team points to for the jump in motion quality over the previous release.

• Stronger identity preservation. The same architectural change holds the reference character’s appearance more consistently across the clip.

• Text-driven viewpoint control. Camera perspective in the output is decoupled from camera perspective in the driving video. The driving clip supplies the performance; the prompt can place the camera somewhere else.

• Wan Animate 2 Lite runs at real-time latency. The efficient variant brings inference latency down to real-time thresholds, which puts streaming character animation on the table rather than batch rendering only.

• Video extension. Generations can be continued past a single clip, carrying motion across the seam.

• Optional pose caching. WanAnimate2Cache reuses the pose branch’s work across sampling steps instead of recomputing it every step, roughly halving generation time in exchange for system memory.

• Context window support. Long sequences can be generated in windows, including alongside the cache.

Getting Started

1. Update ComfyUI to the latest version, or open Comfy Cloud.

2. Load a template from the Templates panel, or download the workflows below.

   Download Wan Animate 2 Workflow

3. Connect your reference character and your driving video, set your output resolution and length, and run.

4. Optional: use WanAnimate2Cache to cut generation time.

Model weights: 🤗 Comfy-Org/Wan-Animate-2

As always, enjoy creating.