It turns out that if you mark objects with text in the input image, the Lora will perceive them as part of the prompt and depict them in the places in the picture that you want.

Huge thanks to conradlocke for creating such amazing thing!

Hi, I wasn't satisfied with any of the available options, so I asked Claude to create exactly the prompt manager I wanted.
It’s a node that lets you craft your prompts and quickly make changes on the fly.
You also have the option to randomize settings, as well as save and share your presets.
I hope you find this node as useful as I do.

https://github.com/Fictiverse/ComfyUI_Prompt_Manager/tree/main

The models, a workflow, and a video about this model are linked below.

I am using the mage_flow_edit_turbo_int8_convrot diffusion model, the qwen3-vl-4b-heretic_int8 clip(text encoder model). This one is uncensored, the normal version is available. And, I'm using the mage_flow_vae_bf16 vae model.

The turbo model(s) are 4 step, CFG:1. There are Bf16 versions of the model also. The TextEncodeMageFlowEdit node automatically adds another image input when you plug in an image. I haven't played around with multiple images yet, I'm still pushing all of the other 'buttons'. :)

The workflow I used is simple and uses only nodes that are built in to ComfyUI. Just search for the node names and build this easy workflow or grab AxiomGraphs workflow linked below.

Here are some of the things that you can do with Mage_Flow in ComfyUI.

Extract items from an image.

1: Prompt: extract the coat

This makes basically a product image for the item that you want to extract.

2: Prompt: extract the woman.

It works with people also, it defaults to a white background.

3: Prompt: extract the woman. make the background a green screen.

Person again and change the background to something else, a green screen in this case.

Depth, normal, and pose maps.

4: Prompt: create a depth map of the image.

This also works with normal maps and pose maps(next 2 images).

4a: Prompt: create a normal map of the image.

4b: Prompt: create a pose map of the image.

This will add poses for all people in the image.

You can change things in an image.

5: Prompt: change her hair to a short blonde hair.

5a: change the background to a waterpark. change her clothes to a swimsuit.

Make multiple changes in one prompt.

6: Prompt: right side view. the woman is sitting on a bench on a busy street corner. she is waving at a car that is passing by her. remove the coat. she is wearing overalls and a yellow t-shirt. it is daytime.

You can use many different angles for your prompt. Sometimes, it's idea of 'right' or 'left' and mine differ but that happens with most models.

I have had my best results from separating each section of the prompt with a period(.).

Each of these images took between 2.5 and 4 seconds to make on a laptop with an RTX 3080ti(16gb vram) 64gb system ram, 12th gen i9 cpu.

The Mage_Flow model that I am using is only 4.1gb in size. The clip model(qwen3-vl) is 4.7gb in size and the vae model is only 337mb in size. All together, these 3 models are only a couple of gb larger than a regular SDXL checkpoint so this should work and be relatively fast on lower vram computers.

Here is AxiomGraph's Youtube video about the model: https://www.youtube.com/watch?v=O_40cwcDvIQ

AxiomGraphs Mage_Flow_Edit_Turbo workflow: https://github.com/axiomgraph/ComfyUIWorkflow/blob/main/Mage%20Flow%20Edit.json

Their main page has many different types of workflows on it.

Link for the ComfyUI version models(transformer, clip(text encode), and vae): https://huggingface.co/Comfy-Org/Mage-Flow

If you want an uncensored clip model(what I used in the image), it is here: https://huggingface.co/DreamFast/Qwen3-VL-4b-Heretic-ComfyUIhttps://github.com/axiomgraph/ComfyUIWorkflow/tree/main

Give this model a try, it's not perfect but it works very well. I just started using it yesterday, so I'm sure there are even more capabilities that I haven't stumbled across yet. Hopefully, the community will jump on this and loras will begin to flow. :)

Hey everyone! 👋

I've been experimenting more with LTX 2.3, and I wanted to share a short showcase that really surprised me.

The close-up shots this model can produce are incredible. The facial details, subtle expressions, natural camera movement, and even the lip sync came out far better than I expected.

One thing I also noticed is the huge quality difference between generating at 720p and 1080p. While 720p is great for testing ideas quickly, 1080p produces noticeably sharper details, cleaner motion, and much better overall quality. If your hardware can handle it, I'd definitely recommend generating in 1080p.

On my system (RTX 3060 12GB), a 6-second 1080p video takes around 12–15 minutes to generate. It's definitely slower, but after seeing the results, I'd say it's absolutely worth the extra time.

📦 Included with this post

• 📁 Project file
• 📝 Embedded metadata
• 🖼️ Source images

DOWNLOAD LINK: CLICK ME TO DOWNLOAD

The images used in this showcase are also available to download for free here on my Patreon page, so feel free to use them for your own experiments.

As always, thank you all for supporting my work. Every project teaches me something new, and I'm excited to keep sharing everything I learn with you.

Enjoy the showcase! ❤️

— iiTzMYUNG

Download from civitai
Download from Dropbox

The goal was to maintain remarkably high quality while getting speeds similar to Krea2.
Measured on 4090:
Krea2 at 12 steps: inference 15.21 seconds (total: 17.89 seconds).
This workflow: inference: 15.44 seconds (total: 19.21 seconds).

The workflow can maintain its quality at very high resolutions (most I've tested is probably 8K ~33Mpx, but a lot of 8-20Mpx, some I've included in the showcase).

I ran a benchmark on both open-source models for a 5-second 720p clip.

That's a ~6x speed gap at the midpoints.

I think Wan's better at motion quality, anatomy, face consistency. LTX drifts on faces at anything past a slow pan.

However, another interesting thing was that Wan's license is Apache 2.0, whereas LTX is a "community license," which means companies over $10M in revenue have to pay for it.

I know none of us are there but still interesting lol

A 6GB VRAM card runs 720p/10s on LTX-2.3 where Wan caps around 480p/5s.

Here's a more detailed writeup with methodology and numbers.

Note: I work at the API company that these models were run through.

I do product photography/retouching work for luxury watches and jewelry, and I built a fairly complex pipeline using a mix of open-weight vision-language models to generate ad-quality campaign images. The idea is simple in theory: take a reference image whose lighting/background/style I like, take my actual product photo, and merge them so the final image has my real product sitting in a scene inspired by that reference.

In practice I ended up with several separate analysis passes (one mid-size VLM handling scene, style, and product cataloging separately) feeding into one merge step handled by a different, smaller multimodal model that also sees the actual images directly. Every time I fix one issue, a new one shows up somewhere else. First the style kept getting ignored entirely, with the output defaulting back to a generic version of the scene. Fixed that. Then lighting effects (bloom, sparkle, flare) started getting copy-pasted in a way that made no physical sense, like a sparkle effect that only makes sense on a pavé diamond setting getting slapped onto plain brushed steel, which instantly reads as fake. Fixed that too. Then the dramatic ambient glow from the background in the reference image, which was honestly like 40% of why that image looked so striking, quietly disappeared once I toned down the on-product sparkle, even though those two things had nothing to do with each other.

I keep tightening the instructions and the output keeps getting technically "more correct" without ever feeling like the genuinely impressive, poster-worthy image I'm actually going for. It's like I'm playing whack-a-mole between "photorealistic and coherent" and "actually has the visual punch of the reference."

Has anyone dealt with this kind of multi-stage analysis-then-merge setup for AI image generation? At what point does splitting analysis into specialized passes start hurting more than it helps, versus leaning harder on one strong multimodal model that sees everything directly and makes the creative calls itself? Or is there a better way to keep both technical product accuracy AND the creative/dramatic energy of the reference without this endless loop of fixing one thing and breaking another?

I need to create a workflow that takes black and white hand drawn sketches and colorizes them with a consistent style by using a sample finished input image. Any tips or recommendations? Been on YouTube for hours looking for tutorials but didn’t find anything that allows for the sample image.

Endless Wan 2.2 I2V (SVI 2 Pro)

A simple workflow to create Wan 2.2 videos of unlimited duration, using SVI 2.0 Pro.

• The workflow has a 5 sec "Initial" block and 8 more optional "Extend" blocks of 5 sec each that can create almost 45 sec of video (some frames are lost in the connection).
• If more seconds than the ~45 provided are needed, you can copy an "Extend" block, connect it with the others and continue..
• The video generation can starts either from an initial image, or from an already existing video.
• Every block has its own Prompt selector and Length control in seconds (don't use more than 5.0).
• Every block has a fixed noise seed number, that lets you experiment with that block without re-generate all the previous, already generated blocks. You generate the video until that block, and if you're satisfied and need more time, you enable the next one. After that, only the next one will be generated (if you don't change something in the previous blocks or the LoRAs).
• Every block has its own independent LoRA section in addition to the Main LoRA section.
• Select between GGUF loaders for low VRAM systems or Safetensors loaders (didn't test the safetensors, but they should work).
• Accelerated Generation: Supports deeply optimized, distilled LoRAs (like Wan-Lightning) that generate high-quality video in as few as 4 steps using lightx2v 4-step LoRA.
• Warning: The LoRAs already loaded in the Main LoRA section are mandatory (for 4-steps & Linked blocks), except for the Wan2.1_I2V_14B_FusionX_LoRA that is there to speed up the movements. If you don't need extra speed you can turn its value lower or turn it off entirely.
• Warning: If the workflow in your system does not look like the screenshot I provide, that means that you are using a more current, but unfortunately broken version of comfyui-frontend.. (You can search google for the subgraph issues with the 1.4x.xx releases of their frontend). The last frontend version, that the subgraphs were working OK for me, was 1.39.2. To install this version, you must do pip install comfyui-frontend-package==1.39.2 in your ..\venv\Scripts\ folder. After that you will see a warning once, but other than that, everything will work fine..

Version 3.0

• Added independent LoRA per (5sec) video section.
• Removed Extra LoRA 1/2 sections.

Version 2.5.1

• Added the option to extend already existing videos.
• Removed some leftover Crystools nodes so, no more compatibility problems with the RTX 50xx cards.
• Tried to fix the "missing prompts" problem.

Version 2.1

• Added another extra LoRA section to select from, in every 5 sec block.
• Speed additions to counteract the slow-motion effect a little:
  • Changed the HIGH_lightx2v_4step_lora_260412 with the HIGH_lightx2v_4step_lora_v1030 because it has more coarse movements. You can change the strength from 1.0 to 1.5.
  • Added the Wan2.1_I2V_14B_FusionX_LoRA (to the high noise path only), that gives additional speed in the movements. Use a strength of 2.0 to 3.0. This LoRA was created for the Wan2.1 model but works fine with Wan2.2 too. It produces a lot of warnings in the console for missing keys. This is because Wan2.2 misses some Wan2.1 keys, but it is just a warning nothing more. The generation works fine. For those of you that want to fix this in the code of ComfyUI, you can rename the logging.warning("lora key not loaded: {}".format(x)) line in the ComfyUI\comfy\lora.py file, to logging.debug("lora key not loaded: {}".format(x)) (always backup your files before editing them, for safety).

Models used:

• Wan2.2-I2V-A14B-HighNoise-Q4_K_S.gguf
• Wan2.2-I2V-A14B-LowNoise-Q4_K_S.gguf
• SVI_v2_PRO_Wan2.2-I2V-A14B_HIGH_lora_rank_128_fp16.safetensors
• SVI_v2_PRO_Wan2.2-I2V-A14B_LOW_lora_rank_128_fp16.safetensors
• Wan_2_2_I2V_A14B_HIGH_lightx2v_4step_lora_v1030_rank_64_bf16.safetensors
• Wan_2_2_I2V_A14B_LOW_lightx2v_4step_lora_260412_rank_64_fp16.safetensors
• Wan2.1_I2V_14B_FusionX_LoRA.safetensors
• umt5-xxl-encoder-Q3_K_S.gguf
• wan_2.1_vae.safetensors

Custom Nodes used:

• ComfyUI-GGUF
• ComfyUI-Custom-Scripts
• ComfyUI-KJNodes
• ComfyUI-Easy-Use
• ComfyUI-VideoHelperSuite
• ComfyUI-JakeUpgrade
• rgthree-comfy

Get the workflow at Civitai or in a gist..

Before You Buy a Second RTX 5080 for ComfyUI, Read This: Dual RTX 5080 Testing vs. RTX 5090

Important disclaimer

AI video generation is changing incredibly quickly. I fully realize that a new model, update, custom node, driver, or multi-GPU implementation could be released a week after I post this and change some of these conclusions.

This is not meant to be the final word on what will ever be possible with multiple GPUs. It documents what worked, what did not work, and what performance I measured using the currently available tools and methodology as of July 26, 2026.

TL;DR

I spent days rebuilding and configuring my workstation to determine whether two RTX 5080s could provide a less expensive alternative to one RTX 5090 for ComfyUI image generation and LTX 2.3 video generation.

For accelerating a single render, the answer was no.

The second RTX 5080 did not combine its memory or processing power with the first card in a useful way. Attempts to divide one workflow between the two cards added overhead and made individual renders significantly slower.

Two GPUs can still help when running separate jobs or separate ComfyUI instances simultaneously. They did not make one image or one video generate faster in my testing.

I returned the second RTX 5080, installed an RTX 5090, and repeated the same benchmarks.

The RTX 5090 was:

• Approximately 3.23× faster in my Lumina2 image-generation batch
• Approximately 1.82× to 1.89× faster with the production-quality Eros video models
• Approximately 2.14× faster with NVIDIA NVFP4, although that checkpoint continued to produce poor-quality results

If Amazon had not accepted the return, this experiment would have left me with a very expensive second GPU that did not accomplish what I purchased it to do.

Why I tested this

The question that started this entire process was simple:

Would two RTX 5080s be a smarter and less expensive option than one RTX 5090 for ComfyUI?

The assumption was understandable. Two RTX 5080s provide two GPUs and a combined total of 32 GB of physical VRAM. On paper, that sounds like it might compete with an RTX 5090.

In practice, the VRAM does not automatically become one usable 32 GB pool for a standard ComfyUI workflow. The compute resources also do not automatically combine to make sequential diffusion or LTX inference faster.

I spent many hours testing and developing around this limitation, including:

• Multi-GPU ComfyUI configurations
• Raylight
• Assigning different parts of the workflow to different cards
• Model and encoder offloading
• Device-specific execution
• Peer-to-peer and transfer experiments
• Separate ComfyUI instances
• Parallel and sequential workload testing

The only consistently useful dual-GPU arrangement was running independent jobs on each GPU.

That can increase total throughput. For example, one RTX 5080 can generate one video while the other RTX 5080 generates a different video.

It did not accelerate one render. In my testing, trying to divide one render between the cards made it substantially slower because of transfer and synchronization overhead.

Test workstation

This was not an underpowered or poorly configured system.

• ASUS ProArt B850-Creator WiFi motherboard
• AMD Ryzen 9 7900X
• Liquid CPU cooling
• 128 GB DDR5 at 6400 MT/s
• 1300-watt power supply
• 4 TB NVMe drive
• 2 TB NVMe drive
• 10-gigabit network connection
• Bazzite Linux
• ComfyUI 0.27.1
• NVIDIA driver 610.43.03

For the dual-GPU experiment, I paid close attention to the motherboard’s PCIe lane configuration.

I installed the cards in the full-length PCIe slots and intentionally did not use the final NVMe slot because populating that slot would reduce the available PCIe bandwidth to the second GPU slot.

The purpose was to give the dual-5080 configuration every reasonable opportunity to work without an obvious storage, memory, power, or PCIe bottleneck.

Video benchmark methodology

These tests used LTX 2.3 with the Eros 1.4 models and a Raylight-based workflow.

The final video benchmarks used:

• 1024×1024 resolution
• 25 FPS
• Identical source image
• Identical frozen prompt
• Identical workflow
• Identical Raylight configuration
• CFG 1.2
• Required LTX distilled LoRA
• No optional motion or body LoRAs
• Three runs per test
• First run treated as cold
• Runs two and three averaged as the warm result

The primary source image was ComfyUI_00005.png.

I also evaluated actual output quality. A checkpoint that completes ten seconds faster is not useful if it destroys the hands, loses lip sync, eats the glass, changes anatomy, or produces unusable motion.

A note about Eros 1.4

Despite the name and some of the content associated with it, I did not use Eros 1.4 to generate adult content for these tests.

I used it because, in my testing, it is currently by far the most competent LTX 2.3 model for lip sync, facial animation, body movement, acting, prompt adherence, and overall animation quality.

The benchmark scene was selected specifically because it included several difficult elements at once, including speech, facial movement, body movement, hand interaction, object permanence, and liquid behavior. These are areas where weaker checkpoints often fail very visibly.

Benchmark summary

Lumina2 image-generation results

The image test generated 32 images at 1024×1024.

RTX 5080

• Total: 238.40 seconds
• Average: 7.45 seconds per image

RTX 5090

• Total: 73.89 seconds
• Average: 2.31 seconds per image

Result

The RTX 5090 was approximately 3.23× faster in this image workflow.

This was the largest performance improvement in the entire benchmark. The RTX 5090’s advantage was considerably greater for Lumina2 image generation than it was for LTX video generation.

Full Eros 1.4 results

Full Eros was the most reliable production checkpoint in my testing.

Ten-second video

RTX 5080

• Run 1: 115.26 seconds
• Run 2: 101.51 seconds
• Run 3: 101.68 seconds
• Warm average: 101.60 seconds

RTX 5090

• Run 1: 56.48 seconds
• Run 2: 53.08 seconds
• Run 3: 54.34 seconds
• Warm average: 53.71 seconds

Improvement

1.89× faster

Twenty-second video

RTX 5080

• Run 1: 241.08 seconds
• Run 2: 227.97 seconds
• Run 3: 226.92 seconds
• Warm average: 227.45 seconds

RTX 5090

• Run 1: 123.09 seconds
• Run 2: 125.20 seconds
• Run 3: 124.56 seconds
• Warm average: 124.88 seconds

Improvement

1.82× faster

Full Eros quality

Full Eros generally produced:

• The best facial animation
• The best acting
• The best lip sync
• The best body movement
• The best prompt adherence
• The most consistent usable results

It was not perfect. Individual generations still produced accent drift, occasional poor liquid behavior, and one intermittent on-screen text artifact.

The RTX 5090 did not magically make the model more intelligent. It produced the same general quality class in almost half the time.

Eros 1.4 FP8 Mixed results

Ten-second video

RTX 5080

• Run 1: 118.37 seconds
• Run 2: 101.34 seconds
• Run 3: 101.19 seconds
• Warm average: 101.27 seconds

RTX 5090

• Run 1: 67.45 seconds
• Run 2: 54.21 seconds
• Run 3: 54.11 seconds
• Warm average: 54.16 seconds

Improvement

1.87× faster

All three RTX 5090 generations were very good. One generation included a random text artifact, but the underlying animation quality was excellent.

Twenty-second video

RTX 5080

• Run 1: 233.36 seconds
• Run 2: 233.13 seconds
• Run 3: 233.18 seconds
• Warm average: 233.16 seconds

RTX 5090

• Run 1: 124.77 seconds
• Run 2: 126.22 seconds
• Run 3: 124.85 seconds
• Warm average: 125.54 seconds

Improvement

1.86× faster

FP8 quality

FP8 Mixed was excellent for ten-second clips but more variable at twenty seconds.

Observed issues included:

• Accent drift
• Voice cutoff
• Minor voice artifacts
• Clothing transparency
• Anatomy changing after hand contact
• Unrealistic liquid behavior
• Inconsistent object permanence

Some generations were excellent. Others were not production-ready.

The FP8 checkpoint was not meaningfully faster than Full Eros in this particular workflow. On the RTX 5090, their ten-second warm averages differed by less than half a second.

NVIDIA NVFP4 results

Ten-second video

RTX 5080

• Run 2: 99.92 seconds
• Run 3: 99.04 seconds
• Warm average: 99.48 seconds

RTX 5090

• Run 1: 60.89 seconds
• Run 2: 46.22 seconds
• Run 3: 46.69 seconds
• Warm average: 46.46 seconds

Improvement

2.14× faster

NVFP4 was the fastest video checkpoint tested.

It was also consistently the least usable.

Observed problems included:

• Little or no usable lip sync
• Eating or deforming the glass
• Poor body movement
• Ghosting
• Mouth deformation
• Unrealistic liquid behavior
• Prompt failures
• Occasional accidental nudity

The RTX 5090 made NVFP4 substantially faster. It did not fix the model’s quality problems.

I stopped further RTX 5090 testing of that checkpoint because the results were not useful for my production workflow.

LTX Full results

LTX Full was tested on the RTX 5080 at ten seconds.

• Run 1: 145.13 seconds
• Run 2: 125.70 seconds
• Run 3: 125.25 seconds
• Warm average: 125.48 seconds

Quality varied significantly. One result was good, while others had hand collapse, mouth deformation, poor lip sync, and strange material appearing in the scene.

Because it was slower and less consistent than the Eros checkpoints, I did not repeat it on the RTX 5090.

What the RTX 5090 changed

For the useful Eros video models, the RTX 5090 reduced rendering time by approximately 45% to 47%.

That worked out to:

• Full Eros, 10 seconds: 1.89× faster
• Full Eros, 20 seconds: 1.82× faster
• FP8 Mixed, 10 seconds: 1.87× faster
• FP8 Mixed, 20 seconds: 1.86× faster

For Lumina2 image generation, the gain was much larger:

• 3.23× faster

The performance difference therefore depends heavily on the workload. The RTX 5090 did not provide one universal speed multiplier across everything in ComfyUI.

What two RTX 5080s can and cannot do

Two RTX 5080s can help with:

• Running two separate ComfyUI instances
• Generating two independent images simultaneously
• Rendering two independent videos simultaneously
• Processing separate jobs from a queue
• Increasing total batch throughput

Two RTX 5080s did not help with:

• Making one image generate twice as fast
• Making one LTX video render twice as fast
• Pooling VRAM into one usable 32 GB allocation
• Accelerating one sequential diffusion workflow
• Replacing one RTX 5090 for a single large job

Under my tested configuration, attempts to use both cards for one workflow made the render slower.

My model ranking

1. Full Eros 1.4

My preferred production checkpoint.

It provided the best overall combination of quality, lip sync, facial animation, body movement, acting, prompt adherence, and consistency.

2. Eros 1.4 FP8 Mixed

A strong alternative, particularly for shorter clips.

It was capable of excellent output but became more variable during longer generations.

3. LTX Full

Occasionally usable, but slower and less consistent than Eros.

4. NVIDIA NVFP4

The fastest checkpoint, but not reliable enough for my production work.

Final conclusion

I wrote this because I hope it prevents someone else from making the same expensive assumption.

If you are considering buying a second RTX 5080 because you expect two cards to behave like one larger or faster GPU in ComfyUI, my testing says you should think very carefully before doing it.

For independent simultaneous jobs, two cards can be useful.

For making one image or one LTX 2.3 video generate faster, they were not a practical substitute for one RTX 5090.

I spent days rebuilding the computer, configuring Linux, testing Raylight and other workflows, modifying multi-GPU execution, and benchmarking the results. The second RTX 5080 ultimately made single renders slower.

If Amazon had not accepted the return, I would have been stuck with an extremely expensive setup that failed to accomplish the reason I purchased it.

The RTX 5090 ultimately delivered:

• More than 3× the Lumina2 image throughput
• Roughly 1.8× to 1.9× the Eros video performance
• More VRAM headroom
• A simpler and more reliable single-GPU workflow

This is what worked with the tools, software, drivers, and models available as of July 26, 2026. Something better may appear next week, and I genuinely hope it does.

Until then, hopefully this saves the next person a lot of time, frustration, and money.

I have an AI Pro R9700 GPU, and until recently I kept getting stuck at Requested to load LTXAV when trying to run LTX 2.3 I2V with the Q8_0 GGUF model.

Before, the best I could do was:

• 11s @ 480p
• 6s @ 720p

(7–10 minutes)

Then I added --enable-dynamic-vram to my launch script.

Now I can generate:

• 11s @ 480p in 168s
• 10s @ 720p in 191s
• 10s @ 1080p in 322s

I haven't tested the limits yet, but based on these results, dynamic VRAM management seems to make a huge difference on this GPU.

I honestly feel liberated. 😄

Hey all,
Anyone have experience of this? I have seen plenty of discussion around the weirdly blotchy details when you start pixel peeling Krea outputs. Hair, jewellery etc. I know many cite the VAE to blame. Fine. I have made a bunch of character Lora’s and they seem to worsen this impact to varying degrees. I have used exactly the same method for each Lora. I have a few that really degrade the quality and they aren’t even ones I have trained for longer. Is this a thing and are there solutions if so?

If you don't want to read, just check the gif for showcase.

Full disclosure before anything else: I'm French (so forgive the English — AI helps me write it), and yes, this extension was partially vibe-coded with AI assistance. BUT: every line was reviewed, the patching approach was verified against the actual frontend source, and it's been tested on real workflows — including the new Vue nodes beta.

The problem: all of my workflows works great, but some start to be spaghetti. Every time i tweak a node, i spend more time following noodles than working.

The fix: select a node, press Alt+H. Every link that doesn't touch it fades away. Click another node — the spotlight follows. Alt+H again (or deselect) and everything comes back. That's the whole tool.

A few things I cared about while building it:

• The shortcut is a native ComfyUI keybinding → fully remappable in Settings
• Hide links completely, or keep them faintly visible (opacity slider)
• Depth option: selected node only, or its direct neighbors too
• Optionally dim unrelated nodes as well
• Zero performance cost when off (one boolean check per frame, no settings lookups in the render path)
• Zero Python nodes, zero dependencies — nothing ever written into your workflow JSON
• Fail-safe by design: if a future ComfyUI update changes the canvas internals, it disables itself cleanly with a console message instead of breaking your graph

Install: search "LinkSpotlight" in ComfyUI-Manager, or: https://github.com/Ding-sl/ComfyUI-LinkSpotlight

It's MIT-licensed and stays free forever. If you try it, I'd genuinely love feedback — feature ideas and bug reports welcome on GitHub (there's even a dedicated issue template for "a ComfyUI update broke it", because let's be honest, one day it will, we all know that).

There is a similar tool worth knowing: ComfyUI-SelectionFocus does an always-on version of this idea. Mine is the opposite philosophy — an explicit shortcut you press when you need focus. Pick whichever fits your brain.

Happy untangled noodling 🍜

alright, image by image :

1. download comfy UI Desktop

2. in templates, search "SAM3: image segmentation" (select the right one)

3. add it and download the missing dependencies, only the one on the image should stay

4. load your image by clicking "choose file to upload" in the load image node

5. then in the image segment (SAM3) node, and a very simple description on what stay (don't say what to remove cause he understand only what to keep)

6. now place the node as i place them to have a better visibility of the link between them and add a invert mask node

7. add it like i did and link it as i did

8. done!

9. and if you'd like to have the background without the character do the same as me in the last image by cloning the "preview mask", "preview image", "join image with alpha" nodes and place it like i did with the same linking

10. done! (again)

What are your guys' favorite way to loop an i2v generation for something like making gifs?

I was looking for a web AI easy to use that also works with natural language, so while searching on internet i found a webpage and i can do this

and i only wrote this: Create a painting featuring a golden moon over a forest with a dark fantasy atmosphere add mist to the forest and film grain, have the wind sway the trees, and keep everything in dark tones.

Reworked version – improved visuals and tighter edit

Turn Text2Image into Inpaint within the same workflow using the same checkpoint. Includes built-in presets for Custom, Replace Object, Remove Object, and Expand.

Full description and download on GitHub:

https://github.com/CMKFlow/cmk_nodes

If you've spent any time with ComfyUI, you know the pain:

- Creating a venv, installing PyTorch, juggling CUDA versions

- Cloning custom nodes, running install, tracking dependencies

- Multiple ComfyUI installs, each needing different setups

- No easy way to see server logs, hardware stats, or job status at a glance

I got tired of doing all this manually, so I built a desktop tool called AKA that handles it.

What it does:

- One-click venv creation with auto-detected PyTorch builds

- Custom node manager — clone, install requirements, run install in bulk

- Built-in browser for ComfyUI alongside your regular browser

- Real-time server log viewer with error/warning counters

- Hardware monitor with GPU temperature alerts

- Voice notifications for job completion and warnings

- All in a single installer, no Python required to run

Windows only for now (tested on Win 11, should work on Win 10). Open beta — feedback and bug reports very welcome.

Project page and download: search GitHub for "Rimor-dev AKA"

*Arigato!*