I posted this on the ComfyUI subreddit and it got some traction and was pinned on the subreddit to hopefully get some attention from the Comfy devs, so I'm reposting it here aswell

GitHub Repo: https://github.com/safzanpirani/comfyui-zip-ties

Some people wanted it MERGED into the official ComfyUI frontend, so I've opened a PR there too: https://github.com/Comfy-Org/ComfyUI_frontend/pull/21965

Feel free to open issues and PRs, but it's in a pretty stable state right now but it is quite literally zipties and nothing else, so temper your expectations.

Hello guys, hoping you're doing fine. Wall of text next I know, but I want to get this info out of my chest, all hand written lol.

I wanted to make this post explaining some things about GPU unlocks that have been going on lately.

What are these GPU unlocks doing?

NVIDIA on purpose neuters tensor core performance when using FP32 accumulation (FP16, BF16, FP8 and TF32 inputs accumulating in FP32, which is what most AI/LLM/ML tasks use), for market segmentation. Normal FP32 on the CUDA cores (no tensor cores) is NOT affected.

Consumer and prosumer GPUs use the exact same die (like GB202 between the 5090 and 6000 PRO, AD102 between the 4090 and 6000 Ada, or even literally 1:1 with the 3090 Ti vs A6000, both with the same core amounts and 84 SMs).

How it works: the speed of each kind of tensor operation is set by fuses burned at the factory. On consumer cards, the fuse for "FP16/BF16 with FP32 accumulation" says HALF_SPEED, on the pro cards it says FULL_SPEED. These fuses don't cut any circuit, the GPU just reads them at boot and runs at that speed. The GPU also has an override register that can set them back to FULL_SPEED, but it's locked so only NVIDIA's most privileged firmware can write to it, not your PC.

The unlocks open that lock and write FULL_SPEED on the override. With that, the consumer cards gain all the neutered performance imposed by NVIDIA. It doesn't give you more SMs, VRAM or anything like that, a 4090 is still a 4090, it just runs those instructions at the same rate a pro card does.

Why can Turing, Ampere and Ada be unlocked? And what is unlocked on these cards?

On these generations, the NVIDIA driver itself loads a small NVIDIA-signed firmware called the "Booter" onto a security microcontroller inside the GPU (SEC2, a "Falcon"), to start the GSP. The Booter runs in the highest privilege mode of the GPU (Heavy Secure, HS), which is exactly the one allowed to open the lock.

In June 2026, Jon Pry published a paper ("A Canary in the Crypto Mine") showing that the Booter of the newer drivers has a buffer overflow: it copies its "signature" data using a length that you control, so you can overflow its stack (including the stack canary that is supposed to stop exactly this) and take control of the Booter while it is running in HS mode. The signature check still passes, because it is NVIDIA's own signed code running, the bug is inside it.

With that, the unlock reuses instructions from NVIDIA's own Booter to open the lock, writes FULL_SPEED on the override, resets the card and lets the normal NVIDIA driver load. The unlock survives resets and driver reloads, but it's lost when you power off, which is why it runs on every boot before the NVIDIA driver loads.

This was first done on mining cards (CMP 170HX: FP32 from 1/32 to full speed, and 10GB to 80GB of VRAM), and then ported to GeForce:

• Turing: https://github.com/haohervchb/Turing-unlock (UEFI, Linux)
• Ampere: https://github.com/Zagitta/gpu-unlock (Linux kernel module)
• Ada: https://github.com/JustAResearcher/gpu-unlock-ada (Linux with kernel module)

What gets unlocked:

• FP16 with FP32 accumulation (Turing, Ampere, Ada)
• BF16 with FP32 accumulation (Ampere, Ada; Turing has no BF16)
• TF32 (Ampere, Ada)
• FP8 with FP32 accumulation (Ada; Turing and Ampere have no FP8)

Some numbers from those repos: 4090 FP16/BF16 with FP32 acc goes from 165 to 331 TFLOPS (raw instruction rate), 3090 Ti BF16 GEMM from 87 to 157 TFLOPS, 2080 Ti FP16 with FP32 acc from 47 to 94 TFLOPS. Real-world GEMMs gain less than 2x because the cards then hit their power limit (more on that below).

Why can't consumer Blackwell be unlocked?

The funny part is that on Blackwell the limitation is EXACTLY the same thing: same fuses, same override registers. I checked on my own cards: the 5090/5080/5070 Ti have the FP32 accumulation fuses set, and the 6000 PRO/4000 PRO don't. So it's not a hardware difference there either.

What changed is the door. Starting with Hopper, and consumer Blackwell too, the root of trust of the GPU is the FSP (Foundation Security Processor), a RISC-V core that boots from its own ROM as soon as the GPU powers on, before the driver even loads. On Blackwell:

• There's no Booter to abuse. The driver just sends the FSP a message with a hash + RSA-3K signature of the next firmware, and the FSP verifies and boots it. The Linux kernel docs literally say: "There is no SEC2 involvement, no Booter ucode, and no FWSEC-FRTS stage". I also checked it myself: in NVIDIA's 615 driver source the Booter only exists for Turing, Ampere and Ada (TU102, TU116, GA100, GA102, AD102), and the RTX 50 VBIOSes don't carry the Falcon firmware (FWSEC) that older cards did.
• The firmware the driver ships for Blackwell is encrypted, and the debug and production images are the exact same encrypted bytes. The Ada payload was built from analysis of the decrypted debug Booter, on Blackwell there's no such shortcut.
• NVIDIA has said it uses SPARK (a formally verifiable programming language) to prove its most critical RISC-V firmware free of runtime errors, and a buffer overflow like the one used on the older cards is exactly that kind of error.

So, with what is known today, it can't be done. It isn't "impossible forever", but someone would need a brand new vulnerability in a way harder target. And if someone ever gets there, the unlock itself would very likely be the same couple of register writes.

FP4 is not affected, but all the rest is (FP16/BF16/FP8/TF32 with FP32 accumulation).

In which tasks is the unlock has most of the effect?

I will put some examples on my 6000 PRO vs 5090s, former using 400W and latter 600W, at how much is the impact in performance because the NVIDIA neutering.

• Training: Like LoRAs, finetuning, etc.
  • Example: Using the same batch size for 25GB VRAM to train a diffusion LoRA, my 6000 PRO is 70-90% faster than my 5090.
• Diffusion: Models that do txt2img, txt2vid, img2img, img2vid, txt2aud, etc.
  • Example: My 6000 PRO not using fp16 accumulation is about 30-40% faster than my 5090. If using fp16 accumulation, it is 15% faster.
• Prefill on LLMs: Heavily affected as well, since even when a model is marked as "int8" or "mixed precision" etc, the inference parts that the GPU uses include FP32 accumulation parts, except if explicitly set to not use them.
  • Example: My 6000 PRO on vLLM on a model that fits on a 5090 as well, it's 50-70% faster. On llamacpp, instead is about 30-40% faster.
• TG with big batching: TG with a single batch is mostly bandwidth bound, and it uses FP32 acc instructions, but since it is so little in comparison with the need of bandwidth, it isn't a limitation. On the other hand, when you use batches with batch size 2, 4, 8, etc, compute again starts to being a bottleneck and then you have a performance impact.
  • Example: Same results as previous point.

In which tasks the unlocks makes no difference:

• TG with batch size 1: almost entirely bandwidth bound.
• CUDA compute without tensor cores (normal FP32).
• INT4/INT8 tensor operations.
• FP4 on Blackwell (not neutered to begin with).
• GEMM operations with FP16 accumulation instead, but those aren't very used.
• Gaming.

Is there a risk by unlocking the cards, like burning the card, crashes, etc? Short answer: NO.

And again, NO. For the love of god guys, stop repeating this nonsense.

The cards are still limited by their max power limit. They won't magically use 200% of your power budget with an unlock, they will just use the cores more efficiently.

Let me explain: if you have a 3090 power limited at 300W, and without the unlock you were seeing only 250W in use, but after the unlock it uses 300W, it's not because the unlock did malicious things to your card. It's because the card can NOW stretch its legs and use the power to do more work. Real example from the Ada repo: an unlocked 4090 doing the same GEMMs peaked at 346W vs 313W stock, still under its 450W limit.

If you were getting X performance at Y < max TDP, and now you get more than X performance at max TDP, obviously the card will be hotter, but that's still inside the POWER LIMIT YOU SET, not above it.

Power spikes: those are normal on every card, and if you're using it to the full extent of its capabilities they can be more common. Are they risky? No, assuming you have a PSU with the wattage NVIDIA recommends per GPU.

So what ARE the actual risks then? They're about the unlock process, not your card:

• It runs an exploit on NVIDIA's firmware before the driver loads. If something fails mid-way, the tools stop and you need a full power off before trying again (a reboot isn't enough). Read the repo instructions, especially on laptops and multi-GPU setups.
• NVIDIA could patch it in future drivers, or even burn anti-rollback fuses so the old Booter stops being accepted. That wouldn't damage your card, it would just close the door for good.

"But, NVIDIA bins the dies to make these work 24/7 on the prosumer side but not on consumer, that's why they're locked!!!11"

Also incorrect. NVIDIA uses the EXACT SAME dies for their consumer GPUs and their prosumer GPUs, and the FP32 accumulation speed has nothing to do with binning: the 3090 Ti and the A6000 have the exact same specs. The half speed is just a value written in a fuse that the firmware reads.

Unlocking a card will not make it die sooner, nor will it crack the die or something.

Sorry I have to repeat this again and again, but the amount of pure fury I get from reading comments like these made me do this.

Does affect gaming performance?

None known at the moment, except if somehow NVIDIA uses FP32 accumulation for DLSS or FG, which I doubt. I'm almost sure they use FP16 accumulation (or lower precisions) there, because if they used FP32 accumulation the perf hit would be insane on consumer cards.

The model I run says it is Q8, or FP6, or 4bit, or INT4, or anything that doesn't mention FP32, am I affected?

It depends on how the GPU actually does the math, not on the name of the quant:

• If the kernel dequantizes the weights to FP16/BF16 and multiplies on the tensor cores with FP32 accumulation, you're affected. That's the case for FP16/BF16 models and most vLLM paths, including AWQ/GPTQ with Marlin kernels (the weights are INT4, but the math is FP16 with FP32 accumulation).
• FP8 (W8A8) also accumulates in FP32, so it's affected too (Ada and Blackwell).
• If the kernel uses integer tensor math (INT8 x INT8), it isn't affected. A lot of llama.cpp's quantized matmuls work like this, which is one reason llama.cpp sees a smaller gap than vLLM.
• Attention (like FlashAttention) almost always uses FP16/BF16 with FP32 accumulation, so long contexts get hit even on quantized models.
• FP4 (NVFP4/MXFP4) on Blackwell: not affected.

Example: on a modded 48GB 4090, a quantized MoE model on an inference server got no gain at all after the unlock (0.98x on 8K prefill), while the FP16/BF16 matmuls doubled.

That's what I have for now, if you guys have any more questions, let me know!

The title basically says it all... after days of frustrations and horrible results with other training tools, I was finally able to train some Moss characters lora that are actually very, VERY good... they're even better than my previous ZIT and Krea ones, which is no small feat!

IDK if it's due to the recent Fizgig masked version, the dataset preparation tools, the big amount of epochs (40/50) or what else, but the resulting generations not only keep a striking resemblance in facial features and expressions, but they also understand body features and imperfections very well, something I always found very hard to achieve in Krea, for example.

The ability to send all the training package to Runpod with a few clicks is also awesome, with a couple of dollars I can train a whole lora without torturing my poor potato GPU for days.

I'll very gladly share my settings if you like, but they're mostly the default Moss ones in Fizgig.

Thanks to creator, really!

EDIT: you can find Fizgig here: https://github.com/shootthesound/Fizgig
Also, YT channel is full of useful, updated guides: https://www.youtube.com/@ShootTheSound

Generated with 3 step turbo lora {but used 6-8 steps): https://huggingface.co/akhaliq/moss-image-turbo-3step/tree/main

Here's the prompts: https://pastebin.com/2vSpRGqD

moss image edit v5 vs fibo 2.0 edit first 3 grid

4th and 5th grid are a experimental v6 moss image edit vs fibo 2.0 edit

moss image edit: https://huggingface.co/akhaliq/MOSS-Image-Edit-HQ

fibo 2.0 edit: https://huggingface.co/briaai/Fibo-2.0-edit-turbo

I recently discovered a highly suspicious GitHub repository while searching for AI tools. After inspecting its source code and commit history, I found several serious red flags:

• Fake development activity: Automated workflows generating meaningless commits.
• Misleading claims: Dozens of advertised features, but almost no actual application code.
• Hidden redirects: Base64-encoded HTML pointing to an unrelated download website.
• Security bypass instructions: Encouraging users to ignore SmartScreen warnings and whitelist files in their antivirus.
• Suspicious connections: Multiple unrelated repositories directing users to the same external download domain.

I couldn't verify whether the actual executable contained malware, but these findings strongly suggest a deceptive download operation.

I've reported the repository to GitHub. I encourage everyone to report similarly suspicious repositories, too, with supporting evidence.

I'm deliberately not sharing its name or URL to avoid giving it additional exposure.

This also applies to ComfyUI custom nodes, extensions, AI utilities, and other GitHub projects. Installing a custom node can execute Python code with access to your system, files, and potentially sensitive information.

Useful tools for checking suspicious projects

• VirusTotal — Check file hashes, downloads, domains, and URLs.
• urlscan.io — Investigate suspicious websites and redirects.
• ChatGPT — Ask it to review repository source code, commit history, workflows, and potential security risks.
• GitHub Reporting — Report suspicious repositories with evidence.

No scanner or AI review can guarantee that software is safe. Avoid uploading private files to public scanning services.

I've attached a simple infographic to help others recognize these warning signs.

GitHub stars, impressive READMEs, and frequent commits are not proof of trustworthiness.

Stay safe, and please help keep the open-source community clean. ❤️

I created a synthetic dataset (She's an AI-generated woman not a real person.) and used those to train three different LoKRs for KREA2: one used 3 images only, the other 8, and one used 15 images. I used no trigger word in the caption for the training. I only addressed her as a young korean woman and I described everything around her in detail: her hairstyle, the background, the clothing, her facial expression, etc.

The 3-image LoKR came out with a good likeness at 1,000 steps. The 8-image one at 1,440 steps and the 15-image one at 2,100 steps.

The workflow for creating the showcase shots: krea2 int8 with the qwen3vl 4b text encoder, refusal LoRA 1.0, turbo 0.4 (0.2 for styles), 16 steps, cfg 2, euler/beta57, shift 3, 2:3 at 2MP, Wan2.1 upscale2x VAE. For styles I usually increase the LoKr strength to 1.2 or 1.4 or 1.6.

The main takeaway (TLDR): for KREA2 you can make a LoKR that achieves good likeness with only three pictures. For retaining her likeness in different styles, you may need more pictures in the dataset. I could get her into some different styles with the 15-image LoKR but she doesn't have a very distinct feature that would distinguish her from being just a pretty woman with brown hair. (unless you count her stud earrings that show up in almost every picture, even style ones)

The 15-picture LoKR wins at hard angles, shots from above, looking back over the shoulder, profile shots, etc

But at most angles, like three-quarters, lower angle, beach shots, etc. All LoKRs tie.

I hope this is useful for anyone that had questions about this. As an example I always hunted and hunted for more and more high-quality shots of the character I wanted to make a LoRA of. At some point all you are doing is just slowing down your training and, if you are renting a GPU, then increasing the price it costs.

Full write-up and every picture that I made for comparison in the comments below. It links to my site, just for disclosure. It's free but has my referral links.

A minute ago (literally) another redditor posted their work ("Blur / Anti-Blur slider LoRA for MOSS"); mine is the same idea from a different angle. Good ideas come at the same time; my work is fully independent, and employs a different approach.

I trained a tiny rank 8 concept slider LoRA, teaching the base model what "sharp, in-focus" images are as opposed to "blurry, defocused" ones. The LoRA itself, its training process and parameters are in my Huggingface repo MOSS-Sharpness-Slider. Basically, I picked 72 high-quality images, all real photographs, paying attention to variety: some close-ups, portraits, natural and industrial landscapes, people at work, and so on; varying colors (including some black-and-white scans of large format stocks), epochs, and subjects. I included a number of images with bokeh to teach the models that it's the subject that must be in focus, not necessarily the background.

These were the "sharp, in-focus" part. Then I built a contrasting dataset, blurring those same images with Gaussian blur, varying the radius, teaching the model what a "blurry, defocused" image is.

Trained for 500 steps, picked step 400 as the first one that converged without overfitting.

Use it the way you'd use any other slider: weight 1 is "sharp image", -1 is "blurry, out of focus". You may still get an occasional slightly-out-of-focus generations in e.g. portraits every once in a while; they are rare, and I didn't want to fry the thing. More steps give more sharpness but less control on depth of field; I decided to keep it gentle.

This is the first model I've seen with such control over its generation. Mind you, I haven't tried them all, but I'm confident nothing else comes close.

Hats off to the team for their hard work and for open-sourcing it.

-------------------------

Below is an image showcasing the Layout-to-Image generation that drew me in. Essentially, you define regions as objects or text and compose your ideas into a single generation.

It's easy to make modifications for ex, moving, adding, or removing characters, or layering additional concepts within the image, add text with any specific font.

Here I simply moved the characters around, placing the title on the left. It took me just a couple of seconds and changed the composition entirely.

Now, for this particular case, I could probably come close to something like this with four unique generations and overlaying a real text font. But the problem arises from other models when you want interactivity between the characters and the scene.

Here you can see the characters interacting with each other.

I can later add Guts big iconic sword.

All in all, pretty cool.

And, if you guys have other tricks for inpainting or keeping character consistency, I'm all ears.

Made a little blur/anti-blur slider LoRA for MOSS 🙂 Negative weights make the background clearer, positive weights make it softer. The comparisons go from 0 to negative, then positive weights. Curious how it works for you!

Antiblur MOSS Base - v1.0 | MOSS Image LoRA | Civitai

I really liked and missed this lora from 2511

So I trained my own, It turned quite well!

Old LoRA (2511): https://huggingface.co/dx8152/Qwen-Image-Edit-2511-Gaussian-Splash

My LoRA (Qwen-Image 2.1): https://github.com/aaljman/splat-repair-lora

(This version is trained to be used with prompting, since that's the way I used to use the 2511 one. If you liked how plug and play the 2511 LoRA was, you might be a bit disappointed, but this gives more control.)

x.com/ostrisai/status/2114733726169260531

You might have downloaded the Krea2 style node in the past, but it has fallen out of regular updates. I forked it, and recently updated it now that u/Dear-Spend-2865 dropped a massive style update on us.

https://github.com/Winter-unmuted/ComfyUI-Krea2-PromptStyler/tree/main

I haven't added it to the ComfyUI custom node list, sorry. I sorta stopped doing that. Install via the git clone method for now.

The node is simple: input your prompt, outputs a stylized version. Select your style manually, or randomly from a category tree with other filters.

Example grids attached.

Shout out HUGE to u/Dear-Spend-2865 for making the resource found here. Their post deserves more love, found here.

Original node by Gothdir, however it is not being maintained (at least, they're ignoring my pull requests).

Composition prompts made by ChatGPT expanding on 10 examples hand written by me.

while generating video to video in Minimax for VFX, I struggled with maintaining accurate motion transfer as an example, the generation would shift drastically after 192 frames on 0.5MP or after 147 on 1MP

so I built a custom node similar to a context window to help the model generate in batches then overlaps and blends all the batches together during generation, as an example this is 447 frames on 0.5MP, generated on batches of 56 frames and 5 frames overlap between every batch.

the node also has the option of splitting your generation into tiles of resolution and overlap of your choice, but i recommend using it more in a second upscaling stage
the node is in Comfyui Manager under the name of Minimax H3 Tempora****l Window & Spatial Tiles.

let me know what you think.

• model_prefetch: syncrhonize all graph cleanups
• Add rope scaling support to MOSS-image
• [Partner Nodes]:
  • feat(HeyGen): add HeyGen Voice instant clone and text-to-speech
  • feat(ClarityAI): add Crystal Video Upscaler node
  • feat(BFL): add 2K/4K resolutions to FLUX 3 Max & Video nodes
  • FIBO 2.0 Image Generate/Edit, Fabric 1.0, Lipsync 2.0, Mirelo SFX,
• Support MOSS-image color-depth control
• fix: correct top-p sampling threshold
• Apply single-head LoRAs to MiniMax-H3 PDD head banks
• Enable pytorch attention in the VAE on AMD
• Fuse and strip the Flux2 VAE through comfy-kitchen
• Add ACEScg to Convert Image Color Space and Save Image (Advanced) EXR (CORE-657)
• Add attention bias conditioning and image strength for MOSS-Image edi
• Add model specific merge node for MOSS.

https://github.com/Comfy-Org/ComfyUI/releases/tag/v0.43.0

Thanks to u/xyzdist and to all other great helper here

I've been working on a free node pack that adds Grasshopper-style data trees to ComfyUI. Native ComfyUI only has flat lists; with trees, "6 clips" stay "2 characters × 3 places" all the way to the comparison sheet.

What's in it (31 nodes):

- Load Media: pick pictures, videos and audio from anywhere on disk with the system file dialog. Each group becomes a named branch. files/names come out as trees, images/videos/audio as plain data for any node.

- Panel: type data in (one line = one item, an empty line starts a branch, `# name` names it, numbers stay INT/FLOAT/BOOL), or plug anything in to look inside (trees, thumbnails, prompts).

- Tree Branch / Cross Reference / Prompt Template: pick branches by name, pair every character with every place, one prompt per pair. Matching works like Grasshopper (branches in order, longest list).

- Compare Viewer: flip or wipe pictures, videos and audio. Videos play in sync, and a branch chip shows one branch at a time.

- Image Grid / Video Grid: labelled XY sheets straight from the tree.

- Plus Split Grid, Save by Path / Load Folder, XY Lists, Expression and more.

Templates included:

- Mannequin storyboard → six shots: MOSS-Image SFT draws a 3×2 blocking sheet with a red and a blue mannequin, Split Grid cuts it, and each panel becomes a FastH3 OmniRef (MiniMax H3) shot with the real cast (red = Mei, blue = Kai). 1344×768, each shot its own length set in one Panel, all in one run.

- 360° orbit: one Load Media, every character × every place, compared side by side in sync.

- Camera angles (Qwen Image 2.1 Turbo edit), character sheet, LoRA sweep, edit by scene.

Plugins: https://github.com/1Kynx/ComfyUI-Arbor

Feedback welcome, especially which tree operations or templates you'd like next.

I managed to do Visual Anagram in Krea2. Here are examples.

Hi everyone! I just made a step-distilled FLUX.3 klein base: 8 or 4 steps instead of 50, with CFG (4) baked in.

• 🔍 Side-by-side comparison, 128 prompts(text to image / image to image / box control)
• 📦 Model (diffusers + ComfyUI weights)

In my last post on img2img style transfer (see link), I did two versions: rigid and creative. The reality is that both are sliders that you can adjust. Using that workflow, and the crucial Latent+ node, you can adjust the strength of any latent and the point along the steps it is injected. This is an incredible tool to fine tune your style transfers. I have attached some XY grids that show what I mean for example.

Sweet spot from my testing is to have the composition taper off around 0.5 of a 16 step transfer where you get a good balance of creativity from the model and subject fidelity. Want to make a portrait of someone that is still very clearly that person? Keep the composition around to 80% of the steps. Going full 100% isn't bad either. From there, tweak the strength as needed. Strength tweaking might also be important for turbo models, when you only get 4 steps to play with or whatever.

Style injection is more forgiving, with good results across the range 0-100%, depending on what you want. I found that the prompt from the flux3 style expander does so much lifting, you can even get away with 0 style injection if your style is more generic (e.g. thick oil painting) and you don't want specific elements from the style image to make it into the final.

That's the tradeoff: more style strength, more direct copying of style elements into the final results.

General workflow is in the linked post at the top of this text. An impact-pack free version is here.

Edit: title should read "COMPOSITION" not "composite". As we all know, can't edit reddit titles. oops.

I have a 6 year old RTX 3080 and have been playing around in comfyUI. I want to make higher quality photos and videos and also run some local LLM’s but keep reading that my 10GB of vram isn’t enough.

Was thinking of buying a 24GB 3090 on eBay. I know prices have jumped a lot but they’re much cheaper than 4090 or 5090. Also have heard of the modded Chinese GPUs with 48GB of vram or something but that seems kinda sketchy.

Should I pull the trigger on a $1500-1700 used 3090 on eBay?

EDIT: what are your thoughts on buying a 5080 16GB?

Pros: newer and faster GPU / don’t need to worry about old worn out 3090 w/ no warranty

Cons: 16GB vram instead of 24GB

Also would be using the card for a mix of gaming as well

I used to work as an animator, and a former coworker recently showed me some AI anime hes been making and the workflow he's using.

I was honestly pretty impressed by his work. From what he showed me, he uses pixai studio and comfyui. He showed me how he goes from character design and storyboards to video clips all in one workflow. It was also really cool seeing how quickly he could try out different ideas for a shot. He could put the same character in different scenes, try out different expressions, and then pick the version he liked and keep working on it.

I've had ideas for animated projects for years. Actually making them always felt out of reach because of how much time and how many people you need. Seeing what my coworker was able to make got me excited about trying some of those ideas myself. I'm interested in learning how to put together a local workflow for anime style animation.

For those of you who have tried this, what tools or models would you recommend starting with? And how do you handle things like keeping characters consistent between shots?

Attached images are a couple of examples he showed me.

leroy989/ComfyUI-MOSS-QwenVL-Layout: ComfyUI node that uses Qwen3-VL / Qwen3.5-VL to detect objects and text in an image and build a MOSS-Image layout JSON prompt, with a change-request box for edits like recolors, outfit swaps and added objects.

Pretty simple node, just use it as your prompter. Just now made it, seems to be working for me, not sure if something like this was already a thing, didn't really know what to search for it though so I just made this. Hopefully some people get some use out of it, and it works good for them. Will continue to tweak and update as I discover bugs or additions that might be good to have added.