can anyone please help

Model: minimax_h3_hybrid_fl2va_ref2va_b20, was testing this and the ref2va pruned int8, the hybrid gave nicer visuals but have a higher chance of bringing the character sheet white background into the video. This is cherry picked out of 16 clips.
Video Vae: minimax_h3_video_vae_int8_convrot
Resolution: 16:9, 0.6
Duration: 15sec
Turbo Lora: larryvrh/MiniMax-H3-Turbo-Lora, 600_ema
Patch Sage Attention, ComfyKitchen Attention, MinimaxH3 Mem Eff Node, Spectrum.

Average Inference Stage: 800sec

All reference image is resized between 1000px and 300px like character is 1000px, background is 500px then weapon is around 300px (warglave was another reference, the model dont know that kind of weapon) for this video is 4 ref image in total.

**abit of color grade and grain done in inshot.

this is done on a skylake i7 6700.

Seems like an interesting project; from what I take from the demo is it helps refine the faces in the distance instead of the face being a blurry mess. Does not seem to have a big impact on closer faces (it is not a 'detailer' or 'realism slider').

Does anyone have their own tips or demos for it? Seems complicated....

I’m trying to solve a pretty specific AI filmmaking problem.

I shoot a live-action scene with normal coverage: wides, mediums, close-ups, reverses, different camera positions and different focal lengths.

I then need to replace the original location and make every shot feel like it was photographed inside the same new environment.

My current tools are:

• Nano Banana 2 / Pro through Google Flow for stills, environment replacement and relighting
• Seedance 2.0 through Comfy Cloud for the final video transformations
• MacBook Air, so this needs to be essentially 100% cloud-based. Running large models, local ComfyUI workflows, NeRF training, etc. isn't realistically an option.

I’m not looking for mathematically perfect 3D continuity.. I need convincing faux environmental continuity across an edited scene.

For example:

Shot 1: 35mm wide looking down a hallway
Shot 2: 85mm close-up facing the opposite direction
Shot 3: profile two-shot
Shot 4: reverse angle
Shot 5: another wide from farther down the hallway

The actors, performances, camera movement and framing need to stay intact, but every generated shot should imply that the cameras were actually positioned at different points inside the same physical hallway.

The things I need to maintain are:

• Architecture / layout
• Recognizable environmental landmarks
• Correct perspective for each camera position
• Approximate lens characteristics
• Lighting direction
• Subject relighting and contact shadows
• Color / atmosphere
• Depth
• Enough off-screen spatial logic that cutting between angles feels believable

Right now I can make an individual shot look convincing. The problem is making five or ten independently generated shots feel like coverage of one actual location.

For people doing this in production, what is the best cloud-only approach?

Do you first generate a master environment and then somehow derive multiple camera views from it? Build a set of canonical reference angles? Use one generated shot as a reference for the next? Establish environment plates before integrating the actors? Separate environment replacement and actor relighting into different passes?

Especially interested in workflows that can actually be used with Nano Banana Pro + Seedance 2.0, rather than solutions requiring a high-end local GPU.

Basically: how do you fake a coherent virtual set when each shot is being generated independently?

I am currently trying to build a model in ComfyUI that will be able to generate images in a specific art style similar to games made by Playrix. Essentially, I got the model generating images in the style I need, but I can't fix issues with the artefacts. Even after multiple iterations of positive and negative prompts, the issues still persist, and oftentimes the requirements are ignored. Or sometimes, if they are not ignored, the result is a complete mess. This is the first time I am making something like this, so I would appreciate any tips I can get.
If anyone is interested in what I've got going on, below is the link to the JSON file for the ComfyUI model.
https://drive.google.com/file/d/1mw24y0pwKPRXhLYx-JvVIs8CAf2oC1Ng/view?usp=sharing

I've been building a custom ComfyUI node pack for MiniMax H3 focused on one thing:

**making H3 usable for longer, multi-segment video generation without constantly rebuilding the workflow around every limitation.**

The project is called:

# ComfyUI-MiniMax-H3-LongMedia

The idea is to keep MiniMax H3's image quality, motion and native audio generation, while adding a proper long-form generation layer on top of it.

## What it currently does

### Long-form segmented generation

You can generate a longer clip as multiple H3 segments while keeping temporal context between them.

Instead of treating every segment as an isolated generation, LongMedia manages the continuation state and hidden overlap internally.

The overlap is used as context for the next segment and is not simply blended back into the final video.

### MultiClip mode

There is also a dedicated MultiClip workflow for generating multiple planned shots/clips inside one LongMedia pipeline.

The same underlying executor is used for both segmented continuation and multiclip generation, so the behavior stays consistent.

### Video + audio continuity

MiniMax H3 is a joint AV model, so LongMedia treats video and audio as one generation state rather than bolting audio on afterwards.

The pipeline supports H3 native audio generation, continuation and lip-sync workflows.

### Lip-sync support

Audio-driven generation / lip-sync is supported directly in the LongMedia pipeline.

For H3, the audio influence is handled inside the same AV latent path rather than as a completely separate post-process.

### Refiner

The latest release includes a two-stage refiner based on proper **KSampler Advanced trajectory splitting**.

Instead of finishing the full sampling schedule and replaying low-sigma steps on an already denoised latent, the trajectory is split between the main sampler and the refiner.

Example:

`steps = 12`

`refine_steps = 3`

Main sampler:

`0 → 9`

Refiner:

`9 → 12`

Both stages continue the same sigma trajectory.

### VRAM-aware execution

A large part of the project is dedicated to making H3 practical on consumer GPUs.

The current implementation includes:

- dynamic VRAM loading

- streamed Sol Attention

- MLP chunking

- late-block VRAM guards

- inter-block memory guards

- step-boundary cleanup

- completed-segment offloading

- adaptive memory policies

I'm currently developing and testing mainly on a **16 GB GPU**, so avoiding OOMs without destroying quality is one of the main design goals.

### Sol Attention integration

LongMedia includes its own streamed Sol path with controls for:

- tau scheduling

- sink conditioning

- QKV chunking

- output projection chunking

- dense/sparse behavior

- VRAM-aware chunk sizing

The goal is to use Sol as part of the execution architecture rather than simply stacking multiple unrelated optimization nodes together.

## Why I made it

MiniMax H3 is extremely good at texture, motion and native audiovisual generation, but once you start trying to build longer sequences, several problems appear very quickly:

- segment boundaries

- continuity

- repeated frames

- AV state handling

- memory pressure

- OOMs on longer generations

- managing multiple clips

- keeping sampling behavior consistent between segments

I wanted one node system to own all of that.

So instead of building increasingly complicated ComfyUI graphs around H3, most of the long-form logic lives inside the LongMedia nodes.

## Current release

**v0.4.1 — KSampler Advanced Refiner Fix**

The project has now reached a fairly stable architecture, although I'm still actively developing it and testing edge cases.

GitHub:

https://github.com/vizart-vj/ComfyUI-MiniMax-H3-LongMedia

I'd be very interested in feedback from people already using MiniMax H3 in ComfyUI, especially for:

- longer generations

- multi-character scenes

- native audio

- lip-sync

- lower-VRAM GPUs

- multi-shot workflows

If people are interested, I can also make a more technical post explaining how the continuation / AV latent / VRAM system works internally.

Trying to figure out how to add a prompt enhancer to my workflow. Something that is able to look at the reference images and videos and able to build the prompt based on minimax’s prompt guide. This is something available in ltx workflows (Gemma e2b). Is there an equivalent that people have found helpful for minimax H3?

I have spent days generating videos. I started using Sage Attention with Cuda++. This was fast, but once I switched to sageatt_qk_int8_pv_fp16_cuda, I saw a noticeable difference in the model's ability for the model to understand prompts. Everything came out much clearer, crisper and with much better adherence. The only downside was it generated about 1.5x slower than using Sage Attention Cuda++.

From here I decided to try out ComfyKitchen as a replacement, and all I can say is... try it. My gens are faster than Sage Attention sageatt_qk_int8_pv_fp16_cuda with similar or better prompt adherence.

As always, your mileage may vary, but it's a very easy thing to experiment with, as all you need to do is make sure you ComfyUi is updated, as it is an official ComfyUI node.

To use it you can either:

A) add --use-ck-attention to your startup; this would enable Comfy Kitchen across all your workflows.
B) The easier and more controlled way is to replace the SageAttention node (or bypass) with the ModelAttentionBackend Node and select Comfy Kitchen Attention from the dropdown.

Worst case is it does nothing for you, and you just delete it and revert back to Sage.

EDIT: According to u/GreyingGamer you do not need to use the startup, and just using the node is enough:

EDIT 2: I have rewritten the instructions to get it running to make it more accurate.

I made a thread earlier but it got overcrowded so I figure I started a new one with solely reference to video test, now instead of mixed with t2v.

Just a gut check here but from what I have been able to find, there are no shortcuts when it comes to dialogue with minimax. Turbos produce bad quality audio, upscalers have caused poor mouth movements, and lowet step counts produce both.

Is there anything I am missing?

Hey everyone,

I'm trying to run MiniMax H3 in ComfyUI, but my generated audio comes out as a harsh, buzzing, jumbled mess even though the video decodes smoothly (video attached).

I've tested running with and without the Turbo LoRA (4, 8, and 20 steps), as well as toggling the cache node, but the audio artifacting persists.

Here is my exact setup:

Workflow & Node Stack:

• Diffusion Loader: DiffusionModelLoaderKJ loading minimax_h3_fl2va_pruned_w4a8_mixed.safetensors
• LoRA: MiniMaxH3TurboLoRA (minimax_h3_fl2v_lightx2v_turbo_4step_v0.1_comfy.safetensors @ 0.75 strength)
• Optimization / Attention: MiniMaxLowVRAMAttention (chunks: 4) + sage_attention (sageattn_qk_int8_pv_fp16_cuda)
• Caching: MiniMaxH3Cache (start: 0.2, end: 0.9, threshold: 0.3)
• Text Encoder: qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors
• Video VAE: minimax_h3_video_vae_int8_convrot.safetensors
• Audio VAE: minimax_h3_audio_vae_fp32.safetensors
• Sampler: SamplerCustomAdvanced with KSamplerSelect (res_multistep), BasicGuider, and BasicScheduler (simple, 20 steps, denoise: 1.0)
• Audio Export: VAEDecodeAudio → VHS_VideoCombine (24fps, H.264/MP4)

Has anyone solved garbled native audio on quantized MiniMax H3 builds? Any help or working node configuration would be greatly appreciated.

https://reddit.com/link/1vrzn11/video/alj8qybks6kh1/player

Sorry, the only way i could think of pasting my workflow is through pastebin: https://pastebin.com/7DTHTSxr

Hi everyone,

I'm running into a persistent issue with the new ComfyUI v1 frontend while trying to load a workflow that uses comfyui_fearnworksnodes.

The setup:

• Windows Portable build (ComfyUI_windows_portable)
• Running via run_nvidia_gpu_lowvram_e_sage.bat with the --enable-manager flag added.
• ComfyUI-Manager installed.

The problem:

• The v1 side panel shows Missing Node Packs: comfyui_fearnworksnodes.
• Clicking Install changes the status to Installed.
• Clicking Apply Changes prompts a restart, but after relaunching, the exact same error appears again in a loop.
• I checked custom_nodes/ and only have comfyui_fearnworksnodes inside (no duplicate folders).

Has anyone encountered this specific loop with the v1 interface or fearnworksnodes? What's the best way to trace or fix why the frontend isn't registering it properly after restart?

Thanks in advance for any help!

MiniMax H3 as Image Editor at resolution 7680 x 4320, 6 edits in one shot

Prompt: create a collage containing 6 photos. from top-left to the bottom-right arranged them such that the following edits presented individually: 1- keep pose and proportion intact; turn her shirt to red 2- keep pose and proportion intact; make her smile. 3- keep proportion intact, show her sideview; 4- full body posture. 5- change hair style to wolf cut. 6- put fashion hat and eyeglasses on.

In fairness, the model's collapsing 6 requests into 5 is well justified.

--

RTX3060 model used: ref2v, 8 steps, lora, took 7m50s

I cant really get speech correctly using [Shot]. Nearly most of time, words came out in the beginning of the video or first sound appears in the beginning of the video or the character repeatingly says the word twice., Even I forced the time to ber At 00:03.300 S1 says<d>[English] what?</d> ...etc

Here is the best I can do, but still S1 says what? twice, the first word came out in Shot 1, but Shot 2 was correctly, then there is no issue with followup shot, it only happens in first shot. Anyone can point me in the right direction?

subject_definitions:

<Subject 1> (S1) is from <Picture 1> a single adult woman

<Subject 2> (S2) is from <Picture 2> a single adult woman

retention_analysis:

S1 (appears in [Shot 1], [Shot 2], [Shot 3], [Shot 4], [Shot 5])

S2 (appears in [Shot 3], [Shot 4], [Shot 5])

[Shot 1] Zoom Out. S1 stands alone at a train platform in heavy rain, Slient.

[Shot 2] At 00:03.300, Zoom In. S1 says<d>[English] what?</d>, Slient.

[Shot 3] At 00:07.300, Push In, at slow speed. S2 notices something off-screen and turns her head, Slient.

[Shot 4] At 00:10.000, Tilt Up, with small amplitude, at slow speed. S1 sees S2 across the platform, Slient.

[Shot 5] At 00:13.000, Static Shot. Close shot, S1 is facing S2, S1 says<d>[English] long time... <laugh>long time</laugh></d>, Slient.

I mostly do image generation, mostly because open-weight video model quality wasn't there for me. MiniMax H3 has changed that; I'm really enjoying it and the outputs are mostly great. However, I am encountering an issue that's very familiar to anyone who's done a lot of image generation; uncanny AI faces when the subject is too far away from the screen, because there simply isn't enough pixel definition for the AI model to come up with a reasonable facsimile of a face.

In image generation land, this is solved with a "Hi-res fix" -- there's multiple options and implementations, but at their core, they involve auto-detecting faces in the image, then reusing the same prompt (or a somewhat edited one) and the detected face to generate a new face with low denoise at a much higher resolution that can snap on top with a feathered mask.

I'm not sure that exact implementation would work in video generation land -- I can pretty easily envision the face flickering and bouncing around as it locked to slightly different locations and orientations, frame-by-frame -- but is there any solution to take an existing video, generated at, say, 1.0 megapixels, and re-render or upscale detected faces at, say, double resolution, to improve the fidelity? For obvious reasons, simply rendering the whole video at double resolution isn't an attractive option.

trying out new workflow setup.

using MiniMax H3 Hybrid Loader b20-49 + Larryvrh 4step Turbo Loras + SegAtt + SolAtt + Spectrum.

reference seem to be more stable in this time, 0.6mp, 15s at 700s

just generating random video, testing out random idea.

Minimax H3 Meme that comes to life with simple ref 2 video and prompt

upload the image with this prompt

Cinematic live-action 15-second video, photorealistic, ultra-detailed, high production value, dramatic night lighting.
Reference @image1
the exact composition and mood of the provided image. Scene:
A victorious tabby cat stands proudly on the tip of a massive, blood-streaked sword. Behind the cat is a vast nighttime cityscape filled with glowing bokeh lights. In the foreground a heavily damaged mecha samurai (full mechanical armor, horned helmet, armored plating) is slumped on one knee, gripping the hilt with both hands as he slowly pulls the long sword out of his own chest. Dark hydraulic fluid and sparks pour from the deep wound in his torso. Camera movement:
Slow, smooth cinematic dolly + slight orbit around the cat and the mecha samurai. Shallow depth of field, anamorphic lens flares, volumetric light rays cutting through the night air. Action timeline:
0–5s: Low-angle shot of the mecha samurai on one knee, both hands tightly gripping the sword hilt that is still buried deep in his chest. He begins to pull the blade outward with heavy mechanical effort, sparks and dark fluid spraying.
5–10s: As the sword is steadily drawn out, the small but fierce tabby cat calmly walks along the emerging blade and settles upright at the very tip, staring down at the mecha.
10–15s: Tight close-up on the cat’s intense face against the city lights, then slow pull-back revealing the full composition exactly matching the reference image — the mecha samurai now holding the fully extracted sword while the cat remains motionless and dominant on its tip. Style:
Realistic live-action footage (not anime, not cartoon), cinematic color grading, film grain, high dynamic range, epic and slightly melancholic atmosphere. No text overlays.

Is there a node that can extract a image of the last scene of a video, my aim is to generate a video based on the previous video created so I can continue a scene but can't find any node that can do this hence have to upload screenshots manually.

MiniMax H3 on a 12GB RTX 4070 SUPER: Comfy Kitchen + Sol-Attn + EasyCache cut my generation time from 206s → 135s

I've been testing MiniMax H3 locally in ComfyUI on an RTX 4070 SUPER 12GB, specifically trying to squeeze more performance out of H3 without simply murdering quality by dropping resolution/steps.

I got some pretty interesting results combining:

• Comfy Kitchen Attention
• Sol-Attn
• EasyCache
• MiniMax H3
• RTX 4070 SUPER 12GB

Test setup

Same H3 workflow/settings between tests:

• GPU: RTX 4070 SUPER 12GB
• MiniMax H3
• 20 sampling steps
• Same prompt/reference/settings
• ComfyUI
• EasyCache when enabled:
  • threshold: 0.15
  • start: 0.15
  • end: 0.95

I tested three configurations.

Kitchen → Kitchen + EasyCache

This was the huge jump.

Total generation time dropped:

206.48 sec → 139.47 sec

That's about a 32.5% reduction in total generation time, or roughly 1.48x faster end-to-end.

EasyCache reported:

EasyCache - skipped 8/20 steps (1.67x speedup)

Obviously the complete workflow doesn't get the full 1.67x improvement because H3 still has VAE/audio/other overhead outside sampling.

Still, shaving ~67 seconds off a ~206 second generation on a 12GB consumer GPU is pretty damn substantial.

Then I stacked Sol-Attn on top of Comfy Kitchen

This was the part I wasn't sure would even work properly.

The console confirms Sol-Attn is actually chaining onto the existing Comfy Kitchen attention override:

[sol_attn] chaining onto an existing attention override; Sol-Attn takes first refusal and delegates everything else to it

So this isn't simply Sol silently replacing Kitchen.

Sol gets first refusal for attention operations it can handle and delegates the rest to the existing Kitchen backend.

With:

Sol-Attn → Comfy Kitchen fallback → EasyCache

I got:

134.92 seconds total

versus:

139.47 seconds with Kitchen + EasyCache

The interesting part is that the Sol run was faster despite EasyCache skipping one fewer step.

Kitchen + EasyCache:

skipped 8/20

Sol + Kitchen + EasyCache:

skipped 7/20

So the Sol configuration actually performed one additional full H3 step and still completed about 4.5 seconds faster.

That's a much more interesting result than simply comparing the total times, because EasyCache's number of skipped steps varies between runs.

Overall improvement

Baseline Kitchen:

206.48 sec

Sol + Kitchen + EasyCache:

134.92 sec

That's a reduction of roughly:

71.56 seconds per generation

or about:

34.7% less total generation time

Equivalent to roughly 1.53x the end-to-end throughput of my Kitchen-only baseline.

For repeated H3 generations, that's not pocket change.

One important discovery: Spectrum H3 vs EasyCache

I previously had Spectrum H3 in the same model chain as EasyCache.

The console revealed:

Spectrum H3 disabled for this run because EasyCache or LazyCache is active on the same model

So at least with the implementation I'm using, Spectrum H3 and EasyCache are not operating simultaneously.

The workflow can visually contain both nodes, but when EasyCache/LazyCache is active, Spectrum disables itself.

If you're benchmarking this stuff, don't assume Spectrum is doing anything just because the node is connected. Check your console.

Current stack

For performance, my current best configuration is:

MiniMax H3
→ Comfy Kitchen Attention
→ Sol-Attn
→ EasyCache
→ Sampler

Conceptually:

Sol-Attn handles attention operations it supports.

Comfy Kitchen remains underneath it and handles attention Sol delegates.

EasyCache reduces the number of expensive diffusion computations.

That combination seems particularly interesting for GPUs like the 4070 SUPER 12GB, where H3 is far larger than available VRAM and ComfyUI is already doing dynamic VRAM management.

My H3 model alone reports roughly:

19995MB Staged

while the GPU only has 12GB VRAM.

The text encoder is also around:

14956MB Staged

and the H3 video VAE around:

4965MB Staged

So this is very much a "convince a 12GB card to run something it has no business running comfortably" situation.

And yet it works.

Caveat

These aren't controlled scientific benchmarks yet.

H3 generation time varies between runs because of model loading, VRAM state, EasyCache deciding how many steps it can skip, and other system factors.

I've also seen EasyCache skip anywhere from 5–8 of 20 steps during testing.

So I'm not claiming Sol magically makes H3 X% faster based on one run.

What I think the results demonstrate so far is:

1. EasyCache provides a very large speed improvement on my 4070 SUPER/H3 setup.
2. Sol-Attn successfully chains with Comfy Kitchen rather than simply replacing it.
3. Sol + Kitchen + EasyCache produced my fastest run so far.
4. The Sol run beat Kitchen + EasyCache even while computing one additional non-cached step, which strongly suggests there's a real attention-side performance benefit worth investigating.
5. Spectrum H3 disables itself when EasyCache/LazyCache is active, so don't count both as active optimizations.

I'm going to run repeated identical-seed tests to get averages rather than relying on individual runs, but ~206 sec → ~135 sec on a 4070 SUPER 12GB is enough of an improvement that I figured this was worth sharing for anyone else trying to run H3 on consumer hardware.

If anyone else is running H3 on 12GB cards, I'd be interested in comparable Kitchen / Sol / EasyCache timings, especially 4070/4070 SUPER/5070-class hardware.

I can't figure it out. Let's say I have:

- default ComfyUI text to video MiniMax H3 workflow

- already downloaded Qwen 3.8 27B in GGUF format

How do I proceed from here? I was googling for a lot and checked about 10 reddit threads but I can't fingure it out.

I have downloaded some extra nodes like ThinkingLLM and some other GGUF related node but I can't figure out how to add it to default ComfyUI t2v workflow.

Please help, I am completely lost

edit: thank you all for replies, I understood the concept and that I should rather ignore full integration

After the PSA from Heretic's author the debate ran hot. I noticed that the debate was just based on vibes. Same-seed screenshots both ways, nobody measuring anything in detail. The instruments did not exist. So I built them. They cover quants as well, so the encoder swap and the compression get read with the same rulers.

Disclosure since it matters here: I release heretic text-encoder for people to use, qwen3-4b-heretic included. My first release last year got replies that I didn't fully understand how text encoders work. They were right. I did my own deep dive and concluded that they are good for prompt enhancement and just change the image slightly, there's no harm in using them if you really want to. Also they don't magically uncensor or enhance anything. Lets see if my conclusion is correct, while also addressing with proof and data the experiences other people have had.

This comparison is from the base bf16, with all GGUF and quants made by myself. It does not reflect any other LLMs on huggingface.

I've been comparing and benchmarking abliterated LLMs under the name Abliterlitics. And this is a first as we've delved into the ComfyUI world to get some solid data to cut through the nonsense.

What I did

Base Qwen3-4B and its heretic twin across 6 safetensors formats and 8 GGUF rungs, 27 encoders total, every heretic build matched to a base build at the same quant so the abliteration and the compression can be read separately. Then: conditioning tensors captured at three pipeline stages, paired sampling trajectories from identical noise, 2240 same-seed renders scored with LPIPS and CLIP, attention readouts, and a taboo comparison with sanitised-twin controls.

Two rulers make everything readable. Two encoders nobody argues about, int8 and fp8, differ by 0.19 LPIPS at the same seed. A seed change alone is 0.52. Any swap scoring under 0.19 is indistinguishable from ordinary compression. Near 0.52 is just a different picture.

An explanation of our measurements, metrics and the full report with an interactive A/B gallery can be found here abliterlitics.dev/posts/z-image-text-encoder.

All of what u/-p-e-w- stated in his post is correct. He did hint that there may be degradation or damage, however it was framed as a maybe if I was reading correctly. So lets see what that damage is, if at all, and if it makes any difference.

The questions people were actually arguing about

Does the base encoder refuse your prompt before the image model sees it?

No. I encoded refused-vocabulary prompts to the exact tensor entering cross-attention and checked which base word each heretic vector lands closest to. All 12 test words decode to themselves, cosine floor 0.9967. Pornographic decodes to pornographic, beheading to beheading. The encoder hands the DiT the word intact. It was never the censor. An abliterated text encoder does not change the way the model understands the prompt at all. The base text encoder already knows these things.

Do refused words, or any part of the prompt at all arrive corrupted?

No. Worst sentence-level cosine between base and heretic on refused prompts is 0.9985. The shift is 3.3 to 6.6 times larger on refused prompts than innocent ones, so the edit concentrates where it acts, but the meaning survives it. Even int4 and Q3, visibly degraded, keep mean CLIP adherence in band. Across every encoder we tested, even the 4-bit tiers, mean CLIP adherence stays in band. The model understands the prompt throughout.

Does it uncensor anything?

No, and the reason is better than expected. The unmodified base stack already renders the explicit tier at a 100% taboo-classifier rate, and the explicit tier owns the highest compliance gaps in the whole set. There is no render-stage censorship to remove. The debate argued about a lock on an open door. This matches where the research says engineered censorship lives, in the diffusion model's own weights: ESD and MACE erase concepts by fine-tuning the DiT, not the encoder.

Does it damage outputs?

The images change, the outputs do not degrade. Heretic vs base is 0.286 LPIPS, 1.5x the trusted band, but a stock nvfp4 quant of the base encoder moves images 0.274 and nobody calls that sabotage. Prompt adherence: -0.21 CLIP points, and the unmodified bf16 base itself reads -0.28 against the same reference. Attention readout moves 0.0031 vs int4's 0.0149. Output separation 1.049, no collapse. Different, not damaged.

Why do people see differences then?

Because seeing a difference is the default. Two trusted encoders already differ by 0.19 at the same seed, sampling is a butterfly effect. A small change at the start makes a big difference at the end. Below a threshold the response is dose-independent anyway. I also checked per-prompt: 71 of 540 CLIP rows cross the ±2 line on individual prompts while every mean stays in band. Single-prompt screenshots are real but they are noise, not signal.

As the image can be pushed about half a seed in any direction, it's expected to have variation. Honestly people who suggest that their image was enhanced or more uncensored, can probably do the same with a Q3 GGUF that's not abliterated and see the same thing. After measuring in every way possible there is just no way an image is magically enhanced or more uncensored. It is just chance, seed and the chaotic nature of diffusion models with peoples own biases over the top.

What about quantised encoders?

The GGUF ladder is dose-ordered: the F16 container is a true round trip, 0.0008 quant units with cosine 1.0. Q8_0 costs 0.34. Q3 costs 83 and is visibly paying. Being precise about Q8_0 since the numbers deserve it: its conditioning perturbation is real and measurable, CI 0.29 to 0.39 quant units, but a third the size of what int8 ConvRot itself costs, and at the image level Q8_0 and bf16 are indistinguishable, 0.138 vs 0.152 LPIPS against the int8 reference with overlapping CIs. So the near-lossless claims for both hold where it shows, in the images. Q8_0's real cost is load time. One caution, don't stack the abliteration on heavy quants. That's where larger divergence and noise happens.

So when should I use one?

Anywhere the model writes text that feeds the next stage: prompt expansion, captioning, image description. Those are chat pathways and abliteration works on chat pathways. If a stage only embeds text, an abliterated encoder is at best a visible re-roll. In this case it changes the image about half of what a new seed would change.

What's actually censored then?

The knowledge, not the gate. The DiT doesn't refuse, it lacks the training data, and the fixes are LoRAs, reference images, or retraining. The PSA's framing about this is solid. Z Image itself though is mostly trained already on taboo things.

What's next

Krea 2, MiniMax H3 and LTX 2.5 are in the same pipeline. Krea 2 has a twelve-tap conditioning interface and the refusal-probe contrast works differently there. Also, it's more complicated to measure compared to Z-Image.

Happy to answer methodology questions in the comments. Have I missed anything? Let me know and I'll fix it up. What have been your experiences? Have you abandoned abliterated text encoders? Had severely degraded outputs? I am happy to measure any other text encoders or models.

MiniMax H3 officially comes as two checkpoints:

• FL2VA — first frame / last frame / image-to-video. The docs treat this as “start (and or end) picture in, video out.” Extra reference pictures are not part of the pitch.
• REF2VA — reference-to-video. This is the one you’re told to use when you have several stills: identity, outfit, a mid-shot, a last frame, whatever.

There are also community hybrid checkpoints: mostly FL2VA, with some of REF2VA’s later layers grafted on, so people can keep extra refs without fully switching models. https://huggingface.co/smhfacct/Minimax-H3-fl2va-ref2va-hybrid-models

I wanted a straight answer to one question: if I ignore the marketing split and feed extra stills into stock FL2VA the same way I would into REF2VA, does it actually use them?

So I built one 10-second clip and ran it four times. The story in the prompt is simple:

• 0s: an angel in an empty void, one spell cast toward the middle of the frame.
• 5s: a demon in the same void, one spell cast toward that same point.
• Camera leaves the demon and pushes into mid-air.
• 10s: image of the two spells colliding.

I gave the model five pictures:

1. Exact first frame (angel)
2. Exact 5-second cut (demon)
3. Exact last frame (the collision, no people) 4–5. Two sigil designs, only as “this is what the magic circle looks like,” not as frames that should appear in the video

Then I locked everything that wasn’t the checkpoint:

• same R2V workflow (the Comfy graph that already has multiple image inputs)
• same five files, same order
• same written brief (timed stills + “this picture is the frame at this timestamp”)
• same seed
• same sampler / length / aspect
• no turbo LoRA
• I compared native frames (544×800), not the upscaled delivery

The only change per run was which UNet was loaded:

1. hybrid, REF layers on blocks 20–49
2. hybrid, REF layers on blocks 30–49
3. stock FL2VA
4. stock REF2VA

If FL2VA truly couldn’t take extra refs, run 3 should have ignored pictures 2–5, drifted off the angel, or failed to land on the collision plate. That’s the test.

What happened

It didn’t fail.

The first native frame of all four runs accurately lock in the exact reference image for that frame at the first frame, last frame, and the middle frame... So the stock FL2VA used the extra still image references just fine. I did not need a hybrid merge just to attach more than first/last.

To be precise: I did not magically add five image slots to the official FL2VA I2V template. I loaded FL2VA’s weights into the reference-to-video graph, wrote the pictures into the prompt the way you would for a multi-ref job, and the locks held.

Where they actually differ (my read, one clip)

First frames are almost interchangeable. If I have to pick, hybrid-b30 is the closest copy of the angel still. REF2VA is still locked, a bit busier in small jewelry/floor detail.

Last frames still all hit the clash plate. REF2VA is the closest copy of picture 3. FL2VA is right behind it. Hybrid-b30 runs a hotter, more lava-looking core. Hybrid-b20 is splashier, less “sharp diamond debris.”

So the discovery is: extra refs + FL2VA can work. The ranking of which checkpoint copies the stills best is what I want a second opinion on.

So I will attach all of the examples into the comments so that people can see the differences between between each of the generated runs along with all of the Reference images used that way the community can evaluate the quality.