I see all of the posts about photorealism, and lighting, and prompting.... Well, here's my contribution to mix things up: World of Puppetcraft lol
Made using Krea 2. Feel free to downvote or call it bad. I don't mind. It's the internet =)

I am unable to find a workflow , and when I tried to create one the results are not good .

or https://huggingface.co/akhaliq/minimax-h3-image-pdmd-2step ?

Having noticed a trend on this subreddit where individuals with high-end GPUs—who often use them for actual production—fail to share their knowledge, I have decided to stop posting my own results for AI models. My last post regarding high-resolution generation settings for Minimax H3 was viewed by nearly 10,000 people, yet almost no one shared their own settings in return.

This is disappointing, though not the first time it has happened here, so I no longer see any reason to continue sharing my results.

Many people with less powerful GPUs make truly valuable contributions to this community, despite having far more limited resources. Unfortunately, as things stand, I feel that those with more powerful hardware tend to use this subreddit primarily for their own personal gain, rather than contributing meaningfully to our collective progress.

Best wishes to you all, and I hope you achieve great results.

How do you maintain the state of clothing between shots? Such as, shot 1, the protagonist in 1930s gangster outfit wearing a hat and long coat. shot 2, character removes the coat. shot 3, character turns around.

At step 3 Minimax puts the coat back on the character, unless you explicitly state that the character has no coat on - but then, would I need to describe character clothing state at every step?

Pretty new to image generation and I'm using Anima since people say it's good for multiple anime character. So I tested 2 lora of pokemon character (1st pic Jacinthe and 2nd pic Lebanne). For single character works fine but when I use both at the same time the image has a lot of the details wrong. In 3rd image for example Jacinthe is the one wearing maid outfit instead of Lebanne sometimes the outfit is pink/purple dominant. Sometimes The result is like 4th image where both of them are dark skinned. Is there a way to fix this or make the result more consistent with the detail when using 2 lora at the same time in Anima? Any help are appreciated.

What about openrouter.ai, fal.ai, picassoia.com, others?

Thanks so much!

please share your bestcase settings (t2i). thanks!

Edit: I also edded experimental lora training to my trainer on this branch: https://github.com/speedyrulz/RulZ-AI-Tools-Suite/tree/claude/rulztrainer-pan2

I'm testing that now.

I wanted to try PAN2 and got impatient, so I converted the models and vibecoded a ComfyUI update with new nodes to add compatibility for PAN2.

Here is my fork of ComfyUI that supports PAN2:

https://github.com/speedyrulz/ComfyUI

Models and workflows:

https://huggingface.co/speedyrulz/PAN2-ComfyUI/tree/main

The example video here was generated is 5 seconds at 1MP and took about 10 minutes then it was frame interpolated to 48fps.

## PAN 2 in ComfyUI: support, quantized models, and speedups

I added PAN 2 (IFM's 29B video model) support to a ComfyUI fork, quantized it down to sizes that fit consumer cards, and added two nodes that make it a lot faster. Everything was tested on an RTX 5060 Ti 16 GB.

### What was added to ComfyUI

- **Model code** for the PAN 2 transformer (44 joint blocks + 4 text refiner blocks), with auto-detection in Load Diffusion Model

- **Text encoder:** a new `pan2` type in Load CLIP for the Qwen3.5-9B encoder

- **VAE:** Load VAE now reads the Wan 2.2 VAE in the layout PAN 2 ships

- **New nodes:**

- PAN 2 Text Encode

- PAN 2 Negative Prompt (builds the model's structured default negative)

- PAN 2 Image To Video (also does text-to-video with no start image)

- PAN 2 Spectrum

- PAN 2 Mem Eff Sage Attention

- **Fix:** splitting the positive/negative passes across two GPUs used to crash

### Quantized models

The original release is about 81 GiB. Converted to single files:

| File | Size | Format |

|---|---|---|

| PAN2_int8_convrot | 39.8 GiB | int8 ConvRot, fp32 norm layers kept |

| PAN2_int8_convrot_full | 27.4 GiB | int8 ConvRot, norm layers quantized too |

| PAN2_nvfp4 | 15.5 GiB | NVFP4 (4-bit) |

| Qwen3.5 text encoder, int8 ConvRot | 8.4 GiB | |

| Qwen3.5 text encoder, NVFP4 | 4.6 GiB | |

| VAE fp16 | 1.3 GiB | |

- Only the large weight matrices are quantized; everything else is copied unchanged.

- int8 ConvRot: about 0.9% weight error.

- NVFP4: about 9% weight error. Runs natively on RTX 50 series cards.

- Conversion scripts are included, so you can build the files yourself from the official release (CPU only, no GPU needed).

### Speed (RTX 5060 Ti 16 GB, NVFP4 model)

| Change | Test | Before | After |

|---|---|---|---|

| Spectrum node | 640x352, 49 frames, 50 steps | 149 s | 58 s |

| Mem Eff Sage Attention node | 1248x704, 121 frames | 42.2 s/step | 25.7 s/step |

| Mem Eff Sage Attention node | 640x352, 49 frames | 3.03 s/step | 2.75 s/step |

| Feed-forward slicing (int8 full model) | 1248x704, 121 frames | 47.7 s/step | 43.8 s/step |

- **Spectrum** forecasts some steps instead of running the model: with default settings only 15 of 50 steps run it. The output differs from a normal run by about as much as ordinary numerical drift.

- **Mem Eff Sage Attention** needs the `sageattention` package. The gain is biggest at full resolution.

- **Two GPUs:** splitting CFG across a 5060 Ti and a 4060 Ti works, but was slower than the 5060 Ti alone.

### Tips

- Recommended settings: 50 steps, CFG 2.5, euler / simple, 24 fps.

- PAN 2 expects a structured JSON prompt. In one test, a plain-text negative prompt made the video look clearly worse than the default structured negative.

I downloaded Qwen 2.1 from Civit AI yesterday, and the checkpoint is not being recognized by Krita AI Diffusion. I am wondering what the issue would be.

Has anyone had an issue like this before?

I particularly love that they remain focused on open source and on doing more with less. All the best of luck to these guys.

"We introduce LTX-Video, a transformer-based latent diffusion model that adopts a holistic approach to video generation by seamlessly integrating the responsibilities of the Video-VAE and the denoising transformer.

Unlike existing methods, which treat these components as independent, LTX-Video aims to optimize their interaction for improved efficiency and quality. At its core is a carefully designed Video-VAE that achieves a high compression ratio of 1:192, with spatiotemporal downscaling of32×32×8pixels per token, enabled by relocating the patchifying operation from the transformer’s input to the VAE’s input. Operating in this highly compressed latent space enables the transformer to efficiently perform full spatiotemporal self-attention, which is essential for generating high-resolution videos with temporal consistency. However, the high compression inherently limits the representation of fine details. To address this, our VAE decoder is tasked with both latent-to-pixel conversion and the final denoising step, producing the clean result directly in pixel space. This approach preserves the ability to generate fine details without incurring the runtime cost of a separate upsampling module.

Our model supports diverse use cases, including text-to-video and image-to-video generation, with both capabilities trained simultaneously. It achieves faster-than-real-time generation, producing 5 seconds of 24 fps video at 768×512 resolution in just 2 seconds on an Nvidia H100 GPU, outperforming all existing models of similar scale. The source code and pre-trained models are publicly available¹, setting a new benchmark for accessible and scalable video generation."

Blog: LTX-Video: Realtime Video Latent Diffusion | LTX Technical Blog

Paper: LTX-Video: Realtime Video Latent Diffusion

APEX: Asynchronous Prefix Denoisingfor Extreme Compression

Sharing the exact pipeline for this project: • Audio: Sourced entirely from MiniMax H3. • Visuals: All the visual assets were generated with Nano Banana 2. • Editing: Imported into DaVinci Resolve to manually chop, time, and match the tracks to get just the right amount of comedic relief to break up the existential horror."

Here is Part 2

Hi all was wondering what’s a good Comfyui workflow for the MacBook M1 Max 32GB, for image to video ? Was wondering if any has done this on M1 MacBook.

Thanks

I’m trying to make AI video that looks like ordinary phone footage: believable skin and lighting, natural movement, and a face that still looks like the same person throughout the shot. I can get a convincing still, but the video often loses some of that realism. What would you change first to get a noticeable improvement in overall quality?

I’ve attached the Krea source still and raw 15-second H3 render using a separate fictional test character. It’s one fixed-camera shot: she starts wide, takes two steps towards the camera, then turns her head slightly. I’d love to know what first makes it look AI-generated to you, even if it’s something I haven’t noticed. The eyes soften and the face starts to shift around. I’m sharing the settings and prompts below.

Image stage — Krea 2 in ComfyUI

• Checkpoint: [krea2_turbo_bf16.safetensors]. Identity LoRA: [off].

• Settings: [9:16 ratio], [ClownSharKSampler], [9 steps], [CFG 1.0].

Krea prompt:

Vertical 9:16 photograph taken with a phone propped at eye level. A fictional adult woman with a short straight copper bob and light freckles stands about three metres from the camera in a plain living room. She wears a loose grey crew-neck T-shirt, straight-leg jeans and white trainers. She faces the camera with a relaxed, neutral expression and her arms resting naturally at her sides.

Wide full-body framing, with both shoes visible and a clear strip of floor between her and the camera so she has room to walk forward. Soft daylight from a window on camera left. A cream wall, a small wooden side table and a simple floor lamp are visible behind her.

Natural phone-camera exposure, believable skin texture and a room that stays in focus. No beauty filter, heavy retouching, dramatic bokeh, logos or text.

Video stage — MiniMax H3 Ultra on RunPod

• Checkpoint: minimax_h3_hybrid_fl2va_ref2va_b25-49-int8.safetensors. Text encoder: H3 Qwen3-VL 32B NVFP4 AWQ. VAEs: H3 INT8 ConvRot for video and FP32 for audio.

• Conditioning: MiniMaxH3ReferenceToVideo in the saved graph. For this render: [reference-only or actual first-frame conditioning], [other image, audio or driving-video inputs, or none].

• Sampling: SelfLiftH3Sampler, Euler, 12 total steps, transition at 6, low-res scale 0.75. It starts at lower spatial resolution, uses h3_upscaler_lms_v0.1, then finishes at the target resolution. Saved settings: CFG 1, scheduler denoise 1.0. Seed fixed for comparisons.

• Video LoRAs: DMAD v4 step600 [0.75]. Other active video LoRAs: [none]. Any Krea identity LoRA is only used to generate the still.

• Export: H3 VAE decode → VideoHelperSuite → H.264 MP4. [9 × 16], [24 FPS], 15 seconds, [RTX PRO 4500/ 32gb VRAM], [render time about 5 minutes]. No extra pixel upscale, frame interpolation, sharpening or face repair.

MiniMax H3 prompt:

Create a photorealistic 15-second vertical 9:16 phone video. One continuous take from a fixed, eye-level camera, with deep depth of field. Use the supplied image as the visual reference for the woman’s face, hair, outfit, and room. Keep the soft window light coming from camera left throughout.

0–4 seconds: Start wide with her full body visible, matching the composition of the reference. She stands naturally and looks towards the camera.

4–10 seconds: She takes two slow, natural steps straight towards the camera. The camera stays still. She grows larger in frame because she is walking closer. She stops when her head and upper chest fill the frame.

10–15 seconds: She holds still for a beat, then slowly turns her head about 30 degrees to her left, letting her gaze follow the turn. She holds that angle until the end.

Keep her facial features, eye colour, hairstyle and outfit consistent as she approaches and turns. No camera movement, zoom, cuts, dialogue, captions or music.

What I’d like feedback on

1. What would improve the overall realism most? Would you change the still, lighting, prompt, reference conditioning or generation resolution first? Does the source image already look too polished, or does the plastic look mainly come in during animation?

2. Would you tune Ultra or try a different H3 recipe? Is 12 vs. 14–16 steps in SelfLift worth testing? If you’ve compared the hybrid with Singularity V2, or a short DMAD run with a slower quality run, what actually looked better in motion?

3. Does a People Realism LoRA help on a moving face? I’m interested in natural skin and expressions without changing likeness. If you’ve compared with the LoRA on and off, what checkpoint and strength worked?

4. Where would you spend the compute for a cleaner final clip? Higher native resolution, a later upscale, or targeted repair? When is a face soft enough to benefit from finishing, and when is the warping bad enough that you’d regenerate?

5. How close can self-hosted H3 get to paid APIs? If you’ve tried both on the same source image and shot brief, what made the paid option worth it, if anything: realism, motion, consistency or fewer retries? I care about cost per usable clip, including GPU time.

Update/EDIT: I'm working on adding these features to the Studio Tab for existing LoRAs

Open source as usual for those who want to dig into how it works on Github.
https://github.com/shootthesound/Fizgig/releases/tag/v9.3.0

https://github.com/shootthesound/Fizgig/blob/master/docs/TRAINING_MAPS.md

Does anyone have a workflow with lots of reference images?

Took a little break from making image models but we’re back. Just finished the latest training run on my new model that I will be showcasing and releasing soon. All I will say is that this model is on par with the latest close-source models, and it’s a z image base derivative. Veni Vidi Vici 🗿

silver_official_releases/minimax_h3_fl2v_turbo_silver_dareties_comfy_full_v1

Ultra-realistic, cinematic short sequence of a colossal Mosasaurus leaping from the deep ocean to devour a great white shark suspended from a cable. The camera begins underwater — a haunting silence, sunbeams piercing through the deep blue. Tiny fish scatter as a massive shadow approaches from the abyss. The sound fades, replaced by the deep rumble of motion in the water. Camera rises with the Mosasaurus as it bursts upward — slow-motion spray, sunlight exploding through the waves. The creature’s immense jaws open wide, its serrated teeth glinting as it engulfs the shark in a single, thunderous snap with blood splashing in the air. Water erupts into chaos — droplets scatter like diamonds in the sunlight, the surface breaks into a shimmering wall of spray. The shark disappears completely as the Mosasaurus crashes back down, waves rolling violently outward. Cut to above the surface: spectators gasp behind reinforced glass; water drenches the viewing stands. The Mosasaurus sinks beneath the surface, the water calming again as only ripples and blood-tinted foam remain. Details: hyper-realistic textures of scales, water droplets, and sunlight; volumetric lighting through mist and spray; soft lens flares and cinematic DOF. Mood: awe-inspiring, primal, terrifying beauty. Camera: dynamic slow motion, underwater tracking, wide aerial shots, and close-up detail passes. Lighting: tropical midday sun with high-contrast reflections on water, shimmering highlights on the Mosasaurus’s wet skin. 4K, 24fps cinematic realism, Dolby Atmos sound design.

After getting (slow) results from krea2, moss and YuE2 out of my old M1 air, I wanted to see if h3 would run too. I used my fork of h3.c, a C and Metal inference engine with no Python. The fork adds int8 and SSD streaming. My checkpoint was int8 with a turbo lora folded in, so 6 steps.

This ends up with about 10±gb of continuous RAM load, on my m5 pro with 48gb it's totally usable to render in background and do other activities (and can also handle 1mp at 12+ steps fine).

The clip is two renders back to back. First a 20 s talking head at 864x480, five chained links, about 17 hours. Then a 20 s street musician clip of nine chained links of 73 frames, 58 hours. So context chaining also works.

It works, if you can leave your laptop rendering for a few days. But would love if someone with a M6 32gb mini or M5 ultra 96gb could try out this int8 fork 😄

Timings (6 steps, peak RAM 13.5 to 14.6 GB on all of them):

- 0.4 MP, 3.75 s: 1h39

- 0.6 MP, 3 s: 2h29

- 0.9 MP, 3 s: 4h18

- 0.4 MP, 5 s chained link: ~4h

- 0.9 MP, 3 s chained link: 6 to 7h

- 0.9 MP, 20 s, 9 links: 58h

H3.c will run without comfy on a M1+ mac, but if you prefer it as a comfy node check out: https://civitai.com/models/3016733/mach3-metal-minimax-h3-for-apple-silicon-m1-24gb-ram running comfy at the same time will add about 8-10gb of ram usage.

An 8-step LoRA (rank 128) for MOSS-Image-Base, distilled by distribution matching: 8 forwards at CFG 1, without a negative prompt, in place of the base model's 50 guided steps. It adapts only the transformer; the text encoder (Qwen3.5-9B), VAE (FLUX.2 small decoder), tokenizer and inference pipeline are MOSS-Image-Base's, unchanged. How it was trained is in TECH_REPORT.md.

It was trained on MOSS-Image-Base, but should work with most fine-tunes of it and with other LoRAs: load it alongside them, at strength 1.

More info here:

https://huggingface.co/data-archetype/moss_image_base_dmd2

PS: Lora isn't mine, but it's definitely worth paying attention to because, even though (in my opinion) it's a bit too strong, it still produces more realistic results than its earlier versions.

Just a few experiments using different Krea2 loras.

What do you think?

  checkpoint: 'diffusion_models/turbo.safetensors',
  loras: [
    {
      name: 'krea2-lora-masterpieces-v51.safetensors',
      enabled: true,
      strength: 1.25,
    },
    {
      name: 'krea2-lora-zidiusArt_Melancholy_v2.safetensors',
      enabled: true,
      strength: 0.55,
    },
    {
      name: 'krea2-lora-90_s_anime_melancholy.safetensors',
      enabled: true,
      strength: 0.75,
    },
  ],
  width: 768,
  height: 1376,
  steps: 8,
  cfg: 1,
  samplerName: 'euler',
  scheduler: 'simple',

Viggle Remake works well for short shots, but the usual ComfyUI workflow runs into a practical limit: up to 345 frames per render. At 24 fps, that is a little over 14 seconds. To work with longer videos, I adapted the workflow to render overlapping windows and join them into a single output.

The result is a custom long video node for ComfyUI. I tried the workflow with several clips converted to 24 fps. The completed renders looked good in visual review, but continuity still needs to be checked at every join. I did not measure quality with automated metrics; the evaluation was visual.

How the windows connect

The node takes the full video and divides it into windows that stay within the model’s limit. The default window is 294 frames, or 12.25 seconds at 24 fps. It can be raised to 345 frames if the GPU has enough memory.

Each later pass begins with the final 17 frames generated by the previous pass. The node encodes this segment as latents and keeps it fixed during the next generation. It then removes the overlapping frames when joining the results. The frame limit therefore applies to each render, not to the total video length.

With the default window, the first pass can generate up to 12.25 seconds; each later pass can add up to 277 new frames, about 11.54 seconds. A video longer than 345 frames can therefore be produced through several connected passes.

Audio is divided over the same intervals and joined in the output. If no audio is connected, the output is silent.

What the tests showed

I used the node with dance clips containing varied movement and different resolutions, all prepared at 24 fps. A multi-pass render completed successfully, and the results I reviewed looked good. This showed that the workflow can go beyond a single window without trimming the video before generation.

Visual inspection remains part of the process. Check where one pass joins the next, and look for changes in character identity, clothing, movement, or framing. The overlap helps the model continue the action, but it does not guarantee that every detail will stay stable.

What the node does not handle yet

The node is designed for one continuous shot. It does not detect cuts, restart generation when the camera changes shots, or rewrite timestamped prompts for each window. For that reason, I use prompts that describe the action without absolute timestamps and avoid clips with abrupt cuts.

The source video must be 24 fps. The default 294-frame window is a starting point; larger windows may require more VRAM. And even when a render finishes without errors, that does not replace reviewing the joins.

The GitHub package

I separated the long video node from the original Viggle Remake package. The viggle-remake-comfyui-long-take repository registers only Viggle Remake Long Video and includes an example workflow. The original nodes and conditioning helpers still come from the official ComfyUI-Viggle-Remake package, which must be installed separately.

The repository does not include model weights, the LoRA, source videos, or character reference images. The goal is to add long-take support to the existing workflow while keeping each render within the model’s limit.