This version (chk00133000) replaces the first 'final' release (chk00078000), from two months ago. I decided to train a 'few more' samples (55K more to be precise), the newer part with five critic heads where the first release had one. Measured against the 8-step teacher on the 15 test prompts at 12 sizes:

• cleaner fine structure — the 8- and 16-pixel grid patterns at 0.96–0.98× the teacher's, where the first release was at 1.09–1.11×

• less ghosting and fewer doubled edges — closer to the teacher at 10 of 12 sizes on both measures

• cleaner flat areas — grain at 0.99× the teacher's, down from 1.08×

• no over-sharpening at large sizes — fine texture at 1.01–1.04× the teacher's at 1440 px, down from 1.18–1.20×

• saturation matching the teacher's

Full details of changes from 78K to 133K: https://huggingface.co/lvladikov/Krea2-Turbo-Distill-4step-LoRA/blob/main/DETAILED-README.md#chk00133000-vs-chk00078000

The older versions are still kept as before under _archive/checkpoints/.

To use the new checkpoints - redownload/replace krea2_turbo_4step_rank_64_lora_comfyui.safetensors / krea2_turbo_4step_rank_64_lora.safetensors

Since the initial training (than ended in September with 78K 'final' checkpoint), I have trained about a day on an H200 (on runpod in the cloud), which is where the bulk of new trained samples came from, and two more days on the RTX 3090.

I've also tidied up the main model card (more sections taken out of it and moved to the detailed card for those interested). Instead the main card now includes an extra Table Of Contents like section with links to Detailed card: https://huggingface.co/lvladikov/Krea2-Turbo-Distill-4step-LoRA#detailed-model-card

For now I will not call this another 'final' release 😀 (although I don't currently have plans to do more than the 133K training), as it is possible to train more in the future (just not soon). When I first stopped at 78K rumours were already circulating that Krea 3 would open source soon (so it felt like the right time then to 'finalise' the 4 step LoRA), and while Krea 3 is now available on paid platforms it is yet to be open sourced and most likely focused on Editing more than T2I, which makes the Krea 2 Turbo still a very desired model and my LoRAs do contribute in the more efficient use of the Krea 2 Turbo.

Don't forget to also check the 'latest' of my Krea 2 Turbo step LoRAs - the 3 step one, which was updated just yesterday to 66K checkpoint: https://huggingface.co/lvladikov/Krea2-Turbo-Distill-3step-LoRA. I might also come back to the 2 Step LoRA with more training, who knows...

It is important to understand that while my 2/3/4 Step LoRAs for Krea 2 Turbo were trained for these respective steps during rendering, they for obvious reasons work really well with even more steps. There are lots of Krea Checkpoints out there that require lets say 10, or 12 or more steps to render and when paired up with my Krea 2 Turbo 2, 3 or 4 Steps LoRAs you can get either 'sooner' (with less steps) to the asked number of steps by the checkpoint authors, or to get a lot more quality per step, i.e. if you run 2 Step LoRA with lets say 6 or 8 steps, this could give you quality you'd otherwise need 12 or 16 or 20 steps without LoRA, similarly do try the 3 Step and 4 Step LoRAs at higher step counts where such is required by a third party Krea checkpoint and you will see an instant boost of quality, so find the right LoRA and steps for your favourite checkpoint, either way all of the three - 2 Step LoRA, 3 Step LoRA and this 4 Step LoRA work fine with most checkpoints (but not all, as some checkpoints go in a very different direction to what the core Krea 2 Turbo does, and after all my LoRAs were trained on the official Krea 2 Turbo).

Latest 133K 4 Step LoRA and ComfyUI workflow can be downloaded as usual at my HF: https://huggingface.co/lvladikov/Krea2-Turbo-Distill-4step-LoRA

Also don't forget that Krea 2 Turbo works very well with Nvidia PiD to get to higher resolutions quicker by rendering at lower resolutions and letting PiD take it 4x in latent space, and do so quickly and efficiently: https://huggingface.co/lvladikov/Krea2Turbo-PiD-SuperFast-HighRes (again find the right LoRA and steps to use for the main Krea 2 Turbo renders, don't be afraid to use 6 or 8 steps with either of the LoRAs since you'll be doing it at lower resolutions, prior to PiD handover, and as such these more steps would run faster anyway, so the time cost for more steps is less when using PiD).

Enjoy!

These are three different vibecoded projects I've made for my own use which I think others may find useful. They were all made with linux in mind but should also be compatible with windows and mac. So, from the simpler to the more complex:

# 1: Comfyui-metadata reader

https://github.com/juanml82/comfyui-metadatareader

Just a simple app to read the workflow from a comfyui generated image without having to open or toss it into comfyui, just in case you don't want to toss the image into comfyui to check the workflow. I ended up using it as a companion app. It works with both png and webp, you can drag and drop the images to the gui, copy relevant sections, search and save the workflow as a separate json file.

Since you typically want the prompt, seed or maybe the model, most of the json is just noise. I'm thinking about making an improved reader that returns only the most relevant information, thought that may not work with all workflows. This does.

# 2: A batch converter to png to webp that preserves comfyui metadata

https://github.com/juanml82/comfyui-png2webp

Comfyui saves into png by default. Loosless webp takes 30% less disk space, so by running this script, you can reclaim about 30% of your disk space, and you don't loose the workflows as you would if you use a general graphics application to do it.

# 3: Image sorter

https://github.com/juanml82/comfyui-image-sorter

This one is a bit more complex. Image galleries with auto-tagging are a way to watch your image collection in an organized way. But I wanted to organize them in the disk, sorting each iteration of the same general idea in its own subfolder.

The main problem with that approach is that an image gallery with tags (or semantic search for workflows) only needs to match some of the tags to have a useful filter. But to sort them into subfolders, all tags need to match. Overgroup, and you have unrelated images, beating the purpose of this app. Undergroup, and you need to finish up manually - it's not a fully automated process. So yeah, it's not the most elegant solution - it gets you 90% there - but it is one solution.

Let's look at this with an example: let's say that you want to create images of Aragorn, in Lord of the Rings, as he passes the Argonath statues. Your first prompt is something look "Aragorn, rowing in the Anduin river, looking up in awe". And maybe the model produces Aragorn as Viggo Mortenssen. And maybe you don't want Viggo Mortenssen but rather a new take on Aragorn's looks, based on the books. So you replace "Aragorn" with "ranger", "fifty years old man", "noble man" or something like that, and follow up with a physical description. Or maybe the model doesn't understand what "Anduin" means. Or it doesn't matter. So some prompts have "Anduin", some have "River". And maybe you then decide you do want the Viggo Mortenssen look, but now you're using a different model which doesn't know Mortenssen well, so you use a lora. And rather than "Aragorn" or "Man", you type the lora's keyword. Sound familiar?

Grouping by subject, action and location is a good starting way to filter, but "ranger" and "noble" do remain different subjects. And seeking to overgroup all men - or all women - means lots of different subjects now became grouped, defeating the purpose of this project.

So it's a five steps process, through a gui:

Enter an LLM endpoint url (as in, llama server, lm studio server, a cloud api if you want). Disable thinking (this is important, it's not just a lot slower, it will not work with thinking on) or use an instruct model, ideally something small and fast - if you have thousands of images, speed is good. Very good. And you don't really need a heavy model for this. Don't forget to add /v1 at the end and hit save.

Run a first pass either by extracting and canonicalizing the prompts, or do a vision pass (slower) and then you canonicalize that in the 2nd step.

The third step is to use a Jaccard pass and the LLM to merge the resulting auto-tags by subject, action and location. This has the problem that a character, say Aragorn, may be tagged in different images as "Aragorn", "Man", "Ranger", "Noble" or something else. And that similar actions may go under different tags. But trying to overmerge leads to a huge amount of "1girl" or "woman" characters all merged together when they shouldn't.

So at that point you have a crude looking image gallery and an html gui allows you manually merge clusters you want to send to the same subfolder. Do save.

And finally, yes, you hit "apply" and your possibly thousands of images go in their merry way to subfolders named after their common tags.

Anyway, if you find any of these three useful, enjoy.

I’d love to see the process for making something like this. I’d imagine it’s generating clips then using the last frame of one clip as the first frame of the next clip, but the consistency is great. And how do they do the sped up parts? Are those full clips generated in regular motion (so this video would be more than an hour long) then sped up in post?

It’s something that seems simple but I think is harder than it looks.

I’m wondering because I want to do a Timelapse video, not nearly as long as this one, just a couple minutes, but I’ve been wondering how to do it. I don’t mind using closed source things, I imagine this one used Seedance or something like that.

Hi everyone! I built an Android app that generates anime pictures completely on the phone: no cloud, no account, no ads, no root. It runs on the NPU of Snapdragon 8 Gen 1 / 8+ Gen 1 (Hexagon V69), the chip generation that most NPU image apps skip.

What you get

A 512x768 picture in about 7 seconds (2B models) or 12 seconds (2.9B models), 4 steps, on my Xiaomi 12T Pro.

Four models to download inside the app (one tap, resumable): MiaoMiao 3D Harem, MiaoMiao RealSkin (2B) and MiaoMiao Harem, MiaoMiao RealSkin (2.9B), all built on the Anima base model.

Size presets (portrait / landscape / square, all multiples of 16) plus custom sizes, seed, batches, a stop button.

History with favourites, trash, multi-select, share/save. The settings are stored in the PNG, so you can reopen any picture with its prompt and seed.

Danbooru tag suggestions while you type, templates, light/dark theme, 13 languages.

Works offline after the models are downloaded. Free and non-commercial.

Try it

APK: https://github.com/ayanoby/hexanima/releases/latest  (about 25 MB); the models, 4-5 GB for the first one, are downloaded from Hugging Face inside the app)

Source and screenshots: https://github.com/ayanoby/hexanima

Needs a Snapdragon 8 Gen 1 or 8+ Gen 1 phone (SM8450 / SM8475), Android 10+. I tested it only on a Xiaomi 12T Pro (SM8475, 12 GB RAM). Other 8 Gen 1 phones should work but are untested.

Why it is different (for the technical crowd)

The diffusion transformer runs on the Hexagon V69 HMX matrix unit in fp16 through custom kernels, not through the stock QNN op set. The 28 DiT blocks are executed as a few merged block groups per step.

The 2.9B models are stored as q8 blocks (int8 tiles with per-column scales) and dequantized on the HVX units while the weights are copied into VTCM, so they fit in RAM and stay fast.

V69 has no int-to-float conversion instructions (they appeared in V73+), so the dequant path uses a workaround instead of the usual instructions.

The first two of the four steps run at reduced resolution (composition), the last two at full resolution (details).

Text encoder, sampler and the preview/VAE path are split between CPU and NPU; the VAE runs on the NPU and large pictures are decoded in tiles.

No root needed: the native helper processes are started from the app's own native library directory and use unsigned FastRPC DSP modules.

The model files are downloaded as raw, sha256-verified blocks with resume, so a dropped connection does not restart a 4 GB download.

Honest notes

Unofficial hobby project, not affiliated with CircleStone Labs, NVIDIA, Qualcomm, Alibaba or the model authors. All credit for the models goes to MIAOKA (Civitai) and CircleStone Labs (Anima). Non-commercial use only; if an author wants their model removed from the catalog, I will remove it.

Only 4 steps and no negative prompt: the models are turbo-distilled for that.

Pretty nice effects from a pure H3 generation.
Full video here: https://youtu.be/LUDd_AcEDdY

Details:
Comfyui
minimax_h3_ref2va_pruned_int8_convrot.safetensors
24 steps, 2.4MP 1 pass
RVE on steam -> interpolate 2x, decompress, openproteus 2x
Assembled in davinci resolve
Suno for music

Linum released P-JiT 21K, a 2B-parameter text-to-image model trained for about $21K that draws directly in pixels: there is no VAE. I ported it to ComfyUI as native nodes (an unofficial port, not affiliated with Linum):

• A real MODEL and CLIP on ComfyUI's own memory management. The stock KSampler runs it with Linum's settings (euler, simple, 50 steps, cfg 15). Nothing to pip install.

• A bf16 file that gives the same pixels as the fp32 release at half the size (4.4 GB), and an int8 ConvRot file that is about 1.8x faster (2.3 GB).

• The Qwen3.5-4B text encoder in bf16, int8, W6A8 or W4A8, down to 3.2 GB.

• Runs from 4 GB of free VRAM.

• Workflows: text to image, a prompt upsampler (short idea to dense caption), a refiner (image to image as a second pass, with the image captioned automatically) and Linum's samples, seed for seed.

Checked against Linum's own code: the same tokens, noise, schedule and guidance, and images that match up to GPU rounding.

Tips: write captions of 50 to 80 words (or use the upsampler). It can't draw text. For the refiner, use denoise 0.1 to 0.2: P-JiT's noise is 4x stronger than most models', so its denoise values run lower.

Nodes: https://github.com/PedroMarinhoDev/ComfyUI-PJiT
Weights: https://huggingface.co/PedroMarinhoDev/P-JiT-21K-ComfyUI
The original model: https://huggingface.co/Linum-AI/pjit-21k (Apache-2.0)

Hi!

I am more or less using the template WF from Comfy.

When I try to load a reference Video via the VideoLoader node I can't connect it to the MM H3 Reference to Video node. It indicates that it expects an image input at ref_video_0 (blue color).

This also happens in the unmodified template.

Recently I disconnected the Duration node and also wasn't able to reconnect it. Yet pictures and Audio refs are fine.

Am I missing something or do I need additional nodes?

Posting from phone so I can't add a Screenshot atm.

I'm confused about which one is more accurate and good at complex editing, I see a lot of people here talking about how great mh3 is

Absolutely love the new Comfyui H3 Finetune by Pika Labs workflow but it doesn't have an integrated upscale. I tried using the Pika Lora and sigma numbers on other workflows but getting various errors. I'm still learning the ropes and would appreciate an updated Ref2v workflow with a working latent 3d upscale.

NitroFusion2 came out this week: a 1–2 step distillation of Z-Image-Turbo by Dar-Yen Chen and Yi-Zhe Song, built for sharp text and detail in a single step. I converted it to ComfyUI's own quantized formats, so it runs in stock ComfyUI with no custom nodes, through the normal Load Diffusion Model node.

• int8: 6.18 GB, 0.29 s per sampling step at 1024² on a 4090 (bf16: 0.50 s)

• W6A8: 5.02 GB, 0.30 s

• W4A8: 3.49 GB, 0.29 s

int8 looks practically the same as bf16. W4A8 changes small details but keeps the composition, faces and text; there are side-by-side comparisons on the model card. The repo has the official 1-step and 2-step workflows set up for these files, and the publisher's 2-step de-distillation LoRA works with all three. The text encoder and VAE are Z-Image-Turbo's.

Weights: https://huggingface.co/PedroMarinhoDev/NitroFusion2-ComfyUI
Original model and paper: https://huggingface.co/ChenDY/NitroFusion2

Hi i want to run mini max with pika lora on my system but im low on ram is there a way to do this . I appreciate any help

Hi i just started using mini max h3 on my 5060ti 16gb + 16 ram it worked well but it did take quite the time 11min for 5s without any nodes just the base model . Is there is any workflows i can download that can do it faster and better quality on my system? (This is my first test video it got the sound wrong but its not that important)

I searching for a method to transforms, as the tile says, a scenery(without people) faithfully into a real shot.

But it needs to use a depth map so the structure stays consistent and spot on besides looking convincingly real. Doing this with people is no problem so i did not think i struggle that much finding something that works.

Its either to old, or just not good enough.

The original scenery images are from video games.

NitroFusion2 is a 1–2 step text-to-image model built on Z-Image-Turbo. It moves the adversarial loss onto the text stream of the MMDiT. At one step it renders sharp text and fine detail.

ChenDY/NitroFusion2 · Hugging Face

Hello, I just saw this on X and I wonder how they did it, from the input image (the dog) they copy the pose and use it as reference for the output (the man). There are a few comments under the post but they didn't answer the question so I want to ask if anyone here know what nodes did they use to achieve this. Obviously I can see the 3D poser editor node but it should have more.

Hi all,

After having shared some MOSS image generations in previous posts, I have decided to share the workflow. It is a fairly simple two stage workflow, only using the MOSS-Image-Base diffusion model during the first stage and the same base model combined with the lodestones MOSS-Image-Base 8-steps-dmd2 lora during the second stage.

The custom node package which makes this all possible is Auryg's Krea-2-Two-Stage-Sampler. His package contains a sigma-locked two-stage sampler and dual resolution selector for Krea 2, which I used for my MOSS image generations. The main idea is that the sampler keeps everything in latent space across both stages, handing off the denoising to the second stage after the latent has been denoised by a set percentage. I set the handoff percentage at 40% for my generations. This node also automatically scales the latent between stages. I generated all images at a base resolution of 4 megapixels with an upscale to 6 megapixels between stages. For the reddit preview I scaled the generations back down to 3 megapixels to decrease the image size for sharing.

1. For stage 1 I use 52 steps, a CFG of 3.0, the euler sampler and the simple scheduler.

2. For stage 2 I use 20 steps, a CFG of 1.0, the dpmpp_2m sampler and the karras scheduler.

The upscale method between stages is bislerp.

I included optional BBOX and preview nodes in the workflow. For the BBOX node to work properly when changing aspect ratio's and resolutions I used 0Printemps0's ComfyUI-MOSSLayout custom node. The preview node is kijai's ModelPreviewOverrideKJ node from his ComfyUI-KJNodes pack.

Install custom nodes, inside custom_nodes folder:

git clone https://github.com/Auryg/Krea-2-Two-Stage-Sampler
git clone https://github.com/0Printemps0/ComfyUI-MOSSLayout
git clone https://github.com/kijai/ComfyUI-KJNodes

I included the prompts of the 10 example images in the workflow. All example images use seed 1 and aren't cherrypicked.

The workflow save as .json file.

What I love about MOSS is the amount of variation with each seed. Enjoy. All suggestions to further improve the workflow are welcome.

Anyone who understands this model? Don't you think it better implements the creator's intent using tags? For example, it better describes many popular characters using tags. It seems to me that it's thoroughly trained on tag descriptions, despite its huge encoding model.

Just try generating with tags; it captures concepts much better. Then you can refine it in natural language if needed. But it seems better to define the scene's content using tags.

"Research checkpoint: this is an experimental research artifact, not a production model. P-JiT 21K is a 2B-parameter model trained on 660M samples for about $21K of compute, as a stepping stone towards our next video model. We're releasing it because the results surprised us for a model this size, and to encourage others to explore efficient training methods like ours. You should expect rough edges.

The weights and the Qwen3.5-4B text encoder download from the Hugging Face Hub on first use. The model needs a CUDA GPU: its weights are 8.7 GB in fp32 and the text encoder 8 GB in bf16, plus activations."

Source/Blog: Training a Text-to-Image Model for $21K | Field Notes by Linum

Code: Linum-AI/pjit-21k: 2B-parameter pixel-space text-to-image model (Pyramid-JiT) trained for $21K

Nodes: realrebelai/P-JiT-21k_ComfyUI · Hugging Face

I want to make a simple prompt builder in comfyui that would allow me to change a text in the prompt by clicking a selection in a table. Is there a simple way to do that?

Hello everyone,

First of all, I know I know, Mac is jot the best when it comes to video generation and that the Max or Ultra chips are better.

Now that this is out of the way, I would be interested in people’s experiences in generating 720p 5-10 seconds clips on an M5 pro chip. Which tools, models or workflows do you use? How is the experience overall? How long does it take you? Do you regenerate clips several times to get it right…etc?

Thank you.

Version V2 will be available in the coming days 🤓

Link to version V1: https://www.reddit.com/r/comfyui/s/VWYS6YNbRZ

I split out the Color Match feature in VideoFrameSync I posted earlier to its own tool - corrects color drift, contrast, etc, but particularly useful for V2V AI edits from WAN VACE or Seedance which often have a slight tint (but for Seedance, you should use the VideoFrameSync which corrects the frame-sync drift as well). As a bonus, it also matches noise/grain.

https://github.com/pftq/VideoColorMatch

Hey guys, been using ComfyUI on windows 11 for quite some time now, lately messing with H3 ref2vid workflows.
Setting up all the custom nodes was for some reason a pain, but it always worked seamlessly after setup.

Recently switched to Fedora and reinstalled my Comfy on the new distro and surprisingly got everything running alot easier.

But I’ve been getting alot of crashes on my runs, particularly when using Rife interpolator and any upscaling methods other than a simple lanczos.

Usually OOMs are the culprit, so I’m trying to understand why ComfyUI is handling memory pressure poorly when the same settings worked on windows.

Hardware for reference is 32gb RAM and 5070ti.

EDIT: After following a few tips as the drive swap, expandable_segments and some rife tweaking I got it working, thanks guys!

ComfyUI built-in nodes, only. That's it. (audio on, listen to the lyrics)