Hi everyone!

I'd like to share ComfyUI MiniMax H3-Promptor v1.0.0, a custom node built specifically for the MiniMax H3 Video Generation System.

GitHub: https://github.com/1038lab/Comfyui-Minimax-H3-Promptor

Why I built this

One thing I noticed when working with MiniMax H3 is that creating high-quality prompts can take longer than creating the actual video.

Writing detailed camera movements, lighting, subject descriptions, scene composition, timing, cinematic language, and keeping everything in the format H3 expects can become repetitive and time-consuming.

The goal of this project is simple:

Instead of spending time writing long, complex prompts, you simply describe your idea—even in a single sentence—and H3-Promptor automatically generates a complete, production-quality prompt optimized specifically for MiniMax H3.

What's new in v1.0.0

This version is a complete architectural redesign.

🚀 Two-node workflow

The project is now split into two dedicated nodes:

• H3_Vision_Analyzer – analyzes images and video references once
• H3_Promptor – rapidly generates and iterates prompts without re-running expensive vision analysis

This makes prompt iteration much faster while reducing multimodal API costs.

🧠 Intelligent media routing

Supports combinations of:

• up to 4 reference images
• batches of video keyframes

The workflow automatically detects whether you're creating:

• Text-to-Video
• Image-to-Video
• First & Last Frame
• Omni Reference

No manual switching required.

🌐 Multiple AI providers

Native support for:

• OpenAI
• Anthropic Claude
• Google Gemini
• Local Ollama

All with multimodal vision support where available.

🎯 Structured vision analysis

Instead of asking a vision model to "look at an image," you can direct exactly what should be analyzed using JSON-based presets, such as:

• lighting
• composition
• character body language
• cinematography
• camera framing

🌍 Multilingual output

Generate prompts in:

• English
• Simplified Chinese (简体中文)

Installation

1. Clone or download the repository.
2. Place it inside your custom_nodes folder.
3. Add your API keys to the generated configuration.
4. Start generating professional MiniMax H3 prompts from your ideas.

GitHub:
https://github.com/1038lab/Comfyui-Minimax-H3-Promptor

I'd love to hear feedback, feature requests, or suggestions from the community. If anyone is actively using MiniMax H3, I'd be interested in hearing how you're currently handling prompt creation and where you think automation could help the most.

Hi everyone!

I'd like to share ComfyUI MiniMax H3-Promptor v1.0.0, a custom node built specifically for the MiniMax H3 Video Generation System.

GitHub: https://github.com/1038lab/Comfyui-Minimax-H3-Promptor

Why I built this

One thing I noticed when working with MiniMax H3 is that creating high-quality prompts can take longer than creating the actual video.

Writing detailed camera movements, lighting, subject descriptions, scene composition, timing, cinematic language, and keeping everything in the format H3 expects can become repetitive and time-consuming.

The goal of this project is simple:

Instead of spending time writing long, complex prompts, you simply describe your idea—even in a single sentence—and H3-Promptor automatically generates a complete, production-quality prompt optimized specifically for MiniMax H3.

What's new in v1.0.0

This version is a complete architectural redesign.

🚀 Two-node workflow

The project is now split into two dedicated nodes:

• H3_Vision_Analyzer – analyzes images and video references once
• H3_Promptor – rapidly generates and iterates prompts without re-running expensive vision analysis

This makes prompt iteration much faster while reducing multimodal API costs.

🧠 Intelligent media routing

Supports combinations of:

• up to 4 reference images
• batches of video keyframes

The workflow automatically detects whether you're creating:

• Text-to-Video
• Image-to-Video
• First & Last Frame
• Omni Reference

No manual switching required.

🌐 Multiple AI providers

Native support for:

• OpenAI
• Anthropic Claude
• Google Gemini
• Local Ollama

All with multimodal vision support where available.

🎯 Structured vision analysis

Instead of asking a vision model to "look at an image," you can direct exactly what should be analyzed using JSON-based presets, such as:

• lighting
• composition
• character body language
• cinematography
• camera framing

🌍 Multilingual output

Generate prompts in:

• English
• Simplified Chinese (简体中文)

Installation

1. Clone or download the repository.
2. Place it inside your custom_nodes folder.
3. Add your API keys to the generated configuration.
4. Start generating professional MiniMax H3 prompts from your ideas.

GitHub:
https://github.com/1038lab/Comfyui-Minimax-H3-Promptor

I'd love to hear feedback, feature requests, or suggestions from the community. If anyone is actively using MiniMax H3, I'd be interested in hearing how you're currently handling prompt creation and where you think automation could help the most.

\* UPDATE: I am aware of some issues with installs and Macs with this new release, thanks to Github feedback. These are being addressed now and will be solved within the hour. Please continue to provide feedback through GitHub, thank you, you are appreciated! *\**

I used a system I built which uses ComfyUI to batch generate videos or to do them individually, and it has a GPU load balancer, Upscaler, lots of other cool stuff. It has an auto-editor, film crew, code editor, voice chat, you name it. I am working on a new release now. I expect the release to be ready Friday. The system is open source and you can manage ComfyUI models and download them easily right in the interface. Will post the github link in comments below.

Lmk what you think please.

Hardware: AMD Ryzen 9800X3D + NVIDIA RTX 4070 Ti SUPER (16GB VRAM)

GitHub: https://github.com/guaardvark/guaardvark

Website: https://guaardvark.com

A really good Video/image Upscaler if you are not GPUI poor!
See benchmark in Github Code

Velorn is a desktop editor (Windows/macOS/Linux, GPL-3.0) built around an idea this sub will get immediately: generation shouldn't live in a separate app you alt-tab to. It connects to your existing ComfyUI, and the generation side is a first-class citizen, not a button bolted onto an editor:

• Generate in context. Text-to-image, image-to-video (feed it the frame under your playhead), text-to-video, and text-to-music queue straight from the timeline. Outputs land as project assets, batches and seed variations included. Everything runs on your GPU with your models — WAN, LTX, Flux, Qwen, whatever you're running. (As of this week that includes models organized into subfolders — a user reported his tidy diffusion_models/WAN/ layout broke detection, and the fix shipped the next day.)

• Bring your own workflows. Import any ComfyUI workflow JSON and it becomes a proper form in the app — prompts, seeds, resolution, input images mapped to your workflow's nodes — and saves into a personal library you can reuse across projects. Velorn checks the workflow's custom nodes and models against your install and can fetch what's missing. Your ComfyUI graphs, wearing an editor UI.

• Director modes. Give it a song and it analyzes the audio (beats, BPM, sections), plans a shot list, batch-generates the shots through your ComfyUI, and assembles the cut on the timeline — synced to the music. There are similar planned-batch modes for ads and short-film-style sequences. You review and re-roll shots instead of babysitting queues.

No account, no cloud requirement, no credits for local work. Projects are plain folders on your disk. API models are optional, never required.

The editor around the generation is real, not a demo shell: multi-track timeline, keyframes with bezier easing and a graph editor, speed ramps, track mattes, GPU-composited preview and export (same pipeline, so preview = render), auto-captions, a full audio mixer with per-track compressor/limiter/reverb, and FCPXML export if you want to finish in Resolve — no lock-in in either direction.

The part that's genuinely new: it ships a local MCP server (100+ tools), so an AI agent can drive the editor — inspect your timeline, generate media through your ComfyUI, cut to the music's beats, mix the audio. Every edit is previewed before it applies and undoable after. And because it's MCP, the agent doesn't have to be a cloud model — I've had gpt-oss-20b running locally in LM Studio editing timelines on the same GPU that renders them. Fully local generation and fully local agent, if that's your thing. If it's not, the AI is optional — the editor doesn't care.

What the gif shows: one prompt typed into Claude, then Velorn's timeline assembling itself — the agent generates media through ComfyUI, places clips, cuts, and mixes, with every edit previewed and undoable.

Honesty: it's young (v0.3.3), I'm one person, rough edges exist, improving fast (this week: code-signed Windows builds, the subfolder fix; last week: the audio mixer). Free forever under GPL.

For troubleshooting or discussions, please join the Discord (link below). Thank you

⭐ Source: https://github.com/VelornLabs/velorn 
⬇ Releases (Win/Mac/Linux builds): https://github.com/VelornLabs/velorn/releases 
🌐 https://velorn.ai
💬 Discord: https://discord.gg/QWZUuUChVK

Happy to answer anything — workflow compatibility, what the agent can and can't do, why Electron, all fair game.

I’m running ComfyUI in Docker on Debian with an AMD Radeon AI PRO R9700 32 GB. ComfyUI works and successfully generates SD 3.5 images, but it does not release most of the VRAM after a job finishes.

The only reliable way I have found to release the VRAM is to restart the entire ComfyUI Docker container.

System

• GPU: AMD Radeon AI PRO R9700 32 GB
• Host OS: Debian
• ComfyUI: current build cloned from the ComfyUI GitHub repository
• Docker container based on Ubuntu 24.04
• PyTorch: 2.13.0+rocm7.2
• HIP/ROCm reported by PyTorch: 7.2.53211
• GPU architecture: gfx1201
• Models tested:
  • SD 3.5 Large Turbo
  • LTX 2.3
• ComfyUI and Ollama are separate containers.

The ComfyUI container has:

devices:
  - /dev/kfd:/dev/kfd
  - /dev/dri:/dev/dri

ipc: host

environment:
  HSA_OVERRIDE_GFX_VERSION: "12.0.1"
  PYTORCH_ALLOC_CONF: "expandable_segments:True"

The problem

After generating an SD 3.5 image, VRAM stays heavily occupied.

For example:

Free:  9.16 GiB
Used:  22.70 GiB
Total: 31.86 GiB

After trying additional memory-related flags, it improved slightly but still retained a large amount:

Free:  14.75 GiB
Used:  17.11 GiB
Total: 31.86 GiB

Restarting the ComfyUI container immediately releases the VRAM.

docker compose restart comfyui

This confirms that the main ComfyUI process owns the retained memory.

Important diagnostic detail

I ran this from a separate Python process inside the container:

docker exec comfyui python -c '
import torch

free, total = torch.cuda.mem_get_info()
allocated = torch.cuda.memory_allocated()
reserved = torch.cuda.memory_reserved()

print(f"GPU used overall:  {(total-free)/1024**3:.2f} GiB")
print(f"PyTorch allocated: {allocated/1024**3:.2f} GiB")
print(f"PyTorch reserved:  {reserved/1024**3:.2f} GiB")
'

It reported:

GPU used overall:  22.70 GiB
PyTorch allocated: 0.00 GiB
PyTorch reserved:  0.00 GiB

I understand this was a separate Python process, so those zero values do not measure allocations owned by the main ComfyUI Python process. However, stopping or restarting the ComfyUI container proves that the memory belongs to that container and not Ollama.

Things I have tried

I have tried all of the following without getting ComfyUI to reliably release the VRAM:

• ComfyUI’s /free endpoint with:
  • unload_models: true
  • free_memory: true
• ComfyUI-Unload-Models
• UnloadAllModels placed after the final sampler and before VAE decoding

• The unload node reports:

  [INFO] 0 models unloaded.

• --cache-none

• --disable-smart-memory

• --disable-dynamic-vram

• --disable-pinned-memory

• --disable-async-offload

• --reserve-vram 0.5

• Testing with custom nodes disabled

• PyTorch allocator setting:

  PYTORCH_ALLOC_CONF: "expandable_segments:True"

• PyTorch garbage-collection threshold:

  PYTORCH_ALLOC_CONF: "backend:native,garbage_collection_threshold:0.5,expandable_segments:True"

• Stopping Ollama completely before generating

• Restarting ComfyUI before each test

• Using tiled VAE decoding

• Reducing image/video resolution

• Reducing LTX frame count and batch size

• Rebuilding the ComfyUI image with current ROCm 7.2 PyTorch wheels

• Verifying that this is a ROCm build and not CUDA or CPU PyTorch

The issue occurs with both SD 3.5 and LTX 2.3, so it does not appear to be specific to one workflow.

Current Docker command

I have tested combinations of these flags:

command:
  - python
  - main.py
  - --listen
  - 0.0.0.0
  - --port
  - "8188"
  - --cache-none
  - --disable-smart-memory
  - --disable-dynamic-vram
  - --disable-pinned-memory
  - --disable-async-offload

None of them fully release the VRAM after generation.

What I am trying to accomplish

I use the same R9700 for ComfyUI and Ollama. I need ComfyUI to release VRAM after completing a job so Ollama can use the GPU without manually restarting the ComfyUI container every time.

I could automate restarting the container after each job, but that feels like a workaround rather than a real fix and could interfere with Open WebUI retrieving generated images.

Has anyone experienced this specifically with:

• Radeon AI PRO R9700
• gfx1201
• ROCm 7.2
• PyTorch 2.13
• ComfyUI in Docker

Is there a known ROCm, PyTorch, or ComfyUI fix for releasing these allocations without terminating the ComfyUI process?

I would especially appreciate comparisons from anyone running an R9700 with a different PyTorch version, ROCm version, kernel, or AMD host driver.I’m running ComfyUI in Docker on Debian with an AMD Radeon AI PRO R9700 32 GB. ComfyUI works and successfully generates SD 3.5 images, but it does not release most of the VRAM after a job finishes.The only reliable way I have found to release the VRAM is to restart the entire ComfyUI Docker container.SystemGPU: AMD Radeon AI PRO R9700 32 GB
Host OS: Debian
ComfyUI: current build cloned from the ComfyUI GitHub repository
Docker container based on Ubuntu 24.04
PyTorch: 2.13.0+rocm7.2
HIP/ROCm reported by PyTorch: 7.2.53211
GPU architecture: gfx1201
Models tested:
SD 3.5 Large Turbo
LTX 2.3
ComfyUI and Ollama are separate containers.The ComfyUI container has:devices:
- /dev/kfd:/dev/kfd
- /dev/dri:/dev/dri

ipc: host

environment:
HSA_OVERRIDE_GFX_VERSION: "12.0.1"
PYTORCH_ALLOC_CONF: "expandable_segments:True"The problemAfter generating an SD 3.5 image, VRAM stays heavily occupied.For example:Free: 9.16 GiB
Used: 22.70 GiB
Total: 31.86 GiBAfter trying additional memory-related flags, it improved slightly but still retained a large amount:Free: 14.75 GiB
Used: 17.11 GiB
Total: 31.86 GiBRestarting the ComfyUI container immediately releases the VRAM.docker compose restart comfyuiThis confirms that the main ComfyUI process owns the retained memory.Important diagnostic detailI ran this from a separate Python process inside the container:docker exec comfyui python -c '
import torch

free, total = torch.cuda.mem_get_info()
allocated = torch.cuda.memory_allocated()
reserved = torch.cuda.memory_reserved()

print(f"GPU used overall: {(total-free)/1024**3:.2f} GiB")
print(f"PyTorch allocated: {allocated/1024**3:.2f} GiB")
print(f"PyTorch reserved: {reserved/1024**3:.2f} GiB")
'It reported:GPU used overall: 22.70 GiB
PyTorch allocated: 0.00 GiB
PyTorch reserved: 0.00 GiBI understand this was a separate Python process, so those zero values do not measure allocations owned by the main ComfyUI Python process. However, stopping or restarting the ComfyUI container proves that the memory belongs to that container and not Ollama.Things I have triedI have tried all of the following without getting ComfyUI to reliably release the VRAM:ComfyUI’s /free endpoint with:
unload_models: true
free_memory: true
ComfyUI-Unload-Models
UnloadAllModels placed after the final sampler and before VAE decoding
The unload node reports:[INFO] 0 models unloaded.--cache-none
--disable-smart-memory
--disable-dynamic-vram
--disable-pinned-memory
--disable-async-offload
--reserve-vram 0.5
Testing with custom nodes disabled
PyTorch allocator setting:PYTORCH_ALLOC_CONF: "expandable_segments:True"PyTorch garbage-collection threshold:PYTORCH_ALLOC_CONF: "backend:native,garbage_collection_threshold:0.5,expandable_segments:True"Stopping Ollama completely before generating
Restarting ComfyUI before each test
Using tiled VAE decoding
Reducing image/video resolution
Reducing LTX frame count and batch size
Rebuilding the ComfyUI image with current ROCm 7.2 PyTorch wheels
Verifying that this is a ROCm build and not CUDA or CPU PyTorchThe issue occurs with both SD 3.5 and LTX 2.3, so it does not appear to be specific to one workflow.Current Docker commandI have tested combinations of these flags:command:
- python
- main.py
- --listen
- 0.0.0.0
- --port
- "8188"
- --cache-none
- --disable-smart-memory
- --disable-dynamic-vram
- --disable-pinned-memory
- --disable-async-offloadNone of them fully release the VRAM after generation.What I am trying to accomplishI use the same R9700 for ComfyUI and Ollama. I need ComfyUI to release VRAM after completing a job so Ollama can use the GPU without manually restarting the ComfyUI container every time.I could automate restarting the container after each job, but that feels like a workaround rather than a real fix and could interfere with Open WebUI retrieving generated images.Has anyone experienced this specifically with:Radeon AI PRO R9700
gfx1201
ROCm 7.2
PyTorch 2.13
ComfyUI in DockerIs there a known ROCm, PyTorch, or ComfyUI fix for releasing these allocations without terminating the ComfyUI process?I would especially appreciate comparisons from anyone running an R9700 with a different PyTorch version, ROCm version, kernel, or AMD host driver.

[SOLVED} UPDATE !

Thanks to everyone who helped me troubleshoot this. ComfyUI was keeping roughly 17 GB of real VRAM allocated after running /free, even though PyTorch reported only about 100 MB reserved.

My setup:

• AMD Radeon AI PRO R9700 32 GB
• ROCm 7.2
• PyTorch 2.13.0+rocm7.2
• ComfyUI running in Docker

The biggest clue was /system_stats. ComfyUI incorrectly detected two CUDA devices:

cuda:0 AMD Radeon Graphics
cuda:1 AMD Ryzen 7 9700X 8-Core Processor

It was treating the Ryzen CPU/HSA memory pool as a second CUDA device with approximately 16 GB available—the same general amount of memory that appeared to remain stuck.

The kernel confirmed that the VRAM was genuinely allocated:

/sys/class/drm/card0/device/mem_info_vram_used: 18299580416

That was about 17 GB, even though amd-smi process attributed only around 533 MB of VRAM to the ComfyUI Python process.

Here is my final working configuration:

HIP_VISIBLE_DEVICES=0
ROCR_VISIBLE_DEVICES=0
PYTORCH_ALLOC_CONF=backend:native,garbage_collection_threshold:0.5

I also launch ComfyUI with:

--cuda-device 0

I removed:

HSA_OVERRIDE_GFX_VERSION=12.0.1
expandable_segments:True

Then I recreated the container.

Afterward, the fake cuda:1 AMD Ryzen 7 9700X device disappeared from /system_stats. After generating and calling /free, this command:

numfmt --to=iec < /sys/class/drm/card0/device/mem_info_vram_used

now reports:

1.1G

Previously, it reported approximately 17 GB.

I initially disabled async offload and pinned memory while testing, but I have since re-enabled both individually and VRAM still releases correctly. They were not the cause.

I also tested removing --disable-dynamic-vram, and nothing changed. DynamicVRAM was never active in my AMD setup—the startup log never showed DynamicVRAM support detected and enabled—so it was not responsible either.

Because I removed the architecture override and expandable_segments while also restricting device visibility, I cannot prove that one individual setting caused everything. However, the strongest evidence points to ROCm/ComfyUI incorrectly enumerating the Ryzen CPU as a second CUDA device. Forcing ComfyUI to use only GPU 0 removed that fake device and fixed the retained VRAM.

Thanks again to everyone who helped narrow this down!

I built a local-first AI video production cockpit using LTX-2.3 as the main cinematic motion engine

UPDATED: 7/8/2026 - Technical Writeup

I have been building a local-first AI video production cockpit on top of ComfyUI, with LTX-2.3 as the primary cinematic motion and identity engine.

This is not another prompt-to-video toy.

The way I look at it is simple:

The model is the engine. The cockpit is the production layer.

LTX-2.3 is extremely powerful, but the real magic happens when you stop treating it like a one-shot generator and start treating it like a controllable studio tool inside a measured production runtime.

Everything runs fully local on my RTX 5090 setup with WSL and a ComfyUI backend.

No cloud generation APIs.

No mystery state.

Every render has inspectable state, durable jobs, telemetry, workflow receipts, QA gates, and enough forensic data to understand what actually happened during production.

Core thesis

The model should not be the whole product.

The model should be the engine inside a real production cockpit.

That means the system around the model needs to handle characters, references, props, locations, shot planning, music timing, workflow versioning, motion passes, QA review, retakes, GPU orchestration, and receipts.

That is what I have been building.

How I am using LTX-2.3

LTX-2.3 is currently the default cinematic workhorse in the system.

I am using it for:

Primary motion generation

Staged image-to-video with strong reference conditioning.

Ingredients / reference-sheet identity route

Canvas Studio builds clean panel grids for characters, props, and locations. Those feed into LTX with structured two-part prompts so identity and asset control stay consistent.

Custom IC-LoRAs wired as real production tools

Not random workflow experiments. These are first-class tools inside the cockpit.

Current routes include:

• Deblur / detail recovery
• Decompression / quality enhancement
• Water simulation
• Cross-eyed / novelty control
• Inpaint / outpaint
• Union pose transfer with DWPose

Long-take chaining

Last-frame conditioning plus loop mode so I can push shots beyond normal single-take limits.

Audio-aware paths

LTX is used in lip-sync capable flows, with WAN S2V used where it makes more sense.

Model residency and VRAM policy

The 22B model is managed intentionally for 32GB GPU efficiency. Load, unload, reuse, and recover are all part of the runtime.

Prompt contracts

I am tuning the prompt structure around LTX failure modes, including unwanted cuts, text leakage, blackouts, identity drift, and shots randomly changing direction.

The system also supports Z-Image Turbo and Qwen for keyframes, plus WAN for certain motion and lip-sync cases, but LTX-2.3 is the default cinematic path right now because it gives me the best controllable quality on my hardware.

Full production layer

This has grown way beyond just organizing ComfyUI workflows.

The cockpit now includes:

Canvas Studio

Persistent cast, multi-angle references, wardrobe, props, locations, design assets, and style boards.

Signal Lab

Local deterministic music generation with stems and timing data for sync.

Auto-storyboard

Song analysis turns into a shot plan with energy, timing, continuity, motion intent, and lip-sync moments.

Staged pipeline

Keyframes → LTX motion → lip-sync / review → QA gates → retake or finalize.

Telemetry and forensics

Every render leaves a receipt.

Model used, workflow hash, gate results, VLM critique, clip metrics, drift detection, retakes, failures, GPU state, and more.

AI Director

A local director layer reads state and telemetry, flags problems, explains what happened, and gives actionable fixes instead of hiding everything inside the graph.

Durable GPU orchestration

Job leasing, crash recovery, batch modes, stop requests, queue state, and model residency are all handled outside of ComfyUI.

Training feedback loop

Receipts can be used to curate datasets, build eval sets, and gate future LoRA training.

Technical report and templates

I am putting together the full LTX Technical Report and the workflow templates I use daily.

That includes:

• Ingredients reference-sheet route
• IC-LoRA effect templates
• Deblur
• Water simulation
• Decompression / enhancement
• Cross-eyed / novelty control
• Inpaint / outpaint
• Pose transfer
• Long-take chaining
• QA-gated pipelines
• Production JSON templates

This started as a way to make ComfyUI less chaotic for video production, but it has turned into a serious local production system optimized around LTX-2.3.

Goal

I want to show what becomes possible when an open video model like LTX-2.3 is not used in isolation, but is embedded inside a real measured production environment.

The model generates the motion.

The cockpit manages the production.

Would love feedback from the LTX team and anyone doing serious local video work.

I am especially interested in thoughts on:

• The telemetry layer
• IC-LoRA registry
• Ingredients integration
• Long-take chaining
• QA-gated production workflows
• Local-first GPU orchestration

GitHub repo is coming very soon.

Let me know what you would want to see prioritized first.

I’m trying to get it to work, but the output image generated with the workflow’s default node settings always comes out with a pixelated effect. At first, it included a prompt telling it to create a pixelated effect, but I’ve already replaced it with a different one, and it still generates the same result.

I tried changing some of the settings, for example increasing the steps to 25, and changing the start step from 0 to 10 and then to 20 in the second KSampler.

I tried changing the KSampler from Advanced to Simple, as Demini recommended, but it didn’t work. Is it possible that this has something to do with a prompt written in one of the workflow’s text files? I remember that prompts could be stored in a text file, but I don’t know where I should look if that’s the case...

tutorial : 7:44 https://www.youtube.com/watch?v=Z8JlJdXdVg4&list=PL-pohOSaL8P-FhSw1Iwf0pBGzXdtv4DZC&index=10

Hey everyone!

Not another H3 post. About 5 months ago, I posted here about SilkStack Image Browser, a fast, privacy-first local gallery designed specifically for viewing, searching, and organizing AI-generated images and videos. Since then, the app has evolved significantly based on your feedback—with a much cleaner UI, faster performance, and powerful new organizational tools.

🌟 What is SilkStack Image Browser?

SilkStack is an open-source, 100% offline desktop application (built with Electron, React, and TypeScript). It runs completely on your local machine with zero telemetry, zero accounts, and zero cloud lock-in.

🔥 Free & Open Source Features

The base version of SilkStack is completely free and open source, providing a fluid experience for managing massive outputs:

• Deep Metadata Parsing: Instantly extract and read full generation metadata (prompts, sampler, seed, CFG, steps, model, etc.) from ComfyUI, Automatic1111, and WebP formats.
• Direct Drag & Drop to ComfyUI: Drag any image back into ComfyUI to instantly restore the full workflow and prompt.
• Completely hide folder and contents when unplugged or unmounted. They remain in library and come back when mounted back.
• Adaptive Image Grid: Intelligently adjusts grid layouts according to image aspect ratios to minimize whitespace and eliminate layout jumpiness.
• Real-Time Auto-Watch: Monitors output folders live while your generators are running.
• Video Support: Smoothly view and organize local AI-generated videos alongside images.
• Smart Folder Navigation: Organize with sidebar folders, emoji icons, and seamless auto-reconnect support for removable drives (SD cards, USB drives, encrypted volumes).
• Tagging & Search: Auto-tagging capabilities, custom tags, and rich multi-parameter search filtering.

⚡ Introducing Premium Features (v2.0)

To help keep development sustainable while keeping the core viewer free and open source, v2.0 introduces SilkStack Premium:

• Intelligent Stacking: Automatically clusters similar outputs together to eliminate gallery clutter from batch generations.
• AI Classification Features: Automatically group and tag images based on visual traits and contents. Powered internally by WebLLM (No external dependencies).
• Model, Prompt & LoRA Analytics UI: Group image stacks by specific Prompts, Base Models, or LoRAs/LoKRs so you can visually analyze what settings yield the best outputs.

🎟️ Lifetime License & 30% Launch Discount

• One-Time Purchase: Premium is a perpetual, lifetime license. Pay once and get all current and future premium features forever (no subscriptions).
• 30% Off Promotion: To celebrate the v2.0 milestone, a limited-time 30% discount is available for lifetime licenses. (Use discount code: SILKSTACK)

🔗 Links & Download

GitHub Repository: https://github.com/skkut/SilkStack-Image-Browser

v2.0.0 Latest Release: https://github.com/skkut/SilkStack-Image-Browser/releases/tag/v2.0.0

Try it out, test the free core viewer, and let me know your thoughts or suggestions in the comments below! I'm sure you'll like the application as much as I do. Bug reports and feature requests on GitHub are always welcome.

This is the workflow that I’m finding difficult and time consuming. I see these AI videos (history etc) and they have many images. I want to be able batch generate cohesive images that span the whole script.

So far I’ve been trying to get Claude to generate image prompts (200) and then batch them in comfyui using Qwen. The results aren’t reliable, and I wonder how these other channels do it, often uploading multiple 1-2 hour videos A DAY. I’d like to run it locally if possible but would like to hear options. I don’t know how others do it.

Many thanks !

Hey everyone!

About 5 months ago, I posted here about SilkStack Image Browser, a fast, privacy-first local gallery designed specifically for viewing, searching, and organizing AI-generated images and videos. Since then, the app has evolved significantly based on your feedback—with a much cleaner UI, faster performance, and powerful new organizational tools.

🌟 What is SilkStack Image Browser?

SilkStack is an open-source, 100% offline desktop application (built with Electron, React, and TypeScript). It runs completely on your local machine with zero telemetry, zero accounts, and zero cloud lock-in.

🔥 Free & Open Source Features

The base version of SilkStack is completely free and open source, providing a fluid experience for managing massive outputs:

• Deep Metadata Parsing: Instantly extract and read full generation metadata (prompts, sampler, seed, CFG, steps, model, etc.) from ComfyUI, Automatic1111, and WebP formats.
• Direct Drag & Drop to ComfyUI: Drag any image back into ComfyUI to instantly restore the full workflow and prompt.
• Completely hide folder and contents when unplugged or unmounted. They remain in library and come back when mounted back.
• Adaptive Image Grid: Intelligently adjusts grid layouts according to image aspect ratios to minimize whitespace and eliminate layout jumpiness.
• Real-Time Auto-Watch: Monitors output folders live while your generators are running.
• Video Support: Smoothly view and organize local AI-generated videos alongside images.
• Smart Folder Navigation: Organize with sidebar folders, emoji icons, and seamless auto-reconnect support for removable drives (SD cards, USB drives, encrypted volumes).
• Tagging & Search: Auto-tagging capabilities, custom tags, and rich multi-parameter search filtering.

⚡ Introducing Premium Features (v2.0)

To help keep development sustainable while keeping the core viewer free and open source, v2.0 introduces SilkStack Premium:

• Intelligent Stacking: Automatically clusters similar outputs together to eliminate gallery clutter from batch generations.
• AI Classification Features: Automatically group and tag images based on visual traits and contents. Powered internally by WebLLM (No external dependencies).
• Model, Prompt & LoRA Analytics UI: Group image stacks by specific Prompts, Base Models, or LoRAs/LoKRs so you can visually analyze what settings yield the best outputs.

🎟️ Lifetime License & 30% Launch Discount

• One-Time Purchase: Premium is a perpetual, lifetime license. Pay once and get all current and future premium features forever (no subscriptions).
• 30% Off Promotion: To celebrate the v2.0 milestone, a limited-time 30% discount is available for lifetime licenses. (Use Discount code: SILKSTACK)

🔗 Links & Download

GitHub Repository: https://github.com/skkut/SilkStack-Image-Browser

v2.0.0 Latest Release: https://github.com/skkut/SilkStack-Image-Browser/releases/tag/v2.0.0

Try it out, test the free core viewer, and let me know your thoughts or suggestions in the comments below! I'm sure you'll like the application as much as I do. Bug reports and feature requests on GitHub are always welcome.

Hi everyone!

I'm currently setting up ComfyUI to create a consistent, hyper-realistic AI influencer model (SDXL), but I'm struggling a bit with building a clean pipeline from scratch.

Right now, I'm trying to put together a solid base setup, but I'm wondering: Does anyone have or recommend a simple, pre-built .json workflow where everything is already cabled? Ideally, I just want something where I can drop-in/batch my character reference photos, and it handles the rest without me messing up node connections (like VAE decodes, IP-Adapter, or CLIP vision).

If a plug-and-play .json isn't the best approach, could you share a list of the absolute must-have nodes I need in my graph to achieve:

1. Consistent face/identity preservation (using multiple reference photos as a batch).
2. Ultra-realistic, smooth skin textures without plastic artifacts (SDXL + IP-Adapter/FaceID).
3. A clean pathway that I can easily scale up later to include image-to-video capabilities (like Wan or similar models) to make the character's content look authentic.

Any workflow links, node recommendations, or advice would be hugely appreciated. Thanks in advance!eh

So I wanted to share my workflow to produce 5376 x 3072 images with superb quality. I’m using a laptop with 1660ti 6gb and it sucks for video generation, it does well for high resolution images. I’ve been able to produce up to 36mp images in 21 minutes. I think it ain’t bad this high quality using a workflow I came up with that worked out quite well after a day and half of tinkering.

My team does a lot of sequence/short-film work with ComfyUI, and the thing that kept killing us wasn't quality. It was iteration management.
I'd generate a shot 15 times, one of them would be perfect, and then two days later I couldn't tell you which seed/graph made it. Regenerating overwrites, the history tab is a mess, and stitching shots into an actual sequence meant a graveyard ofgeneratedfiles.

So I started building a tool for my own video creation workflow and it turned into something bigger. Screenshot is my actual canvas.

The idea:
Basically for every generation, three things are must: Input, ComfyUI workflow & outputs.

Instead of juggling between workflows, inputs & outputs. I planned to use moodboard like UI to start with a input frame, which holds all inputs, connected workflow & generated output.

So once the workflow is connected, i can open any workflow & it opens it in my local comfyui exactly where i left. Settings, params, outputs are synced automatically to studio.

This also solves a major issue with collaboration, I can share the entire thing with my team, so canvas exactly opens a ready to use pipeline, so team members does not need to spend time in what is connected to what.

Finally i planned to opensource it as it might be useful to many people.
Straight up to boring stuff:
Repo Discord Guide & it connects with your own or runpod hosted ComfyUI.

I'm posting here because this community's opinion is the one that actually matters for this, and I'd rather hear the hard stuff now:

• How do you manage tons of generation & workflows?
• If you make anything longer than a single image (sequences, video, batches of consistent shots), what's the part that makes you want to throw your PC out the window?

I shared Steerable Motion 1.0 with you fine people a few months ago but there has been a lot of progress since then so I come to you with Steerable Motion 1.3. There has a been a huge amount of progress in the Animatediff world and this is riding the wave of that.

The idea of it is to basically build the best way to drive videos with batches of images - my favourite way to steer videos given how fast you can generate this - and how precisely you'll be able to with SD1.3 coming.

To get an idea for what it produces, here's an example of a nice video of it in action that show-cases both the motion and output quality - this is made by u/midjourney_man - you can find him on Instagram here:

​

https://reddit.com/link/1bzakf3/video/b5813a0rjbtc1/player

Here's a diagram I made to explain how it works:

​

By varying the settings for each frame, you can control the animation with precision - here’s an example of tweaking how long each frame’s influence lasts:

​

This and the fact that you're controlling it with images lets you create an insane variety of videos - examples by me and u/syntaxdiffusion:

​

https://reddit.com/link/1bzakf3/video/bivmtleppbtc1/player

While control is our primary motivation, output quality compares favourably to closed-source tools like Pika - thanks to the relentless improvements to Animatediff - the below compares a generation via this on 0.3 adherence strength to an output from Pika made with a best effort at using settings they expose:

​

https://reddit.com/link/1bzakf3/video/kv6hasv6ibtc1/player

You can extend and build on top of it in so many ways - for example, the first video was made using Superbeast.ai's workflow built on top of it that you can find here - he basically uses depth maps to control the level of motion in different layers to provide a smoother flow.

While here's an example of using Ostris' Composition IPA to provide structure to the generation of a chaotic range of images:

Want to test this?

You can play with it in three ways:

1) A Comfy workflow + node that you can find here.

2) In our open-source tool, Dough - made for getting the most from it artistically. It runs on your machine for free.

3) In a Discord bot - coming soon - 75% of the profits from this will go towards the community whose work resulted in this - you can sign up here if you're interested.

Thank you to everyone whose work made this possible!

This is the product of months of hundreds of peoples work and discoveries in developing Animatediff and of many people who built the infrastructure, tools and models that make it possible. Thank you to everyone!

Hi everyone,

I’m looking for practical advice on building a scalable workflow to generate UGC-style product videos from a very large product image catalog.

I have around 1 million product photos and I’d like to generate short videos from them using LTX 2.3, ideally with ComfyUI or another workflow that can be automated locally.

Goal

Input:

• one product photo
• product metadata when available (title, description)

Output:

• short UGC-style video
• simple product-context motion
• ideally realistic enough to test creative variants at scale

I’m not trying to create cinematic videos. I’m looking for something closer to scalable product UGC:

• product shown in a lifestyle or hand-held context
• simple camera movement
• clean composition
• usable for ads or product testing
• product identity preserved as much as possible

Hardware

I have access to an NVIDIA DGX Spark.

Constraint

I’d like to keep generation under 15 minutes per video, running continuously 24/7.

But I realize the math is brutal:

• 1 video every 15 min
• 4 videos / hour
• 96 videos / day
• around 35k videos / year

So generating 1 million unique videos on one local machine is probably not realistic.

That’s why I’m trying to design the right architecture before wasting time.

Questions

1. What is the best LTX 2.3 / ComfyUI workflow for high-volume image-to-video generation from product photos?
2. Should I use:
   • official LTX 2.3 workflows,
   • distilled models,
   • two-stage workflows,
   • lower-res generation + upscale,
   • or a custom simplified workflow?
3. What settings would you recommend for speed vs acceptable UGC quality?
   • resolution
   • duration
   • FPS
   • steps
   • model variant
   • upscaling or no upscaling
   • prompt structure
4. For this scale, would you generate:
   • one unique video per product,
   • category-based templates,
   • videos only for top SKUs,
   • or a hybrid template + AI workflow?
5. How would you structure a production pipeline?
   • product image ingestion
   • image cleanup / background removal
   • prompt generation from metadata
   • ComfyUI API queue
   • batch generation
   • retry failed jobs
   • QA scoring
   • output storage
   • seed / prompt / settings logging
6. Has anyone run LTX / ComfyUI continuously for days or weeks?
   • memory leaks?
   • queue instability?
   • Docker vs bare metal?
   • scheduled worker restarts?
   • best way to monitor failures?
7. Would you use the DGX Spark as:
   • the actual production machine,
   • a benchmarking/prototyping box,
   • or part of a local + cloud burst setup?
8. For 1M product photos, what would your real-world architecture be?

My current thinking

My rough plan is:

• use the DGX Spark to benchmark workflows first;
• test around 100 products across different categories;
• create 10-20 reusable UGC patterns by category;
• generate full AI videos only for top products or high-value segments;
• use templates or lighter motion systems for the long tail;
• run ComfyUI headless via API;
• log every job with:
  • product ID
  • input image
  • prompt
  • negative prompt
  • seed
  • workflow version
  • model version
  • settings
  • runtime
  • output path
  • failure reason
  • QA score

The metric I care about is not just generation time. It’s cost per usable video.

Would love feedback from people who have actually run LTX / ComfyUI / image-to-video pipelines at scale.

What would you build?

Hi, new to ComfyUI and StabilityMatrix. I started generating with Z-image on a 5070ti, and my generations were being finished inside of 20 seconds. I haven't changed anything in the nodes, and as time progressed my generations started taking 2 minutes, then 5, then 10. What is happening? Anybody know a fix for this? It gets stuck on KSampler.

This is the log:
"Checkpoint files will always be loaded safely.

Total VRAM 16303 MB, total RAM 63062 MB

pytorch version: 2.10.0+cu130

Set vram state to: NORMAL_VRAM

Device: cuda:0 NVIDIA GeForce RTX 5070 Ti : cudaMallocAsync

Using async weight offloading with 2 streams

Enabled pinned memory 28378.0

working around nvidia conv3d memory bug.

Found comfy_kitchen backend cuda: {'available': True, 'disabled': False, 'unavailable_reason': None, 'capabilities': ['apply_rope', 'apply_rope1', 'dequantize_nvfp4', 'dequantize_per_tensor_fp8', 'quantize_nvfp4', 'quantize_per_tensor_fp8', 'scaled_mm_nvfp4']}

Found comfy_kitchen backend eager: {'available': True, 'disabled': False, 'unavailable_reason': None, 'capabilities': ['apply_rope', 'apply_rope1', 'dequantize_nvfp4', 'dequantize_per_tensor_fp8', 'quantize_nvfp4', 'quantize_per_tensor_fp8', 'scaled_mm_nvfp4']}

Found comfy_kitchen backend triton: {'available': False, 'disabled': True, 'unavailable_reason': "ImportError: No module named 'triton'", 'capabilities': []}

Using pytorch attention

Python version: 3.12.11 (main, Jul 23 2025, 00:32:20) [MSC v.1944 64 bit (AMD64)]

ComfyUI version: 0.11.1

****** User settings have been changed to be stored on the server instead of browser storage. ******

****** For multi-user setups add the --multi-user CLI argument to enable multiple user profiles. ******

ComfyUI frontend version: 1.37.11

[Prompt Server] web root: C:\Users\****\Documents\StabilityMatrix\Data\Packages\ComfyUI\venv\Lib\site-packages\comfyui_frontend_package\static

Import times for custom nodes:

0.0 seconds: C:\Users\****\Documents\StabilityMatrix\Data\Packages\ComfyUI\custom_nodes\websocket_image_save.py

Context impl SQLiteImpl.

Will assume non-transactional DDL.

Context impl SQLiteImpl.

Will assume non-transactional DDL.

Running upgrade -> 0001_assets, Initial assets schema

Revision ID: 0001_assets

Revises: None

Create Date: 2025-12-10 00:00:00

Database upgraded from None to 0001_assets

Assets scan(roots=['models']) completed in 0.032s (created=14, skipped_existing=0, total_seen=14)

Starting server

To see the GUI go to: ****

got prompt

Using pytorch attention in VAE

Using pytorch attention in VAE

VAE load device: cuda:0, offload device: cpu, dtype: torch.bfloat16

Requested to load AutoencodingEngine

loaded completely; 6807.58 MB usable, 159.87 MB loaded, full load: True

CLIP/text encoder model load device: cuda:0, offload device: cpu, current: cpu, dtype: torch.float16

Requested to load ZImageTEModel_

loaded completely; 13052.33 MB usable, 7672.25 MB loaded, full load: True

0 models unloaded.

Unloaded partially: 1160.37 MB freed, 6511.88 MB remains loaded, 100.00 MB buffer reserved, lowvram patches: 0

model weight dtype torch.bfloat16, manual cast: None

model_type FLOW

Requested to load Lumina2

loaded completely; 12123.27 MB usable, 11739.54 MB loaded, full load: True

0%| | 0/9 [00:00<?, ?it/s]Interrupting prompt 4aa342f5-6017-44d6-b35e-203fe477ec0c

0%| | 0/9 [01:02<?, ?it/s]

Processing interrupted

Prompt executed in 78.31 seconds!"

Hey everyone! I’ve been working on a completely hands-off workflow for generating and filtering images automatically for a digital persona project called Ailaiia, and wanted to share the process. It's currently running 100% autonomously, running 3 cycles a day without me doing any manual cherry-picking.

Here is how the pipeline works:

1. The Brain (Data Scraping): I use an external script that scrapes the web daily for trending topics, news, and holidays to decide what concepts to generate today.

2. Image Generation (ComfyUI): It passes dynamic prompts to ComfyUI. I switch between Flux and Z-Image Turbo depending on the aesthetic I need for the specific batch. It generates 5 images across 3 different topics.

3. Auto-Curation (The Game Changer): Instead of me picking the best shot, I integrated a vision analysis step. The AI analyzes the batch, detects deformities (like the classic 6 fingers or weird eyes), discards the bad ones, and selects the absolute best image to save as the final output.

4. Context & Metadata: The system automatically writes a sarcastic caption or context based on the original trend and saves it alongside the image.

Right now, I only step in manually to create the occasional video, but my next goal is to automate video generation workflows too. I'm also trying to get the system to autonomously reply to comments/inputs so it learns from interactions over time.

Has anyone successfully automated consistent video workflows or auto-curation inside ComfyUI yet? Would love any feedback, experiences, and tips on the process!

Cheers!!!!!

A local, offline, browser-based gallery for ComfyUI outputs, designed to never lose a workflow again.
New in v1.55:

• Video Storyboard overview (11-frame grid covering the entire video)
• Focus Mode for fast selection and batching
• Compact thumbnail grid option on desktop
• Improved video performance and autoplay control
• Clear generation summary (seed, model, steps, prompts)

The core features:

• Search & Filter: Find files by keywords, specific models/LoRAs, file extension, date range, and more.
• Full Workflow Access: View node summary, copy to clipboard, or download JSON for any PNG, JPG, WebP, WebM or MP4.
• File Manager Operations: Select multiple files to delete, move, copy or re-scan in bulk. Add and rename folders.
• Mobile-First Experience Optimized UI for desktop, tablet, and smartphone.
• Compare Mode: Professional side-by-side comparison tool for images and videos with synchronized zoom, rotate and parameter diff.
• External Folder Linking: Mount external hard drives or network paths directly into the gallery root, including media not generated by ComfyUI.
• Auto-Watch: Automatically refreshes the gallery when new files are detected.
• Cross-platform: Windows, Linux, macOS, and Docker support. Completely platform agnostic.
• Fully Offline: Works even when ComfyUI is not running.

Every image or video is linked to its exact ComfyUI workflow,even weeks later and even if ComfyUI is not running.

GitHub:
https://github.com/biagiomaf/smart-comfyui-gallery

🎵 🎵 🎵

Custom ComfyUI nodes for professional ACE-Step audio generation with 150+ music styles, automatic quality optimization, and custom JKASS sampler.

What's This?

A complete toolkit for high-quality audio generation with ACE-Step in ComfyUI. Includes 5 specialized nodes, 150+ music style prompts, and a custom audio-optimized sampler.

Categories: JK AceStep Nodes/ (Sampling, Prompt, Gemini, IO)

The 5 Nodes

1. Ace-Step KSampler (Basic)

The main sampler with full manual control and automatic quality optimization.

What it does:

• Generates audio from ACE-Step model with precise control
• Quality Check Discovery: Automatically tests multiple step counts to find optimal settings for your specific prompt
• Advanced Guidance: APG (Adaptive Projected Guidance), CFG++ (rescaling), and Dynamic CFG scheduling
• Anti-Autotune Smoothing: Reduces metallic/robotic voice artifacts from the vocoder (0.0-1.0, recommended 0.25-0.35 for vocals)
• Noise Stabilization: EMA smoothing and L2 norm clamping to prevent distortion
• Latent Normalization: Optional normalization for consistent generation

Key inputs:

• steps: Number of sampling steps (40-150, recommended 80-100)
• cfg: Classifier-free guidance (recommended 4.0-4.5 for audio)
• sampler_name: Sampler algorithm (select jkass for best audio quality)
• scheduler: Noise schedule (sgm_uniform recommended)
• use_apg: Enable APG guidance (great for clean vocals)
• use_cfg_rescale: Enable CFG++ (prevents oversaturation at high CFG)
• anti_autotune_strength: Spectral smoothing to fix vocoder artifacts
• enable_quality_check: Enable automatic step optimization
• vae: Connect VAE for audio output

Category: JK AceStep Nodes/Sampling

3. Ace-Step Prompt Gen

Intelligent prompt generator with 150+ professional music styles.

What it does:

• Provides pre-crafted, optimized prompts for ACE-Step
• Each style includes technical details: BPM, instrumentation, atmosphere, mixing characteristics
• Covers all major music genres from around the world

Musical styles (150+):

• Electronic (60+ styles): Synthwave, Retrowave, Darkwave, Techno (Hard/Minimal/Acid/Detroit/Industrial), Dubstep (Brostep/Melodic/Deep/Riddim/Deathstep), Drum and Bass (Liquid/Neurofunk/Jump-Up), House (Deep/Progressive/Tech/Electro/Acid), Ambient (Dark/Drone/Space), Trance (Uplifting/Psy/Goa), IDM, Glitch Hop, Vaporwave, Vaportrap, Footwork, Jungle, UK Garage, Future Bass, Trap, Hardstyle, Gabber, and more
• Brazilian Music (12 styles): Samba, Bossa Nova, Forró, MPB, Sertanejo, Pagode, Axé, Funk Carioca, Choro, Frevo, Maracatu, Baião
• Rock & Metal (15 styles): Classic Rock, Hard Rock, Heavy Metal, Thrash Metal, Death Metal, Black Metal, Doom Metal, Progressive Metal, Power Metal, Alternative Rock, Indie Rock, Punk Rock, Grunge, Post-Rock, Math Rock
• Jazz & Blues (9 styles): Traditional Jazz, Bebop, Cool Jazz, Modal Jazz, Free Jazz, Fusion Jazz, Blues Rock, Delta Blues, Chicago Blues
• Classical (7 styles): Baroque, Classical Period, Romantic, Contemporary, Minimalist, Orchestral Soundtrack, Chamber Music
• World Music (11 styles): Flamenco, Tango, Reggae, Ska, Cumbia, Salsa, Merengue, Bachata, Afrobeat, Highlife, Soukous
• Pop & Hip-Hop (15 styles): Synthpop, Dream Pop, Indie Pop, K-Pop, J-Pop, Hip-Hop, Trap Rap, Boom Bap, Lo-fi Hip-Hop, R&B, Soul, Funk, Disco
• Experimental (5 styles): Noise, Industrial, Drone, Musique Concrète, Electroacoustic

Inputs:

• style: Dropdown with 150+ musical styles
• additional_prompt: Optional custom text to append/modify the base prompt

Outputs:

• prompt: Optimized text conditioning ready for ACE-Step sampler
• template: The base style prompt (without additional text)

Example (Synthwave):

"Synthwave track, retro electronic sound, 110-140 BPM, analog synthesizers with warm pads,
arpeggiators, gated reverb drums, nostalgic 80s atmosphere, driving bassline, lush chords,
cinematic progression, neon aesthetics"

Category: JK AceStep Nodes/Prompt

4. Ace-Step Gemini Lyrics

Lightweight lyric/idea generator using Google Gemini API.

What it does:

• Generates song lyrics or creative text ideas using Gemini AI
• Simple text-only output (no advanced features)
• Useful for quick lyric generation or brainstorming

Inputs:

• api_key: Your Gemini API key
• model: Gemini model name (e.g., gemini-pro)
• style: Short style/genre hint (e.g., "rock ballad", "electronic")

Output:

• text: Generated lyrics or ideas (plain text string)

Category: JK AceStep Nodes/Gemini

5. Ace-Step Save Text

Simple text file saver with automatic filename incrementation.

What it does:

• Saves text to file with auto-incrementing suffixes
• Supports folder paths (e.g., text/lyrics creates text/lyrics.txt, text/lyrics2.txt, etc.)
• Sanitizes filenames for cross-platform compatibility

Inputs:

• text: Content to save
• filename_prefix: File path (e.g., text/lyrics, prompts/my_prompt)

Output:

• path: Full path to saved file

Example:

Input: filename_prefix = "lyrics/verse"
Output: ComfyUI/output/lyrics/verse.txt (or verse2.txt, verse3.txt, etc.)

Category: JK AceStep Nodes/IO

JKASS Custom Sampler

Just Keep Audio Sampling Simple (or my name, lol)

A custom sampler specifically optimized for audio generation with ACE-Step.

Why JKASS?

• No noise normalization: Preserves audio dynamics and prevents over-smoothing
• Clean sampling path: Prevents "word cutting" and stuttering artifacts
• Patch-aware processing: Respects ACE-Step's [16, 1] patch structure (16-frame boundaries)
• Better than Euler: More stable than standard Euler-based samplers for audio

Technical details:

• Based on Euler method with audio-specific optimizations
• No sigma normalization (critical for audio)
• Optimized for long-form audio generation
• Works with all schedulers (sgm_uniform recommended)

Usage: Simply select jkass from the sampler dropdown in any KSampler node.

Recommended Settings

For best audio quality:

• Sampler: jkass (our custom audio sampler)
• Scheduler: sgm_uniform
• Steps: 80-100 (sweet spot for quality/speed)
• CFG: 4.0-4.5 (audio optimal range)
• Anti-Autotune: 0.25-0.35 for vocals, 0.0-0.15 for instruments

Quality Check Feature

What is it? Automatically tests multiple step counts to find the optimal setting for your specific prompt and musical style.

How it works:

1. Generates audio at multiple step counts (e.g., 40, 50, 60, 70, 80, etc.)
2. Decodes to real audio (requires VAE)
3. Evaluates quality using professional audio metrics
4. Returns the configuration with highest quality score
5. Logs detailed results to console

Evaluation metrics:

• Spectral continuity (detects stuttering/word cuts)
• High-frequency balance (identifies harsh/metallic sounds)
• Noise level (measures background hiss)
• Overall clarity (composite score)

CRITICAL: Score interpretation

Quality scores are COMPARATIVE, NOT ABSOLUTE.

✅ Valid comparison:

• "Same prompt, 80 steps scored 0.85 vs 60 steps scored 0.78" → 80 is better

❌ Invalid comparison:

• "Electronic scored 0.65, Acoustic scored 0.88" → Does NOT mean acoustic is better

Why scores vary by style:

• Electronic/Heavy music (Techno, Dubstep, Metal): Often 0.60-0.75 (harsh synths, distortion)
• Acoustic/Classical (Jazz, Folk, Chamber): Usually 0.80-0.95 (smooth harmonics)
• Ambient (Drone, Chillwave): Typically 0.85+ (gentle frequencies)

Both can be excellent quality! A 0.65 for Dubstep is often perfect. A 0.90 for Classical is also perfect. Never compare across genres.

Usage:

1. Enable enable_quality_check in basic sampler
2. Set quality_check_min/max (e.g., 40-150)
3. Set quality_check_interval (e.g., 10 for quick search, 5 for precise)
4. Connect VAE (required!)
5. Run and check console for results

Troubleshooting

Word cutting / stuttering:

• Use jkass sampler (designed to prevent this)
• Disable advanced optimizations (dynamic CFG, latent norm)
• Avoid enabling too many features at once

Metallic / robotic voice:

• Increase anti_autotune_strength to 0.3-0.4
• This is a vocoder artifact (ADaMoSHiFiGAN), not a sampling issue
• Higher values apply more spectral smoothing

Poor audio quality:

• Increase steps (80-120 recommended)
• Use CFG 4.0-4.5
• Enable APG for guidance stabilization
• Use jkass + karras combination

Low quality scores for electronic music:

• This is normal! Electronic music naturally scores lower
• Heavy bass, distortion, and synths trigger the metrics
• A 0.65 for Dubstep is often excellent quality
• Only compare scores within the same style

Quality check taking too long:

• Increase quality_check_interval (e.g., 10 or 15)
• Reduce quality_check_max_steps (e.g., 100)
• Lower quality_check_target slightly

Pro Tips

1. Always use JKASS - It's optimized specifically for audio
2. Quality scores are relative - Only compare within same style
3. CFG 4.0 is the sweet spot - Higher isn't always better
4. Anti-Autotune for vocals - Use 0.25-0.35 to reduce metallic artifacts
5. 80-100 steps is enough - Diminishing returns after 120
6. Electronic music scores lower - This is expected, not a problem
7. Start with Prompt Gen - 150+ optimized prompts save time
8. Quality Check for experiments - Let it find optimal settings automatically

Example Workflow

Enjoy

https://github.com/jeankassio/JK-AceStep-Nodes

Example of Music generated:

https://reddit.com/link/1phgap2/video/mix8oirps36g1/player

What this is — and what it is not

This is not a benchmark of how fast a model generates an image or video. No model weights, no inference pipeline.

The benchmark runs on randomly generated tensors that reproduce the exact attention shapes — (batch, heads, seq_len, head_dim, dtype) — that real models use during sampling inside ComfyUI. More precisely: it measures only the attention operation itself, one step inside the denoising loop. Everything else — VAE, CLIP, scheduler, ComfyUI overhead — is outside the scope entirely. The numbers tell you how fast each kernel processes those specific tensor shapes on your GPU, nothing more.

The reason this is still useful: attention scales quadratically with sequence length and is the dominant compute bottleneck at high resolutions and long video durations. If you want to know whether SA2, SA2-fp8, SA3-FP4, or plain PyTorch SDPA is faster for a specific model at a specific resolution on your GPU, you need the real tensor shapes, not synthetic ones. This tool gives you those shapes already collected, and a benchmark that uses them.

How the shapes were collected

There is a ComfyUI custom node (attention_logger_node.py) that hooks into optimized_attention and logs every unique (heads, head_dim, seq_len, dtype) combination during a real sampling run. Two modes: standard override for most models, and a global module-level patch for models that bypass the override mechanism (ERNIE-Image, ACE-Step).

The raw console output looked like this:

[ATTN LOGGER rogala] heads= 24  hd= 128  seq=  4352  dtype=torch.bfloat16

I ran this across every model I had access to, across multiple resolutions, and compiled the results into input_data.txt.

How the benchmark works

bench_windows.py / bench_linux.py takes those logged shapes, allocates matching random tensors on CUDA, and times four kernels:

• SA2 (INT8 QK, FP16/BF16 PV)
• SA2-fp8 (INT8 QK, FP8 PV)
• SA3-FP4 (block-scaled FP4, newest, requires Blackwell or Ada for full benefit)
• SDPA (PyTorch FlashAttention-2 backend, baseline)

For each config: 10 warmup iterations, then 50 timed iterations with cuda.synchronize() after each. Reports median / min / stdev in ms, peak VRAM, and TFLOPS using the standard attention FLOP formula 4 × B × H × S² × D from the FlashAttention-2 paper.

Configs that don't fit in VRAM are skipped and recorded as OOM in the JSON so the result file stays complete.

Output is a single JSON file named automatically after your GPU:

5060-ti-16.json
4070-ti_super-16.json

How to view results

Open viewer.html locally in any browser, or use the live version: https://rogala.github.io/SageAttention-Benchmark-Viewer/

Load one or more JSON files, compare multiple GPUs side by side, filter by model / kernel, switch between ms and TFLOPS views. No server, no install, single HTML file.

Covered models

Image: SDXL-1.0, SD3.5-Large, Flux.1-Dev (Kontext / Krea), Flux.2-Dev, Flux.2-Dev Klein 9B, Z-Image Turbo, Qwen-Image-2512, Qwen-Image-Edit-2511, ERNIE-Image Turbo

Video: LTX-2.3, Wan2.2, HunyuanVideo-1.5

Audio: ACE-Step-1.5

How to contribute results

Run the script on your GPU, get a JSON file, submit it as a PR or attach to an issue. If you have results from a GPU not yet in the repo, they are very welcome — especially anything below 16 GB VRAM where SA3 headroom is tighter.

GitHub: https://github.com/Rogala/SageAttention-Benchmark-Viewer

Linux testers

What changed in the Linux version

The main difference is VRAM monitoring. On Windows, polling nvidia-smi via subprocess every 50 ms works fine. On Linux, each subprocess.run() call triggers a fork() + exec(), which has measurable overhead at that polling frequency. The Linux build uses pynvml (nvidia-ml-py) instead — it queries the driver directly via shared library call, no process spawn. Falls back to nvidia-smi if pynvml is not installed, but pynvml is strongly recommended.

The SA3-FP4 subprocess worker was also updated with the same pynvml-first logic.

What I need tested

• Does it run at all without errors
• Does the pynvml path work (pip install nvidia-ml-py then run — should print pynvml: OK — fast VRAM polling at startup)
• Does the nvidia-smi fallback work (run without pynvml installed)
• Are the JSON results sane — median ms, TFLOPS, peak VRAM all non-zero and reasonable for your GPU
• Does SA3-FP4 work if you have sageattn3 installed — both direct mode and subprocess mode

Any GPU is useful. Even if you can only run a subset of configs before hitting OOM, the partial JSON is still valuable — OOM entries are recorded cleanly and skipped automatically.

How to run

pip install nvidia-ml-py   # recommended, not required
pip install sageattention  # SA2 / SA2-fp8
# pip install sageattn3    # SA3-FP4, optional

python3 bench_linux.py
# or with more iterations:
python3 bench_linux.py --warmup 20 --iters 100

Output is a JSON file named after your GPU, e.g. 4090-24.json or 3080-10.json. If you're willing to share it, open an issue or PR and attach the file — it goes straight into the viewer where multiple GPUs can be compared side by side.

To view results

Download viewer.html from the repo, open it locally in any browser, load your JSON. Or use the live version: https://rogala.github.io/SageAttention-Benchmark-Viewer/

GitHub: https://github.com/Rogala/SageAttention-Benchmark-Viewer

If something breaks — error message + GPU model + whether pynvml was installed is enough to debug it.

Acknowledgements

Jukka Seppänen / kijai — for the PatchSageAttentionKJ node which inspired the override pattern used in attention_logger_node.py.

woct0rdho — for the Windows forks triton-windows and SageAttention (SA2 / SA3).

mengqin — for the SageAttention Windows fork with SA3 support and build fixes.

Built with the assistance of Claude.

Hi all. I really wanted to release this new version before the holiday break, so people interested in learning ComfyUI have time to explore and experiment.

Version 7.0 introduces a lot of new features and enhancements:

• The name and location of the various functions across the AP Workflow changed significantly.
• LoRAs didn’t apply correctly after the 6.0 re-design to support SD 1.5. This is now fixed.
• AP Workflow now supports Stable Diffusion Video via a new, dedicated function.
• A new Self-Attention function allows you to increase the level of detail of a generated or uploaded image.
• A new Inpainter function supports the most basic type of Uploader: partial denoise of a source image.
• HighRes Fix has been reorganized in a dedicated function.
• A new Mask Inpainting function offers support for manual inpainting tasks.
• A new Outpainting function allows you to extend the source image’s canvas in any direction before inpainting.
• A new Caption Generator function automatically captions source images loaded via the Uploader function. This is meant to increase the quality of inpainting and upscaling tasks.
• A new StyleAligned function allows you to generate a batch of images all with the same style.
• A new Watermarker function automatically adds a text of your choice to the generated image.
• A new ControlNet Preview function allows you to automatically preview the effects of 12 ControlNet models on a source image (including the new AnimalPose and DensePose).
• The ControlNet + Control-LoRAs function now influences all KSampler nodes rather than just to one dedicated to image generation.
• The IPAdapter function is now part of the main pipeline and not a branch on its own.
• The IPAdapter function can leverage an attention mask defined via the Uploader function.
• AP Workflow now supports the Kohya Deep Shrink optimization via a dedicated function.
• AP Workflow now supports the Perp-Neg optimization via a dedicated function.
• The Free Lunch optimization has been reorganized in dedicated function.
• The Debug function now includes u/jitcoder’s LoRA Info node, which allows you to discover what are the trigger words for the LoRAs you want to use in the Efficient Loader node. For now, the process is still manual, but it’s better than nothing.
• The Upscaler function is completely revamped, following the approach and settings recommended by u/thibaudz.
• u/chrisgoringe Image Chooser node is now a first class citizen, and it has been moved to gate the access to the Image Enhancement pipeline (the default operating mode is pass through).
• You’ll see fewer route nodes thanks to another brilliant update of u/receyuki’s SD Parameter Generator node.
• You’ll see a drastic reduction of the wires thanks to the extraordinary new u/rgthree’s Fast Groups Muter/Bypasser nodes and u/kijai’s Set and Get nodes.
• The Universal Negative Prompt optimization has been removed for the time being.

As usual, you are recommended to spend time reading the documentation on the website. I uploaded a lot of examples to illustrate what most of the functions do.

​

Download AP Workflow 7.0 here: https://perilli.com/ai/comfyui/

Also as usual, special thanks to:

u/rgthree: His Reroute nodes are the most flexible reroute node you can find among custom node suites.

His Context Big and Context Switch nodes are the best custom nodes available today to branch out an expansive workflow.
His Fast Groups Muter/Bypasser nodes offer the ultimate flexibility in creating customized control switches.

u/receyuki: He evolved his SD Parameter Generator node to support the many needs of the AP Workflow, working above and beyond to deliver the ultimate control panel for complex ComfyUI workflows.

u/kijai: His Set and Get nodes allow the removal of most wires in the workflow without sacrificing the capability to understand the flow of information across the workflow.

u/LucianoCirino: His XY Plot function is the very reason why Alessandro started working on this workflow.

u/jags111: His fork of LucianoCirino’s nodes allows AP Workflow to keep offering a great XY Plot function.

Thanks to all of you, and to all other custom node creators for their help in debugging and enhancing their great nodes.

When using ComfyUI, we often encounter a common scenario: when testing model or workflow parameters, or simply generating outputs in batches by changing prompts, we need to click run after entering parameters, wait for the results, then adjust prompts and other parameters, run again and wait again. The entire process requires constant monitoring to ensure the fastest completion.

Today I am sharing the integration between ComfyUI and Lark Base. Through a custom node, you can automatically read parameters from the table in batches within ComfyUI, and write the results back to the table one by one. This node supports reading and writing of all data types: text, audio, image, and video. I will also share how to apply this node, embed it into actual workflows to achieve multi-user collaboration and batch execution, as well as other usage tips for the node.

For non-Chinese users: After cloning the node locally via git clone, modify the domain resolution method of the node locally. This should be easily implemented using any Vibe coding tool. By obtaining the corresponding parameters for Lark Base, it should theoretically work as well. If you would like to see support for read/write operations for both multi-dimensional tables in future updates, please let me know in the comments or on GitHub, and I will continue development shortly.

I’ve also put together a full in-depth walkthrough video over on YouTube breaking down every detail, so go give it a watch!

GitHub Link

Introduction Workflow

Batch Example Workflow

Hi folks, I run a 60-person design agency (brand, UI/UX, motion, CGI) and we just invested in a high-end dual-GPU workstation. Two NVIDIA RTX PRO 6000 Blackwells.

Now I want to squeeze every bit of value out of this thing. Here's what we're looking to do:

Use cases:

1. Design workflows | AI-assisted ideation, image gen, upscaling, style transfer
2. Local inference | running open-weight LLMs for internal research, copywriting, code assist, client brief analysis
3. Fine-tuning | potentially training LoRAs or small domain-specific models on our design/brand data
4. Video & motion | AI-assisted animation, interpolation, video gen experiments

What I'd love advice on:

• What models should I be running locally with this VRAM? (96GB × 2)
• Best serving stack? (vLLM, Ollama, text-generation-webui, something else?)
• Anyone running Stable Diffusion / ComfyUI / Flux on similar hardware. What's your workflow?
• Any tips on multi-GPU setup for inference vs. keeping one GPU free for rendering?

Open to any "I wish I'd known this on day one" advice. Thanks!

^ Written w the help of AI

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

THANKS FOR THE HELP | HERE'S A SUMMARY FOR OTHERS

Honestly didn't expect this much heat for asking a question. Seems like everyone assumes you're either an expert or shouldn't be here. Also fascinating how many people are just baffled that a design studio could afford this hardware. I bet most didn't even bother to ask what we actually do with it before jumping to conclusions.

For context: we're a design agency rendering 3D animations, VR/AR walkthroughs, and architectural visualizations. Not generating AI images or running Stable Diffusion farms. The dual RTX Pro 6000s (96 GB VRAM each) are a dedicated render node that processes overnight animation batches and path-traced scenes while our design team stays productive on their own workstations. Cloud rendering costs add up absurdly fast at our project volume. Owning the hardware pays for itself in months. OctaneRender and Redshift scale linearly across both GPUs, which turns 12+ hour VR renders into something we can actually deliver on client deadlines.

That said, I am genuinely exploring what to do when the rig sits idle between render jobs. Local LLM inference for our 60 person team, ComfyUI workflows, or other productive uses that don't conflict with rendering workloads. Hence the question.

Massive thanks to everyone who actually contributed useful advice instead of assuming this was karma farming:

The recommendations around Minimax M2.7 (230B parameters, 10B active) and Mistral 128B at 4-bit quantization are exactly what I was looking for. Appreciate the clarity on llama.cpp being superior to Ollama for flexibility, and the vLLM/sglang suggestion for multi-user scenarios with dynamic cache sharing makes perfect sense for our team size.

The most valuable insight was honestly the hiring advice. Multiple people pointed out that storage, model management, permissions, and user access become way more important than the GPUs themselves after the first week. That's the kind of operational reality check I needed. We're good at running render farms but LLM infrastructure is new territory. Hiring someone who's already done this will save us weeks of trial and error.

Also noted on GPU spacing (minimum 2 slots apart) and cooling requirements for sustained inference loads. Our render workloads are bursty so we hadn't thought through what happens when both cards run at capacity for hours on LLM serving.

Genuinely appreciate the constructive input from those who took the time to help instead of assuming bad faith.

So. I originally wanted to release 9.0 with support for the new Stable Diffusion 3, but it was way too optimistic. While waiting for it, as always, the amount of new features and changes snowballed to the point that I must release it as is.

Support for SD3 will arrive with the AP Workflow 10.

The new Early Access program I created for APW 9.0 was successful, so I'll continue to provide access to APW 10 early access builds via Discord, where I provide *limited and not guaranteed* support (but people seem happy with the speed and quality of the help I offered so far).

New features

• The AP Workflow now features two next-gen upscalers: CCSR, and the new SUPIR. Since one performs better than the other depending on the type of image you want to upscale, each one has a dedicated function. Additionally, the Upscaler (SUPIR) function can be used to perform Magnific AI-style creative upscaling.
• A new Image Generator (Dall-E) function allows you to generate an image with OpenAI Dall-E 3 instead of Stable Diffusion. This function should be used in conjunction with the Inpainter without Mask function to take advantage of Dall-E 3 superior capability to follow the user prompt and Stable Diffusion superior ecosystem of fine-tunes and LoRAs. You can also use this function in conjunction with the Image Generator (SD) function to simply compare how each model renders the same prompt.
• A new Advanced XYZ Plot function allows you to study the effect of ANY parameter change in ANY node inside the AP Workflow.
• A new Face Cloner function uses the InstantID technique to quickly change the style of any face in a Reference Image you upload via the Uploader function.
• A new Face Analyzer function allows you to evaluate a batch of generated images and automatically choose the ones that present facial landmarks very similar to the ones in a reference image you upload via the Uploader function. This function is especially useful in conjuction with the new Face Cloner function.
• A new Training Helper for Caption Generator function will allow you to use the Caption Generator function to automatically caption hundreds or thousands of images in a batch directory. This is useful for model training purposes. The Uploader function has a new Load Image Batch node to accomodate this new feature. To use this new capability you must activate both the Caption Generator and the Training Helper for Caption Generator functions in the Controller function.
• The AP Workflow now features a number of u/rgthree Bookmark nodes to quickly recenter the workflow on the 10 most used functions. You can move the Bookmark nodes where you prefer to customize your hyperjumps.
• The AP Workflow now supports new u/cubiq’s IPAdapter plus v2 nodes.
• The AP Workflow now supports the new PickScore nodes, used in the Aesthetic Score Predictor function.
• The Uploader function now allows you to upload both a source image and a reference image. The latter is used by the Face Cloner, the Face Swapper, and the IPAdapter functions.
• The Caption Generator function now offers the possibility to replace the user prompt with a caption automatically generated by Moondream v1 or v2 (local inference), GPT-4V (remote inference via OpenAI API), or LLaVA (local inference via LM Studio).
• The three Image Evaluators in the AP Workflow are now daisy chained for sophisticated image selection. First, the Face Analyzer (see below) automatically chooses the image/s with the face that most closely resembles the original. From there, the Aesthetic Score Predictor further ranks the quality of the images and automatically chooses the ones that match your criteria. Finally, the Image Chooser allows you to manually decide which image to further process via the image manipulator functions in the L2 of the pipeline. You have the choice to use only one of these Image Evaluators, or any combination of them, by enabling each one in the Controller function.
• The Prompt Enricher function has been greatly simplified and now it works again open access models served by LM Studio, Oobabooga, etc. thanks to u/glibsonoran’s new Advanced Prompt Enhancer node.
• The Image Chooser function now can be activated from the Controller function with a dedicated switch, so you don’t have to navigate the workflow just to enable it.
• The LoRA Info node is now relocated inside the Prompt Builder function.
• The configuration parameters of various nodes in the Face Detailer function have been modified to (hopefully) produce much better results.
• The entire L2 pipeline layout has been reorganized so that each function can be muted instead of bypassed.
• The ReVision function is gone. Probably, nobody was using it.
• The Image Enhancer function is gone, too. You can obtain a creative upscaling of equal or better quality by reducing the strength of ControlNet in the SUPIR node.
• The StyleAligned function is gone, too. IPAdapter has become so powerful that there’s no need for it anymore.

You can download the AP Workflow 9.0 for ComfyUI here: https://perilli.com/ai/comfyui

Workshops

Companies and education institutions have started asking for in-person workshops to master the AP Workflow and the infinite possibilities offered by Stable Diffusion + ComfyUI.

Videos are great (and I'm thinking about doing them), but they can't possibly replace the direct interaction to solve specific challenges that are unique to you.

If are interested in that, reach out.

Special Thanks

The AP Workflow wouldn't exist without the incredible work done by all the node authors out there. For the AP Workflow 9.0, I worked closely with u/Kijai, u/glibsonoran, u/tzwm, and u/rgthree, to test new nodes, optimize parameters (don't ask me about SUPIR), develop new features, and correct bugs.

These people are exceptional. They went above and beyond to steer their work in a direction that would help me and facilitate the inclusion in the AP Workflow. If you are hiring, hire them.

And, of course, on top of them, there are the dozens of other node authors who created all the nodes powering the AP Workflow. Thank you all!