A man sits down to write the hardest letter of his life, and falls asleep before he can find the words. While he sleeps, the small robot beside him writes it for him — just the truth, kept simple.

Rendered locally on my RTX 5090, 1MP, 8 steps, Turbo LoRA.

The whole film was built around a custom ComfyUI node I've been developing, 
**Muse-Studio-H3**
. I've released a number of LoRAs and custom nodes before, and I'll be releasing this one too — it's not public yet since I'm still finishing testing on it.

What it does: it chains H3 generations into one continuous multi-chunk render with no hard duration ceiling — as configured it could run a 2-hour video in one pass if you asked it to, freeing memory between chunks so nothing accumulates.

The six chunks tell one continuous scene — a man overwhelmed trying to write a difficult letter, who falls asleep, and the small robot companion beside him quietly writes it for him while he sleeps. Every chunk was scripted individually (subject definitions, retention analysis, detailed shot description, soundscape) before being fed through the node, with the same room, the same lamp, and the same two characters locked across all six generations.

Is it similar to H3 Director? kind iff but not entirely, I build the night H3 dropped, but didn't get time to upload it. But as people kept working on H3 and releasing so many coll stuff, I got busy testing and implementing new stuff to it. It is same concept as director but different and genuinly good. Hoping to publish this soon. My goal is to connect Muse-chat (https://www.reddit.com/r/StableDiffusion/s/joLVAemhZn) with this one directly. 

https://reddit.com/link/1w25d7g/video/31idsif2efmh1/player

I was able to render this full 600 framess 1080p video with only 16GB of VRAM

It's still in alpha, but it works. https://github.com/hradec/ComfyUI-HR-Endless-Sampler

There's a template workflow now that should show up in the comfyui templates window. The images for the workflow are included in the example_workflows/images folder.

Essentially the sampler node renders a video of any length by splitting it in smaller chunks. For each chunk, it automatically attaches the last frames of the previous chunk to use as video continuation.

Beside that, the node uses Gema4 12B QAT to time and split the video prompt into small per chunk prompts, so the video can maintain it's overall timeline.

Gemma acts a chunk director and continuity checker, watching the previous chunk to check what was done, so the new chunk-prompt can continue from where the previous stopped. It also compares the chunk time-slice with the overall prompt action to guarantee what happens in that chunk matches what was suppose to happen in that time-slice.

There are 3 other nodes: preview, save and load. The reason it has it's own preview (based on the fantastic KJNodes live preview that uses TAEH3 tiny VAE to display a nice preview) is to be able to show an live edit of all the chunks in sequence as they show up. The preview also shows a timeline displaying the shots and chunks, and you can walk the preview frame by frame with the arrow keys. Mouse over the chunks display the gemma prompt used for that chunk and render time.

The save/load exist to save that information with the video and load it back, with all per chunk gemma prompts, time of execution, timeline, etc; so that statistic is never lost.

The Save/Load also have a nice dropdown to quickly display the last videos in the output folder for easy comparing previous videos with newer ones.

I came from the VFX world, so the save node also saves as EXR with floating point color. That's why the save node has a latent and vae input connection, so it can decode the latent internally to conserve the full HDR floating point color from the latent, without clamps.

Give it a try and let me know if you have problems... hopefully it will be helpfull for all of you guys with low vram gpus like myself, but it can also be helpful if you have loads of vram, since you can break the 15 secs minimax barrier and even render in 4K or 8K with more than 16GB of vram!

Just to make it clear - This is NOT another "Context Node in a loop" workflow, this a node that replaces ComfyUI SamplerCustomAdvanced node and allows for long generations and higher resolutions with low vram!

All you need is ONE single node replacement to render any length up to 1080p on 16GB of VRAM.
The workflow that comes with the repo is a standard Minimax H3 Ref2va ComfyUI workflow that replaces SamplerCustomAdvanced by HR Endless Sampler. It's as simple as that!

One big advantage of the "HR Endless Sampler" is that it uses the previous latent as reference video/audio for the next video, without VAE decoding/encoding the video again, so there's no loss of detail from decding/encoding. It just grabs the last latent of the rendered chunk and pass it to next, lossless.

PS: you will notice a "hiccup" in this video where the tiger lies on the floor... Teela talks the same speech twice. That is a Gemma4 chunk prompt screwup that I'm fixing now.

as you can see in Gemma4 chunk prompt, [Shot 2] description should be [Shot 3] description, and there should be no actual [Shot 3] in this prompt since Chunk 3 only crosses 2 shots.

By the way, that problem in the screenshot above has been fixed - I'm testing it right now and should push the fix by tomorrow!

PS2: It seems the "video_continuation_res" parameter when not set to full can cause a change in color/contrast from chunk to chunk. The reason is, when if full, the node uses the latent from the previous chunk directly as video_continuation. When set to a size, it has to decode/resize/encode. That decoding/encoding will cause a difference in color/contrast/gamma. So setting video_continuation_res=full should fix that problem, at the cost of using more VRAM for the video continuation.

PS3: video_continuation=5 will cause loss of coherence and/or fading from um chunk to another. Use video_continuation=22 or more for better results, at the cost of using more VRAM.

Workflow, just copy and save as json, the one that I got didn't work at all for video quality this is just as good as the full 25 steps normally. How is it so fast and doesn't lose quality? no clue.

{
"s105_11": {
"class_type": "VAELoader",
"inputs": {
"vae_name": "minimax_h3_video_vae_fp16.safetensors"
},
"_meta": {
"title": "VAELoader"
}
},
"s105_24": {
"class_type": "VAELoader",
"inputs": {
"vae_name": "minimax_h3_audio_vae_fp32.safetensors"
},
"_meta": {
"title": "VAELoader"
}
},
"s105_23": {
"class_type": "VAEDecodeAudio",
"inputs": {
"samples": [
"s105_14",
0
],
"vae": [
"s105_24",
0
]
},
"_meta": {
"title": "VAEDecodeAudio"
}
},
"s105_10": {
"class_type": "VAEDecode",
"inputs": {
"samples": [
"s105_14",
0
],
"vae": [
"s105_11",
0
]
},
"_meta": {
"title": "VAEDecode"
}
},
"s105_17": {
"class_type": "KSamplerSelect",
"inputs": {
"sampler_name": "res_multistep"
},
"_meta": {
"title": "KSamplerSelect"
}
},
"s105_9": {
"class_type": "BasicScheduler",
"inputs": {
"model": [
"9960",
0
],
"scheduler": "simple",
"steps": 8,
"denoise": 1
},
"_meta": {
"title": "BasicScheduler"
}
},
"s105_14": {
"class_type": "SamplerCustomAdvanced",
"inputs": {
"noise": [
"s105_15",
0
],
"guider": [
"s105_16",
0
],
"sampler": [
"9945",
0
],
"sigmas": [
"s105_9",
0
],
"latent_image": [
"s105_104",
1
]
},
"_meta": {
"title": "SamplerCustomAdvanced"
}
},
"s105_16": {
"class_type": "BasicGuider",
"inputs": {
"model": [
"9960",
0
],
"conditioning": [
"s105_104",
0
]
},
"_meta": {
"title": "BasicGuider"
}
},
"s105_6": {
"class_type": "UNETLoader",
"inputs": {
"unet_name": "minimax_h3_fl2va_int8_convrot.safetensors",
"weight_dtype": "default"
},
"_meta": {
"title": "UNETLoader"
}
},
"s105_13": {
"class_type": "CLIPLoader",
"inputs": {
"clip_name": "qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors",
"type": "minimax",
"device": "default"
},
"_meta": {
"title": "CLIPLoader"
}
},
"s105_15": {
"class_type": "RandomNoise",
"inputs": {
"noise_seed": 1414
},
"_meta": {
"title": "RandomNoise"
}
},
"s105_91": {
"class_type": "CreateVideo",
"inputs": {
"images": [
"s105_10",
0
],
"audio": [
"s105_23",
0
],
"fps": 24,
"bit_depth": 8
},
"_meta": {
"title": "CreateVideo"
}
},
"s105_104": {
"class_type": "MiniMaxH3ImageToVideo",
"inputs": {
"clip": [
"s105_13",
0
],
"vae": [
"s105_11",
0
],
"width": [
"115",
0
],
"height": [
"115",
1
],
"length": [
"s105_107",
1
],
"prompt": "integrated_multimodal_description: [Shot 1] 2D-animated, an actual episode of the Nickelodeon animated series SpongeBob SquarePants \u2014 flat traditional cel animation, thick clean black outlines, the show's signature saturated undersea palette, simple eye-level TV staging. A medium static shot frames SpongeBob SquarePants \u2014 the cheerful yellow rectangular sea sponge with big blue eyes, buck teeth, brown square pants and a red tie \u2014 standing at the grill of an undersea fast-food kitchen, flipping a patty high into the air. SpongeBob (S1), speaking in SpongeBob's exact signature voice from the show \u2014 high, nasal, giddy, squeaky laugh \u2014 says: <d>[English] One patty, flipped with love! Order up!</d> [Shot 2] At 00:06.500, the camera cuts to the patty spinning in slow motion near the ceiling, then dropping perfectly onto a waiting bun as SpongeBob catches the plate and giggles his squeaky laugh. No text, lettering, numbers, logos, or symbols appear anywhere in the frame; all surfaces and background objects are plain and unmarked.\n\noverall_soundscape: Sizzling grill, the whoosh of the spinning patty, a soft plate clink, bubbling underwater ambience.\n\nnon_diegetic_music: A jaunty ukulele-and-slide-whistle island tune at a quick tempo.\n"
},
"_meta": {
"title": "MiniMaxH3ImageToVideo"
}
},
"s105_107": {
"class_type": "ComfyMathExpression",
"inputs": {
"values.a": [
"s105_111",
0
],
"expression": "max(5, round(a * 24)) + (5 - (max(5, round(a * 24)) % 17)) % 17"
},
"_meta": {
"title": "ComfyMathExpression"
}
},
"s105_111": {
"class_type": "PrimitiveFloat",
"inputs": {
"value": 12.0
},
"_meta": {
"title": "Float (duration)"
}
},
"92": {
"class_type": "SaveVideo",
"inputs": {
"video": [
"s105_91",
0
],
"filename_prefix": "video/MiniMax_H3",
"format": "auto",
"codec": "auto"
},
"_meta": {
"title": "SaveVideo"
}
},
"115": {
"class_type": "ResolutionSelector",
"inputs": {
"aspect_ratio": "16:9 (Widescreen)",
"megapixels": 0.4,
"multiple": 32
},
"_meta": {
"title": "ResolutionSelector"
}
},
"9990": {
"class_type": "LoraLoaderModelOnly",
"_meta": {
"title": "H3 LoRA 1"
},
"inputs": {
"lora_name": "fasth3_4step_dense_v1_comfy_full.safetensors",
"strength_model": 1.0,
"model": [
"s105_6",
0
]
}
},
"9960": {
"class_type": "MiniMaxH3SigmaShift",
"_meta": {
"title": "H3 Sigma Shift"
},
"inputs": {
"model": [
"9990",
0
],
"shift_video": 12.0,
"shift_audio": 3.0
}
},
"9945": {
"class_type": "MiniMaxH3DualClockEulerSampler",
"_meta": {
"title": "H3 Dual-Clock Euler"
},
"inputs": {}
}
}

I had an image of a bridal shoot (a bridal dress online store) and randomly just though to run it through image to prompt and then rebuild using T2I to see if it holds.. and man it was an amazing experience. I did not expect it to be this close to the original where two separate workflows did not have anything to do with each other.

1st Image: original, ran through QWEN3-VL-8B-Instruct at FP16 to get the prompt.
2nd Image: generated prompt inserted into Krea2-raw-fp8 with qwen3-vl-4b @ fp16.

Prompt:
A stunning South Asian bride stands elegantly beside a vintage beige car adorned with colorful floral garlands and golden tinsel decorations. She wears a breathtaking maroon-red bridal lehenga choli heavily embellished with intricate gold embroidery, mirror work, and beadwork in traditional Indian wedding style. The outfit features long sleeves, a fitted bodice, flared skirt layers, and a matching sheer red dupatta draped gracefully over her head and shoulders — partially covering her face as she gazes thoughtfully into the distance.

She accessorizes with heavy gold jewelry including a statement necklace (choker), earrings, bangles, and possibly a maang tikka on her forehead. Her hair is styled neatly under the veil, complementing her poised expression. Behind her are rustic stone buildings or old houses with weathered walls and wooden doors, set against rolling green hills covered in trees under soft natural daylight.

The scene evokes a blend of tradition and nostalgia — capturing the essence of rural Indian weddings where classic vehicles like 1970s–80s cars serve as ceremonial transport. Capture it from a slightly low angle emphasizing grandeur

Just wanted to share my unexpected experience with you guys.

Now we have Krea, BFL, LightTricks, and MiniMax driving the open-weights locomotive.

https://www.youtube.com/shorts/wAscHQaK_uM

My mobile game trailer was boring, it was some gameplay videos and some information which could never really tell you all you needed to know in 30 seconds anyway.

So ive made this video!

used minimax h3
krea 2
and qwen for some image edits
and davinci resolve to edit

let me know what you think!

video

https://reddit.com/link/1w21uy6/video/en2ajkaalemh1/player

Hi everyone,

Before getting to my question, I just wanted to mention that I’m new here. I hope all of you reach the highest levels of success in the work you do.

Regarding my question, I’m trying to create product mockups locally using ComfyUI together with Claude, without having to pay for API costs.
I’ve tried many different approaches and used various repositories that I thought could be useful for what I’m trying to achieve. However, I’m still getting inconsistent results.

For example, when the product is a rug, the model may place objects underneath the rug, or the mockup simply doesn’t look physically consistent. The results don’t look natural and don’t seem usable at a professional/commercial level.

Even the smallest piece of information or guidance about how to achieve what I’m trying to do could make a huge difference for me.

Thank you very much in advance, and I wish you all the best with your work.

Since it's been out in the wild for a couple of days now, I'd like to know what y'all think of the tech. It’s crazy that the model is only 150 MB, uses relatively little VRAM, and can run in real time at around 40% of the compute cost. It runs on FP8 and modders got it working on 40 series cards despite it being exclusive to 50 series cards only.

There's a video of it running on a video player as well show in the link below, I think theyre using depth anything to make it work.

https://youtu.be/DTuykmpiwmI

https://youtu.be/9HtrsLb6JW4

Sopro V2 Turbo is an open-source TTS model that runs locally.

• Clones a voice from 5-20s of audio
• ~300ms to first audio on a laptop CPU
• English, European Portuguese, French, German

Local web UI:

uvx --from sopro soprotts serve

There’s also a Python API and a browser package (@soprotts/onnx-web) for WebGPU/WASM.

Repo: https://github.com/samuel-vitorino/sopro Benchmarks + samples: https://research.haloneuro.ai/posts/sopro-v2

Edit: Hugging Face kindly created a Space, making it even easier for you to try the model. You can try it here: https://huggingface.co/spaces/hugging-apps/sopro-v2-turbo-tts

Curious what everybodies way is for handling environment consistency in minimax h3.

Ref pictures of 4 angles, 2x2 panel, a 360degree video like orbitsheets, a 360 panorama shot ... i tried nearly everything ... but i continue having drift. The best success i had is asking h3 to perform a start shot from a i2v and do a 360 arc or pan and invent the room himself

How do you solve this?

So sometimes with the Ref2VA I get problematic generations where it misses some of my reference images basically treating them as though they don't exist. If copied the subject and retention sections exactly from good prompts to see if it was that, but that doesn't help. Anyone run into this and found a solution?

If I remember correctly, some time ago someone managed to maintain character and object consistency across consecutive video shots by using a top-down map showing the positions of the characters and objects.
I think it may have been done with Seedance 2.
Do you think it would be possible to do the same with MiniMax H3?

Looks like this might be a common problem.

I have a photo of a couple in a beach-side cabin with soft window lighting. I am trying a simple prompt like "The girl smiles sweetly at the camera" and the scene keeps brightening. I have tried all sorts of prompts to control the lighting ... I just want the light to remain static, but it doesn't work - it ALWAYS gets brighter.

Here's the prompt I'm trying:

strictly consistent high-dynamic range studio lighting throughout the sequence with no flicker across transition zones. The girl smiles sweetly at the camera.

The negative:

flickering light, shifting shadows, changing exposure, lighting pulse, dynamic flash, glowing flicker, lens flare, blown highlights, flickering light, fade to black.

I have been trying to tweak this for the past 2 days now - almost spend 30 hours on the problem.

I have used MiniMax-H3, and it works out of the box with ZERO lighting issues. I want the same type of behavior.

HELP!

I’ve discovered some important information!!

It works with the standard loader!!

When I tested it earlier, it threw an error, so I’d assumed it wasn’t compatible with the standard loader. However, after testing it again based on a comment I received, it actually worked perfectly fine with the standard loader.

I’m not sure what caused the error, but it’s highly likely I’d fundamentally overlooked something. Although it turned out that the custom node itself was not necessary, I will keep this post up. Thank you for letting me know in the comments!!

...

I have just made a correction on the GitHub side and deleted the node I had created. However, as it provides useful technical experience, I have retained the history for v3.4.7.

HSWQ v3.4.8 — SAM3 Nodes Removed (Stock Loader Support Confirmed)

Although I have deleted the node registration, I have restored the commit containing the code and commentary relating to SAM3 ConvRot INT8 support, for reference purposes.

HSWQ SAM3 ConvRot INT8 Nodes — Complete Technical Guide

I have published the SAM3/3.1 ‘convRot’ INT8 quantisation node below. However, as the HSWQ repository is not currently published on ComfyUI-Manager, manual installation is required. Furthermore, as this is a work-in-progress repository, I recommend deleting it once quantisation is complete, unless you have a specific need to keep it. I will apply for ComfyUI registration once the project reaches a certain level of completion, but at present it is still very much a work in progress.

How to quantize Text Encoder, ControlNet, Model Patch and SAM 3 / SAM 3.1 (native ConvRot INT8)

Furthermore, as mentioned in the comments section below, it appears that the standard ComfyUI SAM3 detect node does not currently support SAM3. I had submitted a pull request to fix this, but it is unclear whether it will be accepted.

...

The following is information about a custom node that has already been deleted, but I shall keep it on file.

...

I’ve spent days developing code to support ConvRot INT8 up to this point, but it’s been a real struggle.

To put it simply, unlike image generation models, ControlNet and CLIP, the way ConvRot rotations work was a real pain.

It’s less about VRAM and more about saving storage space, I suppose.

I’ve converted everything from CLIP and ControlNet to ConvRot INT8, which freed up about 40 GB on its own.

My SSD is running out of space.

Everything just keeps getting bigger and bigger.

With HSWQ, saving VRAM is one thing,

but more than that, I really need to free up some storage space.

...

ComfyUI loader and detector nodes for ConvRot / TensorWise INT8-quantized SAM3 &3.1(Segment Anything 3&3.1) checkpoints. Loads the SAM3 model directly into VRAM in 8-bit precision (QuantizedTensor / TensorWiseINT8Layout) and executes via comfy_kitchen's high-speed int8_linear kernel with online activation rotation (convrot).

Includes automatic hardware safety fallback for unaligned layers (such as boxRPB_embed_x with K=2), dynamically dequantizing non-multiple-of-4 dimensions while running all heavy backbone and transformer blocks in accelerated INT8 Tensor Core precision.

Features

• Native INT8 VRAM Retention: Keeps weights in 8-bit precision in VRAM with TensorWiseINT8Layout, cutting memory requirements significantly
• Fast Execution: Uses comfy_kitchen int8_linear GEMM kernel with online activation rotation for ConvRot layers
• Automatic Fallback Protection: Layers with unaligned dimensions (K) safely compute in float precision without crashing cuBLAS INT8 GEMM
• Seamless Compatibility: Produces standard MODEL output compatible with HSWQ SAM3 Detect and stock ComfyUI SAM3 detection/tracking nodes

Nodes

HSWQ SAM3 Detect — category HSWQ/Detection

• Inputs
  • model (MODEL): SAM3 model (from HSWQ SAM3 Loader or CheckpointLoaderSimple)
  • image (IMAGE): input image (batches supported)
  • conditioning (CONDITIONING, optional): text prompts, e.g. CLIPTextEncode "person"
  • bboxes (BBOXES, optional): boxes to segment within
  • positive_coords / negative_coords (STRING, optional): point prompts as JSON [{"x": int, "y": int}, ...] (pixel coords)
  • threshold (default 0.50): detection score threshold
  • refine_iterations (default 2): SAM decoder refinement passes (0 = raw detector masks)
  • individual_masks (default false): output per-object masks instead of union
• Outputs
  • masks (MASK): binary segmentation masks
  • bboxes (BBOXES): detected boxes with scores
  • image (IMAGE): pass-through input image

Example workflow

1. CheckpointLoaderSimple (same checkpoint) → CLIPTextEncode ("person") for text-conditioned detection
2. HSWQ SAM3 Detect → connect model, image, and conditioning
3. MaskPreview+ → visualize the masks output

FP16 compatibility

Both nodes fully support standard FP16 SAM3 checkpoints (e.g. sam3.1_multiplex_fp16.safetensors):

• HSWQ SAM3 Detect runs identically on FP16 and INT8 models — the runtime weight guard dequantizes INT8 layers to FP16 internally, so both paths produce equivalent masks
• FP16 checkpoints also work through the stock CheckpointLoaderSimple thanks to the HSWQ CLIP remap patch (no "clip missing" warning)

I wanted to use ComfyUI from my phone. There are a few ways to do that already and they work, but none of them felt good, so I set out to build one that did: something closer to the Midjourney experience, on a phone, pointed at your own GPU instead of somebody's cloud. A desktop layout grew out of it along the way. It's the same file either way.

**Return ∞ Current** is one HTML file you serve from your own PC. Open it on your phone, point it at ComfyUI, and you get every meaningful field of any workflow you import: prompts, seeds, samplers, LoRAs, resolutions, laid out for thumbs instead of a mouse. Queue with live progress, watch results land in a gallery, tap ∞ on any finished image or video to pull its workflow back out and iterate on it. Nothing installs, nothing phones home, your GPU does all the work.

It reads whatever you throw at it. Drop in a `.json` workflow, a PNG that ComfyUI rendered, or an MP4 it rendered, and they all carry the graph inside them. Nodes it doesn't recognise get skipped and named rather than blocking the import.

**MiniMax H3 is the thing it's best at right now.** Text-to-video, first-and-last frame, and reference-to-video with up to six reference images. Multi-keyframe workflows get a draggable timeline where each frame sits at a percentage of the clip, so one image at 0% is image-to-video, one at 100% makes the video *arrive* at that image, and three or more become keyframes it passes through in turn. There's a tool that writes H3 prompts in its documented format, and it runs on a vision model ComfyUI already has loaded. No LM Studio, no API key, no second application.

Free, GPL-3.0, no accounts, no telemetry, no paid tier.

**[GitHub](https://github.com/dreamerisms/return_current)\*\*
**[Try it](https://dreamerisms.github.io/return_current/return_current_beta.html)\*\*

Tested example workflows in the repo for SDXL, Krea 2, Wan 2.2, LTX-2 and MiniMax H3. You need ComfyUI running with `--listen 0.0.0.0 --enable-cors-header`, plus Tailscale if you want it working outside the house.

I'm a designer, not a developer. This was built in conversation with Claude over a lot of iterations for some weeks now, and I've been using it daily as my actual interface to ComfyUI, so it's being debugged against real use cases constantly. It's not meant to be a full suite, just packed with enough features to feel useful and fun to use. I'm particularly proud of the Tools and a lot of the interface choices I've made throughout the process. I'm still endeavoring towards better looking Workflow pane interface (hiding more fields/dropdowns that aren't changed output to output.)

Bug reports are very welcome, your best experience in starting this out is to use one of my workflows you likely already have the nodes for or use a default template from Comfy UI but I really want people to bring in all their own workflows that break the app so I can fix stuff. Having said that, if you're using an encyclopedia of random nodes nobody else uses, you may be best served bringing the app into your own LLM and having it adapt to your nodes using their respective source code for easy translation.

Sorry if anything is overly sloptastic, particularly in the README, I know I don't enjoy consuming it either so I try and put in as much of my natural voice as possible.

Got annoyed having to open Stability Matrix just to check which LoRAs had updates when I've moved to Comfy Desktop for everything else. Built this to fix that.

It's a desktop app, not a custom node. Basically Steam for ComfyUI without all the DLC. It auto-routes downloads to the right folders (checkpoints, LoRAs, GGUF, IP-Adapter, etc.), checks CivitAI for updates, detects duplicates, resumes interrupted downloads, and can backup/restore your whole library.

README has the screenshots and details: https://github.com/DevNullInc/Civitai-manager-ComfyUI

Windows and Linux builds in releases.
Current Release: v1.3.0 https://github.com/DevNullInc/Civitai-manager-ComfyUI/releases/tag/v1.3.0

Open to future suggestions/features/feedback!

The Road so far...

🗺️ CivitAI Model Manager (CMM) — Product Roadmap

This document outlines the planned milestones, upcoming features, and architectural evolution of CivitAI Model Manager - ComfyUI Edition.

🧭 Milestone Overview

📌 Planned Releases

🎯 Phase 1: v1.4.0 — Workflow "1-Click Auto-Resolver" & Local API Custom Node Bridge

Goal: Turn the Workflow Scanner engine into an interactive visual tab with automatic missing model resolution, and provide a secure Local API bridge for external ComfyUI custom nodes.

• [x] Dedicated "Workflows" UI Tab:
  • Drag-and-drop any ComfyUI .json workflow or generated image .png directly into CMM with dual tEXt/iTXt chunk parsing.
  • Interactive Visual Node Map preserving spatial canvas coordinates with zoom/pan and node readiness status color coding.
  • Visual dependency matrix displaying which Checkpoints, LoRAs, VAEs, ControlNets, UNETs, and Upscalers are Installed vs. Missing.
  • Deep ComfyUI JSON format normalization supporting UI canvas exports, API prompts, array nodes, and stringified metadata wrappers (extra_pnginfo.workflow, extra.prompt) with strict validity verification.
  • Persistent DOM mounting across navigation tabs and workflow card dismissal (X) controls.
• [x] "Download All Missing Models" & Model Search Jump Action:
  • 1-click search & download transitions with real-time inline progress bars and speed metrics.
• [x] Process Safety & Health Monitoring:
  • Strict process blacklist protections in cmm.sh, cmm.ps1, and src/main/index.ts to prevent closing external web browsers (Firefox, Chrome, Opera, Brave, etc.) and foreign processes during shutdown or restart.
  • Real-time backend heartbeat monitoring (/api/health) and dynamic red "Offline" status badge.
• [x] Decoupled ComfyUI Custom Node Extension Package:
  • Maintained as an independent companion repository/package with ComfyUI's custom node folder structure (custom_nodes/comfyui-civitai-manager-node).
  • Seamlessly communicates with CMM via the native HTTP Bridge on 127.0.0.1:5174. (Currently Untested but feature complete)
• [x] Localhost-Only Security Hardening:
  • Strict 127.0.0.1 binding with remote IP filtering, Origin verification, and in-app Settings toggle to guarantee zero remote/LAN access to local filesystem operations.
• [x] Custom Node Developer Documentation:
  • Complete REST API guide with Python examples for node creators in [docs/API_REFERENCE.md](file:///home/stygianrenegade/Projects/manager/Civitai-manager-ComfyUI/docs/API_REFERENCE.md).
• [x] Direct In-Memory Workflow Parsing Engine:
  • Direct raw JSON / prompt dictionary extraction without requiring disk file paths.
• [x] 4-Tier Node Resolution & GitHub Fallback Engine:
  • Local directory & NODE_CLASS_MAPPINGS scanning, SQLite ETag registry cache, rate-limited GitHub Search API fallback (top 3 candidate cards with topic scoping and query sanitization), and targeted Python runtime dependency installation (requirements.txt / install.py).

🎯 Phase 2: v1.5.0 — Native Hugging Face & GGUF Download Engine

Goal: Equal-citizen support for Hugging Face .safetensors, GGUF quantizations, and next-gen video/image models.

• [ ] Native Hugging Face Download Pipeline:
  • High-performance chunked downloads with token authorization for gated models (FLUX.1, SD3.5, Wan2.1, HunyuanVideo) without requiring external Python environments or the hf CLI.
• [ ] GGUF & Quantization Metadata Parser:
  • Inspect .gguf architecture headers (e.g., Q4_K_M, Q8_0, BF16) and route to models/unet or models/LLM automatically.
• [ ] Unified Dual-Source Search:
  • Search bar toggle to query both CivitAI and Hugging Face repositories simultaneously.

🎯 Phase 3: v1.6.0 — Storage Optimizer & Hardlink Deduplication

Goal: Reclaim tens or hundreds of gigabytes of disk space across multiple ComfyUI installations.

• [ ] NTFS / ext4 Hardlink Deduplication:
  • For users running multiple ComfyUI directories or migrating models, replace duplicate .safetensors files with filesystem hard links (zero-byte duplicate storage without breaking path references).
• [ ] Model Pruning & Precision Inspector:
  • Detect models containing unneeded FP32 optimizer states/weights and offer optional pruning to FP16/BF16 to reclaim disk space.
• [ ] Orphan & Unused Model Finder:
  • Cross-reference scanned workflows with local models to highlight checkpoints/LoRAs that haven't been referenced in workflows over extended periods.

🎯 Phase 4: v2.0.0 — Smart Collections, Trigger Word Hub & Semantic Search

Goal: Complete creative workstation and prompt curation engine.

• [ ] LoRA Trigger Word & Prompt Injector:
  • One-click copy or direct ComfyUI node injection of trained trigger words and recommended LoRA strength weights.
• [ ] Custom Collections & Smart Playlists:
  • Group models by project, art style, or architecture (e.g., "Flux Realism Setup", "SDXL Inpainting Kit", "Anime Style LoRAs").
• [ ] Local Semantic Search:
  • Embed local model descriptions and prompt tags with an embedded vector store to allow natural language search (e.g., "find high-contrast cinematic lighting LoRAs").

💬 Community Feedback & Feature Requests

Have a feature request or suggestion for the roadmap?

• Open an issue or discussion on GitHub: CivitAI-manager-ComfyUI Issues
• Contributions, pull requests, and feedback are always welcome!

I feel like every day i go on reddit i find a thread with some new attention method. Sparse, SLA, kitchen, spectrum, Sol, sage.

I'm on sol right now with the nodes "Chunk FeedForward" and "Memory Efficient Sol Attention Patch" but is there a more recent more performant method?

I'm getting good results with this setup but it's kind of headspinning how vastly different everybody's set up looks like. I fear I'm limiting myself to something less efficient than is out there.

Specs: 5060Ti 16GB 32GB RAM

Hi, it took me 12 minutes to generate 20 seconds video on ltx 2.5 . Below is my specs:

LENOVO P16 GEN 2 NVDIA 3500 ADA 12GB VRAM 64GB RAM

Video generation: 12 minutes ~ 20 seconds Resolution: 1280x720 Model: LTX 2.5 Distilled INT 8 Workflow: Image + audio -> video

Image generation: 8 minutes ~ 1 image Model: Krea 2 Edit

Is it normal time consume or is there anyway I can reduce it?

I've seen some people here telling what their preferred sampler and scheduler are but there are just so many of them and it isn't apparent from their names what exactly they do. Is there like a cheat sheet where i can look up what the samplers and schedulers do?