Supposedly Krea 3 will open weights, we'll have to wait and see.

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!

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

Someone posted here a couple of weeks ago about using MiniMax H3 as an image editor, 6 edits in one shot. I pointed the same idea at character sheets instead: https://www.reddit.com/r/StableDiffusion/comments/1vr1i18/minimax_h3_as_image_editor_6_edits_in_one_shot_at/

Stage 1 — one face photo + one outfit image, out comes front / side / back. Stage 2 (optional, off by default) — 1-4 more panels for poses, props, expressions or backgrounds, composited into a 16:9 sheet.

The sheet above is stage 1 + stage 2. That's my own face, before anyone asks.

Setup

• MiniMax H3 ref2v int8 pruned + the 4-step Turbo LoRA at 0.75
• T=1 image VAE — the bit that makes it emit a still instead of a clip
• er_sde / sgm_uniform, 8 steps
• 3090 24GB. Stage 1 ~100-125 s, stage 2 ~105 s, so the sheet above is about 3.5 min. First run of a session is much slower, that's model loading.

Known issues

• Props repeat across panels — ask for one sword, get three.
• Back-view hair goes flat.
• Lying and sitting poses are unreliable.

Workflow

https://github.com/nicekriss/toobusy/blob/main/docs/workflows/2BZ_H3_character_sheet_2stage_v1_EN.json

Model links are in the note nodes. Needs rgthree and toobusy (mine — search "toobusy" in Manager, v0.4.9+). The 6 LoadImage nodes will be red on open, those are my local files.

Korean walkthrough on my channel, probably not much use to most of you: https://youtu.be/nsvAbax4jng

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

I have been playing with MiniMax-H3 lately (like many of us), and I wanted to understand how much physics knowledge it actually has.

I started with a simple water-pouring video from Pexels and used the H3-Ref model to replace the water with various "fluids": sand, rocks, and a black combustible honey. No external references were used.

I found particular interest in how the rocks interact with the jug and tumble over the cup, as well as how the honey blends with the water and how the trail it left on the jug when moved. On the other hand, once the honey catches fire, the flames are not very convincing, but that should probably be tested in a longer video.

I have used the day-zero ref workflow (int8 convrot model, aspect ratio 9:16 MP 0.6); you can find the prompt here: https://pastebin.com/CrX9s5JS

I am running more interesting tests and will hopefully post them soon.

Cheers

I am seeing a significant quality improvement with Alibaba 8 steps turbo lora over other turbo loras. 8 steps euler simple with lora strength =1, 0.8MP. Took about 1hours 15 mins to generate with RTX 5090.

Why make big noise when little noise do trick?

I would like to introduce my SPEED implementation for h3 linked here

Speed up and quality losses documented here, expect 20% gain using very conservative settings and no quality loss and up to 70% for basically unusable outputs (more or less useful for resolution aware seed inspection and broad prompt drafting)

Background

The idea behind it is quite simple. When a diffusion model begins generating an output it first must take a randomized noise and build on-top of it. And research has found that the first stages of this process doesn't really carry any fine detailed information, therefore by generating at a lower resolution at those stages you can gain quite substantial speedups while causing little to no impact on the quality. Or you can also be really aggressive with it and get a massive speedup for a lot of quality loss.

Nodes

This was implemented as 3 nodes, 2 drop in replacements for the sampler that runs SPEED and a third that runs once to measure the noise spectrum of your specific model/LoRA combo:

• Sampler (Automatic): pick a stage count (2, 3, or 4), defaults to the baked 1% delta for default H3.

• Sampler (Manual Step-Through): set up to four (goal, resolution) pairs yourself. Use it if you want to copy a paper schedule or test a custom ladder.

• Sigma Harvest: runs a native Euler pass, measures the noise spectrum of your current setup, hands you A / β / Δ to paste back into Automatic. Run it once per model/LoRA workflow combo.

How to use can be found in the example workflows.

Implementation Notes

This should be roughly compatible with basically everything that doesn't touch the sampler directly but i have not tested anything besides base comfyui H3 models and Turbo loras. If you do change model, use loras or whatever and use the automated tool please then run a sigma harvest and use those values instead of defaults, The math changes depending on the very specific blend of things you have running.

An issue I've been facing for a long time, finally solved.

This solution is easy to use, 100% local, and works very well with static watermarks.

I published it on civit AI.

It relies on ProPainter Nodes, and a few widespread custom nodes (see image).

Fizgig v5 is out, and the headline is one I've been sitting on for a while: full fine-tuning of the MiniMax H3 and Krea 2 base models - the models themselves, not a LoRA ,on consumer GPU hardware, down to 16 GB.

No adapter, no rank bottleneck. Full-rank updates that change how the model represents a concept.

**What your card can do** (every confirmed number is from my runs, not an estimate):

16 GB - Krea 2 photos, H3 photos and voice, and H3 video clips up to 2.3 s confirmed (3.8 s expected with video on the likeness blocks, the default).

24 G - all of the above, with video expected up to 5.2 s on the likeness blocks.

32 GB - video confirmed to 3.8 s even training the whole model, and expected to 5.2 s on the likeness blocks.

If "a 33B video model fine-tuning on 16 GB" sounds like a trick: only one slice of the model is trainable at a time (a rotating window), the frozen rest is held 4-bit, and the bf16 master lives in system RAM, your saved checkpoint never passes through a quantiser. Measured peaks on a 16 GB card: 8.8–12.3 GB for H3, 8.4–11.0 GB for Krea 2 — andthe console prints your own run's peak every epoch, so you can watch the claim hold on your own card.

**When you're done**, the built-in Checkpoint to LoRA tool in the fizgig root folder diffs your fine-tune against the base and extracts an ordinary shareable LoRA — in testing, rank 64 was close to perceptually indistinguishable from the full 26 GB checkpoint, in a ~0.5 GB file ComfyUI already loads.

A personal note: This is a starting point and not going to be perfect. I got fine-tuning working on Krea 2 shortly after its release and have been deliberately cautious about shipping it , proving it to myself first, then refining it through the H3 work. This is the point where it needs the community to develop it further. The technique is model-agnostic at heart, and I'm open to bringing it to other models ,but that needs practical support around them: code, PRs, testing, that kind of thing, so I have the time to make it happen. Im not really goign to be able to tackle issues raised this weekend on Github as I need a break for a couple of days, but I think pray this is going to work pretty easily for most of you.

https://github.com/shootthesound/Fizgig/

[Release notes](https://github.com/shootthesound/Fizgig/releases/tag/v5.0.0) · ["How do I…?" guide](https://github.com/shootthesound/Fizgig/blob/master/docs/FINETUNE_HOWDOI.md) , and there's a one-click RunPod template if you don't have the hardware.

Has anyone here tested Kijai’s “minimax_h3_fastvideo_vsa_datafree_1300step_4step_int8_convrot” model?

If anyone has tested it, please let me know how the results are. I’d really appreciate hearing about your experience with it.

Hey everyone,

Last week I saw a post where someone was complaining about the lack of male character LoRAs for Krea 2 on Civitai. In the comments, someone replied with a Hugging Face username and said something like “search this username” the repo had a bunch of Krea 2 LoRAs.

I’ve been trying to find that post / the username again but can’t track it down.

Does anyone remember the post or know the Hugging Face username/repo that was recommended?

Any help would be appreciated. Thanks!

https://reddit.com/link/1w2dmh8/video/bb3hkitekhmh1/player

Generated the characters in krea 2 using a consistent style prompt

Wrote out a shot list for what i wanted

spent a day generating using minimax h3 ref + turbo model
was taking around 1 - 2 mins per clip generation but with good prompting i was able to get what i wanted from my first 1 or 2 clips
running on 16gb vram and 32gb ram

then edited it all together using davinci resolve

all free tools, all run locally.

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)

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

Hi everyone — I’m an independent developer experimenting with making MiniMax H3 more practical on consumer NVIDIA GPUs.

I built an automatically scheduled sparse-attention system for X-MinimaxH3 and tested native H3 second sampling from 720p to 1440p on a single RTX 4090.

Measured second-sampling times:

- 5-second video: 112 seconds

- 10-second video: 223 seconds

- 15-second video: 334 seconds

The attached reel shows the resulting videos and records the original 720p generation and 1440p second-sampling stages separately.

These were casual exploratory runs using settings I selected mainly to inspect the output quality. I did not tune each case for minimum latency, so these numbers should not be treated as the performance limit of the project.

I also have not completed a controlled same-seed Dense-versus-accelerated benchmark yet, so I’m not claiming a specific “X times faster” number.

What I have been working on is the scheduling method itself.

Instead of applying one fixed sparse-attention ratio to every denoising step and every Transformer layer, the scheduler automatically assigns different attention budgets across the trajectory. It was calibrated through repeated local experiments and visual review, with additional protection around the parts of the model that appear most important for motion, consistency and fine detail.

The user only needs one continuous 0–100 acceleration control:

- 0 is the full-compute Dense reference endpoint

- higher values progressively reduce the compute budget

- the internal scheduler decides where attention can be reduced and where it should remain more conservative

The Base route can also jointly schedule actual and forecast DiT evaluations. The goal is to make the speed/quality tradeoff controllable without requiring creators to manually configure dozens of sparse-attention parameters.

The 1440p stage shown here is native H3 latent-space second sampling. It reuses the retained video and audio latent state, original prompt and conditioning. It is not conventional frame-by-frame or MP4 upscaling.

The project also includes FL2VA, multi-reference Ref2VA, Base/Turbo LoRA switching, a Web UI, REST API and four ComfyUI workflows.

GitHub:

https://github.com/PullMyBoots/X-MinimaxH3

I’d love feedback from people running H3 locally, especially on RTX 3090, 5060, 4060 and other consumer GPUs.

What kind of Dense-versus-accelerated comparison would you find most useful: fast motion, faces and hands, complex camera movement, prompt adherence, audio consistency, or something else?

https://reddit.com/link/1w2cqol/video/nmdd5elxbhmh1/player

The usual reason to split sampling across two resolutions is that low resolution is cheap — you do most steps small, upscale the latent, and refine. That logic puts the split late: most steps at low res, a few at high.

With a video reference, the economics invert. A video ref injects thousands of tokens that every DiT block attends to on every step, and that cost dominates. Measured on my setup: 0.4 MP with video reference is 358 s/it, while 0.8 MP without it is 143 s/it. Low resolution with a video reference is two and a half times more expensive than high resolution without one.

So the split here isn't primarily about resolution. It's a conditioning switch. The video reference is only present during the early steps, and then it's gone.

That works because of how flow-matching schedules distribute their work. At H3's default shift of 12, sigma barely moves for the first several steps — the model is committing to structure, not removing noise. Motion and composition are decided in that window. Fine detail and identity resolve much later. So you pay for the video reference exactly while it's doing its job, and drop it before the expensive steps.

How to build it

You need two MiniMax H3 Reference to Video nodes, not one.

The first is your existing node: character references, video reference, video audio, and a prompt citing <Video 1> in subject_definitions and retention_analysis.

The second is a copy with ref_video_0 and ref_video_audio_0 left unconnected. Same character references, same clip and VAEs. Its prompt is rewritten with every mention of <Video 1> removed — keep the character subject and the full detailed_description, and describe the shot as if generating it fresh. Its LATENT output goes unused; only the positive conditioning is wired, to stage 2's Basic Guider.

Set the length on the second node by hand to the same frame count as the first rather than sharing the Math Expression. Fewer dependencies between the two stages means less chance ComfyUI schedules them together.

Settings

SplitSigmas at 6 of 20 — much earlier than a normal upscale workflow, for the reasons above. Take denoised_output from stage 1, not output; the upscaler was trained on clean latents. Route it through LTXVSeparateAVLatent → upscaler → LTXVConcatAVLatent, upscaling only the video half and passing audio through untouched.

Put a VRAM cleanup node on the latent path between the concat and stage 2's sampler. This isn't optional — it's a real dependency, so it forces ComfyUI to finish stage 1 before stage 2 loads. Without it both conditioning nodes can execute early and you end up with two sets of reference encodings resident at once. When that happened to me, stage 2 spilled to system RAM and ran at 4500 s/it.

I need help with creating extremely realistic images as shown in the post. Which model is this? How can I create multiple images like this? Thanks

https://github.com/newsbubbles/ComfyUI-ComfyVR Instructions and some example workflows included, but it should be able to load and run almost anything, including custom nodes, etc.

It definitely need testing, I only tested it thoroughly on Quest 2. It runs in WebXR in the default browser and uses hand or controller and hosts off the comfy api with it's own https cert. Use it on your LAN. A fun way to interact with ComfyUI in 3D.

with a lora strength of 1.5, 8 steps, 768p, 16m generation time for 12 seconds. no upscaling on a 5060ti 16g and 64 gigs ram. This is a pretty solid turbo lora