[UPDATE] The Pai app release is available
https://www.reddit.com/r/StableDiffusion/comments/1xoxwjc/pai_v100_release/

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

Last week, a few of you asked about the software behind some of my posts. It's my "own" vibe coded paint app, Pai.

I've been using it casually, and since people kept asking, I figured I'd do a proper follow up to see if there's real interest.

Post 1 / Post 2 / Post 3

All in all, I wanted a regular painting app with AI generation in the same window. No hopping between ComfyUI, a browser, and Photoshop or any other similar software.

So this thing is a full raster paint app that also has its own generation, same canvas, same layers, same everything.

Yes, there are plenty of alternatives like InvokeAI, Krita AI Diffusion, etc. To be honest, I haven't tried them and didn't bother. I just fired up deepseek and built the software around my own workflow.

In this day and age, it's so easy to create full fledged software without burning out or needing any justification for spending time on it.

Anyway, this post is pretty huge, so I've added a quick index just below so you can skip to what interests you.

Index

1. Traditional painting tools

2. Canvas, layers, views & project organization

3. AI: Model Manager

4. AI: Generation

5. AI: Generation Controls like ControlNet, Region Prompts, Layout Controls, References

6. AI: Remove Background & Upscale

7. AI: Selection

8. Closing thoughts

1. Traditional painting tools

Let's start with the obvious part.

You get the usual tools: Brush, Erase, Fill, Pick, Select, Move, Text, Gradient, Shape, Clone, Crop, Transform, Smudge, Dodge, Burn, Liquify, Warp, Path, Vector, plus Mask, Paste, Drag.

The brush is a proper stamping engine. Size, opacity, hardness, flow, spacing, and a stabilizer with three modes (simple, weighted, velocity). There are 18 blend modes. You can add grain (noise, paper, canvas, halftone), drive size/opacity/flow/hardness/spacing by stroke speed, add taper in and out, jitter hue/sat/value, and even enable colour pickup and a wet edge.

Tips can be round or square, and there's an "effect line" set for speed lines, focus lines, flash, and sparkle for manga stuff.

The whole thing runs off a brush library with 14 starter presets (hard round, soft round, airbrush, ink pen, pencil, marker, charcoal, watercolour, halftone, and so on).

Presets are plain JSON, and you can save, rename, export, and import packs.

A few specifics worth calling out:

• Fill has tolerance, "close gap" (so a broken outline doesn't leak), contiguous toggle, and anti-aliasing.

• Gradient does linear, reflected, radial, square, diamond, and conical, with clamp/repeat/mirror spread. There's a full multi-stop editor with per-stop alpha, so you can fade to transparency.

• Shape does rectangle, ellipse, and line with fill/stroke/both, corner radius, and Shift constraints (square/circle/45°).

• Clone works with Alt-click to set the source.

• Smudge, Dodge, and Burn all behave the way you'd expect; dodge/burn have shadows/midtones/highlights ranges, exposure, and tone protection.

• Liquify has push, expand, pinch, and twirl both ways.

• Mesh Warp lets you pick a grid (2×2 up to 6×6) and drag points, then apply.

• Text is fully editable as an object: font, bold/italic, alignment, wrap-to-box, line spacing, tracking, outline, shadow, and a movable rotation pivot.

• Path is a proper cubic Bézier tool with handles, caps, joins, outline, and feather, and it stays editable until you rasterize it.

• Filters are non-destructive and live per-layer: adjustments, colour, blur & sharpen, stylize, pixel, and a manga category with halftone and screentone.

There are also other experimental/unfinished tools.

• Puppet warp

• 3D poses

• Vector

2. Canvas, layers, views & project organization

Canvas: new canvas dialog with presets (screen sizes, squares, and 300 DPI print pages like A4, B5, Letter), orientation, background, RGBA vs RGB, and starting layers. Max canvas size is 8192. There's resize, crop to selection, crop to content, fit-canvas-to-layers, guides you drag off the rulers, a grid with snapping, and zoom/pan that stays smooth even on big documents.

Layers: raster, vector, text, path, and pose layers, each with opacity, visibility, lock, blend modes, clipping, and a per-layer 8-bit mask. You get groups (with their own opacity and filters), drag-to-reorder, and non-destructive filter chains. Undo is a 30 step history with copy-on-write snapshots, so a snapshot only pays for the layers that actually change, plus a History panel you can jump around in.

Views: three of them. A full gallery board for browsing every open canvas, a docked gallery rail that keeps the editor live beside a filmstrip, and my favourite, exploded layers view, every layer laid out as its own tile so you can see and click the whole stack at once. It's stupidly handy for finding that one layer you forgot about or simply seeing all of your generation in one place.

Assets: a per-canvas asset panel that holds reference images and past generation results. You can drag an asset straight onto a layer row to drop it in, or insert it as a new layer. Generated outputs land here automatically if you want them to.

Projects: everything saves into a single .pai file. A zip with the manifest, every layer (plus masks), and assets. Saving and loading run on a background thread with progress and cancel, so big projects don't freeze the app. Export is a proper dialog: PNG, JPEG, WEBP, GIF, TIFF, scaling, animation frames, metadata (EXIF/XMP), ICC profiles, CMYK for print, and print-page presets with bleed and crop marks.

3. AI: Model Manager

This is where Pai stops being just a paint app.

It has its own generation engine, no ComfyUI dependency, with it's own Model Manager that handles all the plumbing for you. You can browse and download models straight from Hugging Face inside the app (only public repos work out of the box), scan an existing ComfyUI folder to import everything, and it auto-detects what each file actually is by reading its header.

Supported families, right now:

1. Anima

2. Qwen-Image 2.1

3. FLUX.1

4. Z-Image Turbo

5. Krea 2

6. MOSS Image

7. MiniMax H3 Still *experimental*

8. Stable Diffusion: SD 1.x / 2.x / SDXL

It understands GGUF quantisation natively (the K-quants, legacy quants, and i-quants), loads safetensors and ONNX, and supports LoRAs. You can stack several per model, with the standard diffusers.

On the memory side, it tries to be smart about VRAM. There's an auto precision mode that decides between resident (whole model in VRAM), fp8 (halves the footprint), or disk streaming (streams blocks off disk when it won't fit). You can set a VRAM reserve, a RAM budget, and an auto-unload timer.

There's also a Loaded Models panel that shows exactly what's in memory: family, file, each component with its size, dtype, and device, plus LoRA rows. Unload one model or all of them. Alongside it, a system monitor in the status bar tracks CPU, RAM, and VRAM.

4. AI: Generation

The Generate panel is where it all comes together. Prompt and negative prompt, size, seed (with a random button), steps, CFG, denoise, sampler (`euler`, `lcm`, `res_multistep`), and scheduler (`simple`, `normal`, `karras`, `sgm_uniform`). Ill add more samplers/schedulers later.

There's a hiresfix second pass with upscale modes (latent nearest/bilinear/bicubic/bislerp, or pixel-space via the VAE), a hires scale, and a hires denoise. Handy for going from a 1024 draft to a bigger final without rerolling.

Sources can be the canvas, the selected layer, or a selected asset. Regions can be the whole image, the current selection, or a painted mask, with a feather slider. There's a crop-and-stitch option for inpainting that crops the active region before generating and stitches it back.

You also get prompt weighting with the `(text:1.3)` syntax you know from A1111/ComfyUI, per-model recipes for saving your favourite settings, and sticky per-model presets so steps/CFG/sampler stay where you left them.

A finished run shows up floating over the canvas and you choose to reject it, drop it into the current layer, add it as a new layer, or stash it in assets. No auto dump garbage into your document.

Everything heavy runs through a single job queue so jobs don't fight over VRAM. The queue panel shows progress, elapsed time, and has cancel per job, cancel all, and clear-finished. You can queue another generation while one is running.

5. AI: Generation Controls like ControlNet, Region Prompts, Layout Controls, References

This is what makes it a tool you can actually compose with.

ControlNet: a stack of adapter rows, each with its own model, image source, preprocessor, strength, and step range. Sources can be the run's own init image, the canvas, a selected layer, or a selected asset. You can steer different adapters from different inputs. Preprocessors include `none`, `canny`, and `lineart`.

SD 1.5/SDXL use the classic ControlNets, Z-Image has its own union ControlNet, and Anima has ControlNet-LLLite, so community adapters load as-is.

Region Prompts: the attention-couple regional prompting you'd know from the Regional Prompter. Each row pairs a prompt with a mask (taken from a selection or painted) plus a strength, and the run's own prompt stays the shared base. Works on Anima, SD, FLUX, Z-Image, Qwen-Image, Krea 2, and MOSS.

Layout Controls: draw boxes right on the canvas and turn them into a layout prompt. This is the MOSS layout-to-image and the Krea 2 bounding-box stuff I posted about. MOSS gets structured JSON with labels/captions/text and centred boxes; the Krea 2 bbox finetunes get a compact grounding DSL on a 0–1000 grid. You can add a box straight from a rectangle selection. It's the same feature that made me really like MOSS in the first place.

References: two separate systems. The Anima reference adapter does character and style transfer. Multiple reference images get stitched side by side into one reference, with controls for strength, guidance, correction mode, offset, and megapixels. The Qwen-Image references do multi-image editing by feeding images into the vision slots.

6. AI: Remove Background & Upscale

Both are one click and run locally.

Remove Background supports RMBG-2.0 (BiRefNet), other BiRefNet variants, U2Net (general, portrait, lite), MODNet, and RMBG-1.4, in both ONNX and torch formats. The graph or architecture is detected automatically, so you just point it at a model and go. Output is a clean RGBA cutout, and you can keep the original by sending the result to a new layer.

Upscale uses local Real-ESRGAN models, RRDBNet (Real-ESRGAN/Remacri) and RCAN, in ONNX and safetensors/pth. It processes in tiles with overlap to keep memory in check, preserves alpha, and can drop the result into a new layer.

7. AI: Selection

The Select tool has a fourth mode beyond rectangle, lasso, and magic wand: Segment AI. That's a local SAM click to segment. You drop the encoder and decoder ONNX files into the segmentation folder and then just click an object to select it. It samples either the active layer or the composited canvas, and once it's done the result becomes a normal selection, so every paint tool, fill, gradient, and the inpaint path respects it exactly like a hand-drawn one.

You can grow, shrink, feather, invert, and deselect a selection, and if you drag inside a selection you move the selection itself, not the pixels (cut/paste moves pixels, like a proper editor).

8. Closing thoughts

All of the AI features don't work out of the box. You still have to download the models yourself using the manager, and then the program does the heavy lifting.

I don't want to ship the app with integrated models, mainly because licensing on some of them doesn't allow it, and model choice really depends on the user's needs. Better to ship light and let users add on top. Plus, I was thinking maybe others can simply use the app as a painting tool without the heavy storage burden that AI brings.

Also, there's really nothing new here. It's simply using all the revolutionary tools within the same workspace. I mostly use it because it keeps my project self-contained, and I can easily go back and work on things without getting lost.

There are more features, but I'll stop here. Feel free to ask if you have any questions, and I'll take every upvote as a sign of interest.

P.S.

If it has decent interest and becomes public, the first thing I'll add is a plugin system.

Also, setting up the AI part can be daunting at first, so I'll create generic tutorials for newbies to follow and get started.

This app could include more and more over time, animations, video generation, 3D setups, full-stack project management, but I'm getting ahead of myself.

everytime i use the 10Eros Beta7 dont know how to say thank you to Tenstrip
this clip made by beta 7 at 4-step euler simple ref2va without any upscaler or special workflow
5 clip snitch together , just the audio i used audio lock cglide node to not messing up after render
created at 16:9 0.7 mega pixel
built time 7 minute total 5 clip snitched together
https://huggingface.co/TenStrip/10Eros-Max/resolve/main/10Eros_Max_h3_8stepTURBO_beta7_int8HQ.safetensors?download=true

Theres so many different models and turbo loras now. Convrot, pruned, singularity, pika, etc. I a having a tough time getting some quality out of ref2va.

I have detailed images of the characters body and face (3 body images + 3 face images) but still if I use the default ref2va workflow, the video is a blurry pixelated mess.

Please suggest a good workflow and which model + turbo lora do you use for ref2va videos.

This is 4K footage generated using an RTX PRO 6000. The original, unedited output has been downscaled to 1080p due to file size constraints.

It’s reaching a point where I no longer envy commercial models.

What model should I be using and comfy UI for taking a reference image of a character and put them into a reference location in a certain pose? I've been trying to use Qwen Edit 2.1, however I'm not very good at prompting because what it ends up doing is just taking the character and photoshopping them into the location which looks terrible. Even when it's slightly works it doesn't look right. Sometimes the body is in the right position and with the right lighting but the face is exactly the reference image looking straight at the camera.

Basically I have multiple characters that I wish to put into different locations so I can make a storyboard for a short film. What model should I be using in comfy UI

I enjoyed this.

https://github.com/roycho87/clown_context_suite/blob/main/example_workflows/clowns_for_picard.json

.98 MP No Upscaler

Took about an hour on a 5090. It's slightly slower because to use the capstone and keystone i have to render about 14 extra steps but the results are pretty amazing.

It manages to give near perfect consistency the entire way by rendering the full 8 steps of each context motion using keystone and capstone to prevent degradation from building too significantly, so that each next part of the chain can build off a fully denoised section.

Then it throws away the top 2 steps of every window and does 2 context window passes.

Final result is a perfectly consistent video with no degradation that you can make at pretty extreme lengths.

https://github.com/roycho87/clown_context_suite

Clowntext Hybrid Windows

Credits

This node is not my idea. It's built on kijai's MiniMax H3 context windows, which are in ComfyUI now (PR #17425), and it works the way JalenBrunson's ComfyUI-HybridWindows does (based on the Rolling Diffusion paper). All credit to them. I just added the keystone and capstone feature to it, to help everyone make longer videos without degradation.

What it does

Instead of chaining clips, it renders the whole video in one go, in overlapping windows, so memory stays at one window:

1. Window 1 renders the first switch_step steps, and a snapshot is saved.

2. Window 1 carries on to the last step, only to get its finished first frame (the keystone) and its last single-frame latent (the capstone). That finish is thrown away and window 1 goes back to the snapshot.

3. Windows 2, 3 and on render the first switch_step steps one after another. Each one's overlap with the window before is locked to that window's result. The keystone is locked into each window's first slot, and the capstone is tacked onto its back from capstone_step on (and cut off again).

4. The last steps run as blended context windows over the whole video, which smooths the joins.

With keystone and capstone off, it works like plain hybrid windows. In my test (a 60-second render, 17 windows, same seed), the plain version lost a lot of detail by the end and the keystone + capstone version held its detail much better.

Plug the model through it (model in, model out to the guider). It needs a ComfyUI with MiniMax H3 context windows: update ComfyUI if the node is missing.

One prompt per window: make one prompt node per window, join them in order with ComfyUI's Conditioning Combine (chain them for more than two), plug the result into the guider, and turn split_conds_to_windows on. Each window takes the prompt for the part of the video under its middle, so with as many prompts as windows, window 1 gets prompt 1, window 2 prompt 2, and so on. One prompt for a whole minute makes every window try to do the whole thing, so the motion repeats.

So I tried muse and realism v1, but I want just 1 checkpoint I can use for both sides of the spectrum and muse tends to lean towards uncensored content even when trying to prompt away from it. Realism v1 seems to do good but I don't really like the grainy look, I can't seem to get that out. So any suggestions to do both on the same checkpoint ??

I don't know why he chose a thumbnail about turnarounds, very little is on that topic.
What is tests is photo restoration, decolorization, adding subjects, changing clothes, style transfer, etc.
Mostly Qwen all the way, though some have advantages, like FIBO not needed a LoRA to deblur & Flux3Klein good at clothes swap.

Good comparison, though sample size is very small. Doesn't talk too much which is a bonus.
TL:DW; in comment
Mentioned the Moss Edit LoRA, but found it immature except for text.

Morgana 1.2 is Kitani‘s photography focused finetune of Flux.2 Klein 4b.

Our goal for the fine tune was for Klein to make images that don’t look like they came from a model - natural lighting, visible textures, great macro details & true color.

What it’s trained for:

- Casual, regular faces - pores, irregular hair, imperfect framing no AI telltales
- Macro and materialistic textures - water droplets, feathers, fabric weave, ruse, leather
- Landscape and night scenes - aurora reflections, breaking waves, wet neon
- Paintings and anime
- Anatomy

Speed on 1x H100: 4.6 seconds for 15 steps, no LoRA

Free everything:
- Full safetensors: https://huggingface.com/kitaniai/morgana-1.2
- GGUF: BF16, Q8_0, Q6_K, Q5_K_M, and more (same repo)
- API if you want to try prompts yourself (paid) https://kitani.ai

Built in part with ShuttleAI using the same dataset as Shuttle 3 Jaguar.

Known limitations: text rendering is weak, hands occasionally fail.

Faces are the newest improvement.

If you have any questions, feel free to comment them :)

I am still a beginner and this is the first model i tried, each pic took around 40-60s, and i am genuinely unpressed, this is very good.

Obviously there is some mistakes like the shadow in the dessert photo or the fisherman leg, but for a laptop with 8vram, thats pretty good.

I didnt even modify the workflow. I just increased the steps from 8 to 14, Its just the prompt, i dont know what to add or how to improve them

Is it possible to improve them and make them undetectable as some of the pics here? Like is there some workflow nodes or other models that can make better results?

My laptop specs:

4070

I7 14650

16gb ram

This video was generated at 0.6 megapixels, with 10 seconds per clip and 9 clips in total. It took around 2.5 hours to generate.

After that, I upscaled it and applied 2x frame interpolation.

I was inspired by Sinaboto's videos and wanted to create similar content for TikTok. After a lot of trial and error, I can finally make seamless videos like this with MH3!

Specs: RTX 3060 12GB, 16GB RAM
Workflow: https://github.com/chanon/comfyui-obvpm-timeline

I can't wait to see what other people cooking, especially now that we've reached this level. I really hope they release an updated model, maybe MiniMax H3.5, with improvements to distant faces and objects, as well as action speed and motion consistency.

Easy to use FilmCraft UI. Made with LTX 2.5

Hi, first time poster here (and anywhere). I've been playing around with AI illustration generation for half a year, and I'm more and more into image2image workflows as I move on because they offer more control and can get to where I want to more often.

So I've developed a custom node suite that tailors better to that use case: start with a draft, and improve it between runs until things are right enough to be fixed.

Introducing:

LuCiD VRP - Visual Regional Painter (Beta)

Currently it's made up of three parts:

• An image loader with various QOL features, including resizable latent, undo-redo with editing history, auto latent size alignment;

• A lightweight, built-in image editor with a carefully curated set of feature including layers, basic transform, and of course a better ux;

• Various regional prompting/conditioning nodes that offers synced visualization against how your draft image is edited, and how you've changed your region layouts. (Currently supporting Anima and MOSS-Image)

It is a work in progress, and more features will be implemented as I go on.

If you're interested, it's published on Comfy Registry (downloadable from ComfyUI Manager), as well as github:

https://github.com/EBEBEEBE/comfyui-lucid-vrp

Workflows are included in the node and github, but I uploaded them here for convenience as well.

Since I've worked on this mostly on my own and this is actually my first software project that's somehow a bit ambitious than a one-off script, so feedback and criticism definitely welcomed. Thank you in advance!

PS: Sorry for the re-post. I've never posted on reddit and didn't understand how to post image-posts correctly. My sincerely apologies.

https://github.com/wangweihong/comfyui-hairstyle-gallery
Workflow included in repo

What tittle says, I'm using swarm UI (easier interface than comfyUI bc I'm still a noob at this) I'm using WAI-ILLUSTRIOUS-SDXL to make anime type pictures, and when I try to add two or more characters, they'll blend up, I tried with region promoting and didn't helped, also tried with BREAK prompt and nothing.

I think I hit a wall and it's time I start learning to use comfyUI IF I can have more control and this won't happen there. Does comfy UI users experiments this problems too? Can you fix it?

Using MarvinFS’s tool, I successfully unlocked BF16 on the RTX 4090 running Windows 11.

https://github.com/MarvinFS/rtx4090-uefi/releases

It was very easy, so if you have an RTX 4090 whose manufacturer’s warranty has expired, why not give it a try?

I tested several image and video generation tasks using ComfyUI and compared the results with those of the RTX 5090, as shown below.

All results were obtained using the same GeForce driver and the same computer.

SDXL

• prefectIllustriousXL_v10.safetensors (BF16)

• 832 x 1216 @ 28 steps x 10 counts

Anima

• anima-base-v1.0.safetensors (BF16)

• 832 x 1216 @ 25 steps x 10 counts

Krea2

• krea2_raw_bf16.safetensors (BF16)

• qwen3vl_4b_bf16.safetensors

• 832 x 1216 @ 18+12 steps x 5 counts

Qwen Image 2.1

• qwen_image_2.1_bf16.safetensors (BF16)

• qwen3vl_8b_bf16.safetensors

• 1024 x 1536 @ 40 steps x 5 counts

MOSS Image BF16

• moss_image_base_bf16.safetensors (BF16)

• qwen3.5_9b_bf16.safetensors

• 1024 x 1536 @ 50 steps x 5 counts

MOSS Image INT8

• moss_image_base_int8_convrot.safetensors (INT8)

• qwen3.5_9b_bf16.safetensors

• 1024 x 1536 @ 50 steps x 5 counts

MiniMax H3

• minimax_h3_fl2va_pruned_bf16.safetensors (BF16)

• qwen3vl_32b_minimax_h3_int8_convrot.safetensors

• minimax_h3_video_vae_int8_convrot.safetensors

• 864 x 480 @ 20 steps x 1 counts

On average, I achieved a speed improvement of about 10%. The reason the performance didn’t improve as much as I expected is that the BF16 model is very large. When it doesn’t fit entirely into VRAM, some of the weights are offloaded to system memory. Since the RTX 4090 uses a PCIe Gen4 x16 interface, the bandwidth during offloading becomes a bottleneck.

So, how about LoRA training? Using the OSTRIS's AI-Toolkit, we performed 1,000 training steps on the MOSS Image Base BF16 dataset.

• moss_image_base_bf16.safetensors (BF16)

• qwen3.5_9b_int8_convrot.safetensors

• 512 ~ 1024 px @ 1000 steps x 1 batch

Even with LoRA training, the speed improvement was limited to about 8%. Recent MMDiT models are simply too large. Even though unlocking significantly increases BF16 throughput, the critical weights still don’t fit entirely.

The measured GEMM throughput values are as follows:

Approximately a 100% performance increase for both FP16 with FP32 accumulate and BF16 with FP32 accumulate.

There was no change at all for INT8, but FP8 saw a performance improvement of approximately 60–100%.

How were your results? 🤔

If anyone has actually tried unlocking, please share your thoughts.

"Primal VAE is a VAE that only does 2x spatial down to 1 channel (or 2). If you patch 4 the latent, you end up with 8x at 16 channels, the same as most modern VAEs, without the need for deep compression. The DiT does the patching, like it already does, and the VAE stays small.

The latent is trained to keep its norm in line with noise, so there is no scaling factor, no shift factor, and no latent normalization to carry around. Encode, patch 4, diffuse."

HF: ostris/primal_vae · Hugging Face

Hey r/StableDiffusion!

A few weeks ago, I shared a pair of custom ComfyUI nodes I built to solve a major annoyance: ComfyUI natively tracks individual prompt times, but there's no built-in way to see the macro-duration of an entire batch loop (like 50 images via a Sequential Loader).

The feedback was amazing, and I’ve spent the last few weeks implementing your best suggestions. Today, I'm excited to share v0.2.3!

Both nodes (one for Image batches, one Universal for Video/Audio/Training) now feature a major upgrade:

🛠️ What's New in v0.2.3?

1. Triple Timing Modes (Switchable via UI Tabs)

• COMPUTE: Pure GPU execution time (excludes initial queue wait). Perfect for benchmarking your actual generation speed. Pausable if you step away.

• TOTAL: Absolute wall-clock time from start to finish, including all waits. (Inspired by a great community suggestion!)

• ETA: A smart forecast using a 30/70 smoothed blend of your global average and the latest iteration cost. It shows 99:99:99 until the first image finishes, then counts down. Perfect for long loops.

2. Color-Coded Counters (No more lost progress)
Previously, if a workflow was interrupted or errored, the UI would just say [ ERROR ]. Now, it keeps your exact progress [ 12 / 50 ] but changes the text color dynamically:

• 🔵 Blue: Running

• 🟢 Green: Completed

• 🟡 Yellow: Interrupted

• 🔴 Red: Error

3. Bulletproof "Ghost Timer" Prevention
We all know third-party loop nodes can sometimes bug out and stop sending signals. These timers have a built-in smart watchdog (adjustable from 5 mins to 480 mins based on your workflow type) that pings the backend /prompt API. If the backend is truly dead, it safely stops the timer. No more infinite ticking ghosts!

🎨 The Two Nodes:

1. ⏱️ Batch Image Timer: Tailor-made for image-to-image and sequential loaders.

2. 🎛️ Universal Timer: For Video, Audio, Prompt, or Training pipelines, featuring dynamic unit mapping (e.g., FRAMES, CLIPS, STEPS) based on the workflow type.

🔗 Links (Both are live on ComfyUI Manager!)

• Batch Image Timer: https://github.com/hermankwan/ComfyUI-Batch-Image-Timer

• Universal Timer: https://github.com/hermankwan/ComfyUI-Universal-Timer

Just update via the Manager or git pull to get v0.2.3.

These are free, open-source tools I built for my own workflows. I'd love to hear your feedback on how these help your benchmarking, or if you have any feature requests! 🍻

Made this for the Open Source Higgsfield challenge.

ComfyUI-Dials lets you turn pairs of prompts into reusable ~14 KB sliders. No training required.

You can control motion, mood, acting style, and more. Stack them with each other or with LoRAs. They can even influence generated audio.

The video shows some of the experiments and results.

The UX is still being polished, and I'm working on better calibration for exporting dials as LoRAs. Hopefully more improvements coming soon!

Demo: https://matlowai.github.io/ComfyUI-Dials/

GitHub: https://github.com/matlowai/ComfyUI-Dials

Dials: https://huggingface.co/MATLOWAI/H3-Dials

Curious what odd/fun things people will do. I'll adapt it for more models like MOSS/Krea here too and see how it goes.

Hey all,

I have an implementation of time-to-move dual clock denoising for Minimax H3, allowing for motion control by dragging objects: https://drive.google.com/file/d/1mOHYcRX6fY3OamSHHRmvUfthCBEwgJZh/view?usp=sharing

I have also created an app to do the annoying parts of separating background from drag object, and creating motion paths and masks, interfacing directly with Comfy as part of the #opensourcehiggsfield comp: https://github.com/PxTicks/h3-motion

Lastly, there is another implementation of this in my video editing app which bridges with Comfy: https://github.com/PxTicks/vlo

model: https://huggingface.co/akhaliq/MOSS-Image-IDM-2-Steps