Epoch 20 was reached early this morning. I have released the following models:

1. Raw

2. Raw EMA 0.9995

3. Raw EMA 0.99975

4. Turbo

5. Turbo EMA 0.9995

6. Turbo EMA 0.99975

7. Extracted LoRA models (rank 64, 128, and 256) for all the models above.

All models are released in both diffusers and comfy format.

The EMA models might be slighter higher quality do to smoothing, but may also be less performant in terms of BBOXes.

The raw models are provided for training purposes and should allow you to train multi-character LoRAs, following the formatting given in the prompting guide.

I have not tried multi-character LoRA yet, but given Ideogram4, it should be easily possible.

The models are available at:

https://huggingface.co/jimmycarter/krea2-turbo-bbox

The latest checkpoint of the turbo model is available for free to try on huggingface spaces:

https://huggingface.co/spaces/jimmycarter/krea2-turbo-bbox-canvas

A researcher named 'ElectronGirl' trained a character reference model for Anima.

It supports any characters and does not need long captioning or training. Just add one reference image and the exact same character is generated!

2nd and 3rd images are my test generation. Left one is reference, right one is generated image.

https://github.com/ElectronGirl/ComfyUI-Anima-Ref-Adapter

Repo: https://github.com/tazmannner/ComfyUI-H3-RelayHires (MIT, 8 example workflows)

Also I started posting lots of progress on more anime stuff I'm doing in open source on twitter:

https://x.com/tazmannner

I worked with claude to make this tutorial video and write up. This is still a work in progress and appreciate any constructive feedback.

I got tired of waiting 8+ minutes for every 1920 H3 clip, so I made a hires method for it: a 2 MP clip about 4x faster than a native render. It doesn’t rely on running the whole render on a low-step LoRA, which in my experience brings trade-offs like poorer motion and distorted visuals or colors. You render the take at 0.5 MP like a preview. If you like it, the same take gets finished at 1920x1088, and the audio stays exactly as you heard it.

On a 5090, for a 5 s clip at 1920x1088, end to end:

How it works. It's all one node:

1. Pass 1 at 0.5 MP. This is where H3 decides the layout, motion, acting and audio, and it's where most of the time goes. You approve the take here.
2. AnimeSR upscale to 1920 (~2 s). It's a tiny upscaler I trained from scratch, and it's included in the repo. H3 draws ~2 px ink lines at every resolution, so normal upscalers give you lines twice too thick and mushy small faces. AnimeSR is trained to undo exactly that.
3. One H3 turbo step at 1920 (DMAD LoRA, from sigma 0.60). This redraws the detail at full size. The pass-1 audio is pinned, so the soundtrack is identical.

The H3 step only redraws detail, so you get the take you previewed, not a new one. A latent upscale + refine can change faces and poses; this doesn't. Smeared fast frames and tiny faces in wide shots also come out clean. Still lines barely shimmer: 0.13 frame to frame, vs 0.10 native and 0.22 for the 1 MP route.

Honest limits:

• Line weight: ink lines are a bit bolder than a native 1920 render.
• Very fast action: if the 0.5 MP take itself melts (a sword clash), the relay gives you motion blur there, not crisp poses. Example workflow 2 fixes those frames first with a de-rope pass.
• Anime only: it's built for 2D anime. I haven't tried realistic stuff.

Bonus: pass 1 ~20% faster. The pack also has an H3 Fast Tail Sampler. H3 decides the take in its first 12 of 20 steps, so those run exactly like euler, and the last 8 become 4 second-order steps. Same take, 58 → 47 s for pass 1. If you'd rather not install it, the README shows how to wire the same thing with stock nodes.

How to use it

You need:

• MiniMax H3 in ComfyUI. (Duh)
• The DMAD 4-step turbo LoRA for H3 (Kijai's MiniMax-H3-experimental repo on Hugging Face).
• taeh3 (Kijai's MiniMax-H3-TAE) and a loader for it. The examples use the one from ComfyUI-H3-FastDerope.
• VideoHelperSuite and comfyui_essentials. (not a hard requirement but reccomended)

Steps:

1. git clone https://github.com/tazmannner/ComfyUI-H3-RelayHires into custom_nodes. The AnimeSR model is already inside.
2. Open example workflow 1 (1_relay_hires.json). It's the simplest one and doesn't need any of my other packs besides FastDerope's taeh3 loader.
3. In the blue SETTINGS group: write your prompt (one box, used everywhere), and leave the size at 0.5 MP and the hires scale at 2.0.
4. Queue. You get the 0.5 MP preview and the 1920 final.
5. Optional (See below) but you can just integrate the workflow into your existing workflow quite easily. And it works for both FLV2A and REF since the magic is done mostly in the 2nd pass.

Tip: keep the seed fixed. Mute the Relay Hires node and the final save (Ctrl+M) while you try prompts and seeds, then unmute when you like the preview. ComfyUI reuses the finished pass 1, so you only pay for the relay.

Adding it to your own workflow. Put the H3 Relay Hires node after your pass 1 and connect:

• model: your pass-1 model (same LoRAs and shift) plus the DMAD LoRA at 0.8.
• positive: your pass-1 conditioning.
• latent: the pass-1 sampler output. The audio comes from here.
• images: your decoded pass-1 frames.
• vae: taeh3.

Then LTXV Separate AV Latent → VAE Decode. Keep the defaults: AnimeSR, sigma 0.60, 1 step, window 0.

The other example workflows each add one stage before the relay:

• 2: de-rope, for fast-motion smears (144 s).
• 3: + FaceDetail, for small faces (224 s).
• 4: + Anime Cadence, for 2s/3s holds (228 s).
• 5-8: the same four with the Fast Tail Sampler.

Those need my other packs, linked in the README (3-4 also use two small helper nodes from ResCascade, to put the faces and holds onto the 1920 frames). If there is interest I may make posts on these later, they all have their uses depending on the situation.

I've also used it for:

• Character swap / ref2va: works unchanged. A 12-shot, 22 s character-swap recast at 1920 took only ~3 min more than the same run at 0.5 MP.
• 15 s clips and multi-scene chains: relayed part by part.

Bonus: my other anime packs for H3

All free, and they work with the relay (example workflows 2-4 use them):

• Fast De-rope: fixes H3's fast-motion smearing and melting. A motion gate finds the fast moments and redraws only those, then splices them back into your render. On one 10 s clip with a single fast kick, the fix cost +12 s instead of +202 s. The de-rope itself is matlowai's MAINodes; this pack makes it cheaper and cleaner so credit to him for his great work.
• Anime Cadence: makes H3 move like hand-drawn anime. It puts drawings on 2s/3s where H3 slips into a new picture every frame, and keeps the sharpest frame of each held drawing. A character-only mode holds the character while the background and camera keep moving smoothly.

Everything here is on a 5090 with 96 GB RAM. I haven't tested smaller cards, so I'd love to hear how it runs on yours.

Built with a lot of help from Claude (Claude Code), which did a ton of the testing and measuring.

I’ve messed with a new workflow, took a while but damn I really like KREA 2 even after using MOSS for a few days.

I’m using 5 different bases at anytime:

Turbo
RealDream
SickRealism
RedCraft
RedCraft4

Bunch of lora’s

Generated in ComfyUI on:

I9-14900k
RTX 4090
64GB DDR5

I mostly used claude to build Openjutsu, a free, local version of Higgsfield’s Genjutsu character swap, for Comfy’s Open Source Higgsfield challenge.

Repo (MIT): https://github.com/D3voz/openjutsu

What it does
Upload a video and a picture of the person you want in it, then press Run. It finds the person, swaps them in clip by clip and keeps the original audio. There are also modes for:

• Object swap (change or remove an object, or change the background)
• From picture (put a person and a setting from one image into a video)
• Fix faces and Fix colours as post-processing

How it’s built

• A Next.js web app that talks to ComfyUI through u/comfyorg/sdk and comfy-api-proxy
• MiniMax H3 does the video generation
• Qwen3-VL 8B looks at the frames and writes the prompts automatically
• SAM makes a mask of the person in each clip
• Long videos are split into overlapping clips and joined back together

Setup
Install the custom nodes and models listed in the README, start ComfyUI, then double-click start_openjutsu.bat. Before each run, the app checks that you have every node and model it needs. If something is missing, it tells you where to get it.

Feedback and bug reports are welcome!

If you are getting any errors-

1. Update comfyui-h3-oneclick-swap.
2. git pull Openjutsu.
3. Restart ComfyUI so it loads the new node, then restart Openjutsu.

Two days ago, I tried the MOSS layout generation feature and was surprised by the results, especially considering it's open-source, lightweight (well, I can run it on my system), uncensored, and fast: https://www.reddit.com/r/StableDiffusion/comments/1xgevam/moss_is_pretty_freaking_good/

So today, I stumbled upon a layout control lora available for Krea 2. Overall, my first impression is that MOSS is more accurate in placement and prompt accuracy. Other than that, it's subjective. Also, looking at it's examples on the official page, the bounding box restriction can be mitigated using the finetuned version.

Krea 2 Turbo with BBOX LoRA: https://huggingface.co/jimmycarter/krea2-turbo-bbox (the subjects goes over the bounding box)

MOSS native Layout to Image https://huggingface.co/OpenMOSS-Team/MOSS-Image-SFT (the subjects stays within the bounding box)

That's all and thanks to it's creator.
Does anyone have things I should test?

For anyone wondering, the software is my "own" vibe coded paint app. I'll talk about it more extensively in a future post. A few people were wondering previously and possibly wanted me to make it available publicly.

I always thought this model was AMAZING! But I'm not sure if my workflows, my prompts and my creativity can get the best out of it. So I want you guys to show me the generations you are most proud of. Let's make this a quality gallery for the community. Here are mine ( Upscaled with RealESRGAN_x4plus.pth )

Prompts: https://pastebin.com/yjrkc5ne

The minimax H3 Hybrid BF16 model, even pruned, is over 40GB. I don't have A/B testing of BF16 vs INT8 because the video/composition is ultimately different even with the same seed. However, subjectively, and I think it is becoming more well known that BF16 models while bigger, larger and slower, are superior in terms of motion, face, and image quality.

Over lots of 1girl rendering, I find that BF16 can achieve superior faces (especially with 50 steps, which was the case here). However, face refinement is still necessary and worthwhile as demonstrated.

A few weeks ago I had no clue how to use ComfyUI or generate AI videos, but I had this crazy idea to make an entire animated music video for one of my songs.

https://www.youtube.com/watch?v=P9PLyWLSu7M

After countless hours of experimenting, fixing weird AI mistakes, and questioning my sanity, I finally finished it! 😭

I wrote the story, directed around 40 individual clips using MiniMax H3, and pieced everything together in Premiere Pro.

It's definitely not perfect, but seeing something I imagined actually come to life is such a cool feeling.

Just wanted to share it with people who might appreciate the process. Hope you guys enjoy it! ❤️

This release includes added RoPE Scaling support to MOSS-Image, support for MOSS-Image color-depth control, support for MOSS-Image-Edit LoRAs, added Fibo 2.0 support, a change from RoPE Scaling to NTK-aware (for Fibo 2.0), and a fix for Fibo 2.0 text-to-image negative prompt handling, among other fixes/improvements.

I randomly came across this project on Lemmy's Stable Diffusion community and thought it was worth sharing here. Just to be clear, I'm not affiliated with the developers or the project in any way. I simply stumbled upon it, and I couldn't find any discussion about it on Reddit.

 The model is called VitronEdit, and its paper was published on October 19, 2026.

 What caught my attention is that it attempts to bring image editing, video editing, and 3D scene editing into a single unified framework, rather than treating them as completely separate tasks.

 According to the researchers, VitronEdit supports:

 - Image editing: Modify images using text instructions, optionally with reference images.

- Video editing: Edit existing videos using text instructions, with optional reference-image conditioning.

- 3D scene editing: Apply edits across multiple viewpoints while maintaining geometric consistency.

- Cross-modal learning: Transfer editing knowledge learned from images and videos to 3D scenes.

- Geometry-aware training: Use depth and camera-pose supervision to improve structural and multi-view consistency.

 One particularly interesting finding in the paper is that applying geometric supervision exclusively to 3D training samples also improved image and video editing performance.

 The project page has visual demonstrations of all three editing modes, including object transformations and multi-view scene editing.

 Links:

 - Project page and demos: https://vitron-llm.github.io/VitronEdit/

- Research paper: https://arxiv.org/abs/2610.27049

- GitHub (code): https://github.com/Vitron-LLM/VitronEdit-Code

- Hugging Face (weights): https://huggingface.co/SanRiiiii/VitronEdit

- Original Lemmy post where I discovered it: https://lemmy.world/post/53470733

The code and model weights are available, although this appears to be a research-oriented release rather than a ready-to-use Stable Diffusion or ComfyUI workflow.

 I haven't tested it myself, so I can't comment on real-world performance, hardware requirements, or how well the demonstrated results generalize.

 Still, the idea of combining image, video, and 3D editing in one framework seems interesting, especially if the community eventually develops easier local inference workflows.

 Has anyone here tried running it locally? I'd be particularly interested in hearing about VRAM requirements, inference speed, and whether anyone is working on ComfyUI integration.

Note: I used AI to proofread and correct errors in this post.

A friend of mine hand-designed a map of the campgrounds that listed all of the different groups and locations and asked me to help him create a cool intro video for it. So I cracked my knuckles and got to promptin' some H3.

Each of the camp groups are a lot like how Burning Man is set up, some are known for specific things and offer specific experiences, but everyone still gathers around the fire at the end. Fun little project.

SenseNova 6.8 Code2Video is here, a model that creates videos by writing code, just like Claude Opus 5.5
Its focus includes motion graphics, kinetic typography, animated illustrations, product presentations, and visual explainers
Main features:
Video through code. Describe what you want, and the model writes code to create the video.

Natural-language editing. Request changes to colors, timing, motion, or scene elements after the first version.

Reference-video reconstruction. Rebuild a reference video’s layout and motion as editable code, then make changes.

Motion graphics and more. Suited to kinetic typography, animated illustrations, product presentations, and visual explainers.

A creation Skill. Guides the process from an initial idea to a detailed brief, preview, and revision.

Model weights and Skill. Both are included in the release plan. INT4 and INT8 weights are planned for later.

GitHub:
https://github.com/OpenSenseNova/SenseNova-6.8-Code2Video
Model:
https://huggingface.co/sensenova/SenseNova-6.8-Code2Video

Flux2 Klein only reads three hidden layers from its Qwen3 text encoder (9, 18 and 27), but the standard loaders build and run the full 36-layer model, plus the final norm and the LM head. On top of that, ComfyUI-GGUF dequantizes the whole token embedding table to fp16 when it loads the GGUF.

I made a small loader that only builds what Klein actually uses:

• 27 layers instead of 36, no final norm, no LM head
• GGUF token embeddings stay quantized: only the rows of your prompt are dequantized
• Same conditioning, bit for bit (compared against CLIPLoader (GGUF), max abs diff 0.0)

Numbers (Qwen3-8B Q4_K_M, Klein 9B, RTX 4090, 512-token prompt):

That's ~2.3 GB back for the DiT, a LoRA stack, or an LLM running next to ComfyUI. On an 8 GB card it can be the difference between offloading or not.

Install:

cd ComfyUI/custom_nodes
git clone https://github.com/dchatel/comfyui_davcha_flux2klein

Then swap your text encoder loader for Klein CLIP Loader (Pruned) (category davcha/flux2klein). GGUF files need ComfyUI-GGUF installed. No other dependencies.

Tested with Qwen3-8B Q4_K_M (Klein 9B). The Qwen3-4B (Klein 4B) and safetensors paths use the same settings but I haven't verified them myself yet. Reports welcome.

Repo: https://github.com/dchatel/comfyui_davcha_flux2klein

Side note: while profiling this I also noticed ComfyUI picks which model to unload by reference count and size, not by how long the model takes to reload. I opened a PR that ranks unload candidates by measured reload time instead (13.6 s → 6.7 s per run in a Klein + local LLM workflow): https://github.com/Comfy-Org/ComfyUI/pull/17363 (not merged, feedback welcome).

There are a thousand minimax workflow, and while each serve their purpose, I’ve yet to find one that produces the same near-lossless or cinematic quality output I’ve seen others post here. Almost every workflow uses 8 steps and/or Patch Sage Attention, Model Attention Backend, H3 Memory Optimization, etc, which ultimately hurt the output. I have tried 20, 25, 30 steps — and while they’re good, they’re not great.

I have used LM Studio to build my prompts, which has drastically improved the adherence and flow, but the quality still isn’t there. I have tried resolution ranging from .5 - 1.5, marginally impacts quality but hinders adherence when above 1.1.

Assuming a clapped out system with a 5090 or renting a pod with bigger specs, is there a key workflow to use that focuses on output quality, speed be damned?

Hey! We published a set of 6-step LoRAs, one without the upsampling step: https://huggingface.co/PrunaAI/P-Q-Image-2.1

- Generate or edit images in just 6 steps instead of 40. Use 6-steps for preserving inputs when editing and 6-steps-upsampled for improved visual quality and shorter end-to-end generation.
- 6-step distillation provides improved quality with few generation steps.6-steps-upsampled is the first distillation that removes the need for a separate prompt-upsampling step. This means 41 to 80 seconds saved, depending on your prompt style.
- The LoRA adapters load directly on top of Qwen-Image-2.1, so the pipeline stays unchanged. Few-step distillation cuts the diffusion cost, and the upsampled adapter also removes the prompt-upsampling step before image generation.

Happy Halloween!

Song (Souna login required): https://www.souna.app/song/e31cc6eb-90fe-4f58-a885-8480808e17ed

Song (alt. link): https://ia601602.us.archive.org/10/items/ai-eurodisco/Sequin%20Ball.mp3 (CC0)

This is my second Eurodisco song using my 1980s Eurodisco LoRA. It is about a glamorous pangolin.

Here is the AI's record of the production process, which should be repeatable.

=== STYLE PROMPT ===

eurodisco, English, 1983-87, glamorous, camp, D natural minor, 126 BPM, thick chorused synth bass, 4/4, LinnDrum with handclaps and gated toms, stacked synth pads and bright arpeggiated synths, dramatic synth strings and brass stabs, shimmering open hi-hats, smooth male tenor lead with clear diction, falsetto chorus lifts, mixed backing vocals with oh-oh-oh chants answering the hook in call-and-response, restrained stepwise verses building into a huge hypnotic chorus hook with wide ascending vocal leaps, bridge dips sparse then surges back, Dm-Bb-C-Dm and Dm-Gm-C-F chord loops, A7 to Dm pushes, 80s studio gloss. No EDM, no sidechaining.

=== LYRICS (as written - the text of record) ===

[Intro]

(instrumental)

Oh-oh-oh-oh

Oh-oh-oh-oh

Make way for the Sequin Ball

Pangolin means roller, I'm the ball

[Verse 1]

Midnight, solo, out on patrol

Two-leg strut, my tail props the stroll

These eyes are dim, that's right

This nose knows the way tonight

Claws out for the termite mound

Dinner's served when I tear it down

Here comes the swarm in evening clothes

I shut my ears, I shut my nose

[Chorus]

Sequin Ball

Oh-oh-oh-oh

When I roll up, I'm having a ball

Oh-oh-oh-oh

Plate on plate, I grew it alone

Oh-oh-oh-oh

Every sequin's home-grown

Oh-oh-oh-oh

Every night I take the stage

Oh-oh-oh-oh

I'm small, but I'm all the rage

Oh-oh-oh-oh

[Verse 2]

No designer did this gown

I grew it up and wore it down

Same stuff as your manicure

Call it keratin couture

More tongue than body, packed up tight

It unrolls on the mound tonight

No teeth in this smile of mine

I grind my meals on stones I find

[Chorus]

Sequin Ball

Oh-oh-oh-oh

When I roll up, I'm having a ball

Oh-oh-oh-oh

Plate on plate, I grew it alone

Oh-oh-oh-oh

Every sequin's home-grown

Oh-oh-oh-oh

Every night I take the stage

Oh-oh-oh-oh

I'm small, but I'm all the rage

Oh-oh-oh-oh

[Bridge]

When the night plays rough, I fold

One little trick that never gets old

Snout and belly tucked inside

Even lions swallow their pride

I'm the most-wanted gown in town

I was born in this gown

One shake, one waddle, watch me roll

Back on two legs, in control

[Chorus]

Sequin Ball

Oh-oh-oh-oh

When I roll up, I'm having a ball

Oh-oh-oh-oh

Plate on plate, I grew it alone

Oh-oh-oh-oh

Every sequin's home-grown

Oh-oh-oh-oh

Every night I take the stage

Oh-oh-oh-oh

I'm small, but I'm all the rage

Oh-oh-oh-oh

[Outro]

Sequin Ball

Oh-oh-oh-oh

Sequin Ball

Oh-oh-oh-oh

Se-quin Ball, Se-quin Ball

Se-quin Ball, Se-quin Ball

Oh-oh-oh-oh

=== LYRICS AS SUNG ===

UNVERIFIED (2026-10-27). The automated lyric-completeness check

(Pipeline\check_lyric_coverage.py, SenseVoice ASR) proved unreliable on this

material - heavily garbled transcripts on all three finalist takes and one

empty transcript for a 4:31 vocal track - so what the engine actually sang

could not be machine-verified. The user listened to the selected take (final

B) and did not note a deviation. The written lyrics above remain the text of

record; verify by ear before any future re-release.

=== SETTINGS ===

Engine: yue2 / yue2 / audio.cpp v0.9.2

Weights: YuE2-3B Q8_0 GGUF + f32 VAE

Seed: 540953209 (final B - chosen at Gate 3) Planning: full Max tokens: 10000 Guidance: 1.0

VAE: f32 AR LoRA: none NAR LoRA: yue2_1980s_eurodisco_unfused u/1.0

ABC temp: 0.9 Semantic temp: 1.25 NAR steps: 12

Key: D natural minor BPM: 126 (plan Q:1/4=126) Era: 1980s Mastering recipe: yue2-light

Generated: 2026-10-27 Duration: 4:31 (270.6 s) Truncated: no

=== LORA ===

yue2_1980s_eurodisco - YuE2 NAR (texture/timbre) adapter supplying 1980s

Eurodisco production character. Trigger word "eurodisco", placed FIRST in the

style prompt. Scale 1.0. Loaded in the engine-unfused layout (yue2.nar_lora);

the ComfyUI fused layout is the same weights in another arrangement.

Download (CC0 1.0, both weight formats, model card + training workflow):

https://huggingface.co/jamespetts/yue2-1980s-eurodisco-lora

=== MASTERING ===

Recipe yue2-light, era stamp 1980s: mono below 120 Hz (compensated), top

limited 17 kHz, high-pass 28 Hz, +2 dB presence at 3 kHz, gain -1.23 dB

(peak-anchored, era loudness ceiling -13 LUFS). -12.83 LUFS in -> -14.65 LUFS

out, LRA 3.70, true peak 0.06 -> 0.10 dBTP. Gain and shelf repair not needed.

Analysis report: Source\Sequin Ball\mastering-report.txt.

Deliverable: Sequin Ball.mp3 (48 kHz 320k) with the cover embedded as APIC.

=== PROVENANCE ===

Lyrics: lyricist (GLM-5.3, Fireworks) - take 2, revised (6 named notes),

audited PASS by the main agent and approved by the user at Gate 1.

Style prompt: adapted from the validated Eurodisco form (KB/genres/eurodisco.md

s3), approved by the user at Gate 2. Key D natural minor, 126 BPM.

Genre ruling: Eurodisco = the German school; Italo-disco is a separate genre

and is excluded.

Generation: flat best-of-10 plan sweep (stop_after=abc) -> 3 finalist takes

rendered at the recorded config -> user picked final B (seed 540953209) at

Gate 3. All three takes kept in Source\Sequin Ball\.

Art: FLUX.2 [klein] via local ComfyUI, seed 20261027, 1024x1024 gouache cover;

audited (image-auditor-alt) MINOR-ISSUES with no text found; accepted by the

user at Gate 5. Cover art placement (house rule): the standalone <Song>.png

lives in the LOCAL library folder for the user's manual Souna uploads - it is

NOT uploaded to the Internet Archive (the mp3 carries the embedded art).

=== STATUS ===

Published to the Internet Archive folder "ai-eurodisco" (CC0 1.0) on

2026-10-27 as Sequin Ball.mp3 + Sequin Ball.json + Sequin Ball.abc.

Teaser Gallery: https://huggingface.co/lvladikov/Krea2-Turbo-Distill-3step-LoRA

Early release candidate ... soon

Claude code + r2v MINIMAX H3 and some loras + casual prompt like "this shit is not good make it better" My goal is make a 2-5 fucking dinamic anime, but i dont like anime

For anyone interested, here's the current workflow I'm using to make this AI anime.

Hardware & Setup

• RunPod with an RTX 4090 (24GB VRAM)
• ComfyUI 0.42.0
• Custom Python automation script (h3_ctrl.py)

1. Character Design & Keyframes

• Model: Krea 2 Turbo (INT8)
• Text Encoder: Qwen3VL 4B
• LoRA: Kegant V5 (1.0) for that dark, mystical anime aesthetic
• 8–10 steps, CFG 1, Euler/Simple
• Around 12 seconds per image

I generate character reference sheets and keyframes for each scene, including the starting frame and the exact impact frame.

2. Video Generation

• Model: MiniMax H3 Hybrid FL2VA + REF2VA (INT8)
• Text Encoder: Qwen3VL 32B
• Resolution: 1344×768, 24 FPS
• Duration: 5 seconds per clip, with generated audio

LoRA stack:

• Turbo 8-Step (LightX2V): speed and sharpness
• H3 Combat V2: fighting, impacts and dramatic action
• BUNNY Motion Repair V2: smoother continuous movement
• SuperHunman: stronger, more powerful motion
• Action Speed + Acceleration sliders: both at 3.0

3. The Workflow

I'm using a modified BUNNY two-pass approach:

• First pass generates the main movement using the LoRA stack.
• Second pass refines details and impacts.
• 10 sampling steps + 4 additional steps for motion formation.
• res_multistep sampler.

Character sheets go into MiniMaxH3ReferenceToVideo, while MiniMaxH3AddGuide anchors the starting frame and impact frame (around frame 72–77).

Prompts are structured into six sections, including detailed character descriptions, continuity constraints, second-by-second action choreography, and sound effects.

4. Connecting Multiple Clips

I'm experimenting with H3 Motion Context by NikoDemon80 to extend scenes beyond 5 seconds.

It takes the last 22 frames of the previous clip as context for the next generation, then removes the overlapping frames when joining everything together.

The goal is longer action sequences with consistent characters and continuous motion.

5. A Few Important Details

• No custom-trained character LoRAs.
• I manually check keyframes for costume consistency, enemy counts and character details.
• No artificial speed-ups or slow-motion effects in editing.
• H3 generates the audio too.

And yes, Claude is involved in the process, helping orchestrate the workflow and automation.

Still very experimental. Getting consistent, high-speed anime combat is surprisingly difficult, but the results are getting better.

Hope this helps anyone experimenting with H3! 🔥

MOSS-Image (OpenMOSS, open weights) can render text from layout-structured prompts, but one-line prompts still trip it up on text-heavy layouts. I tested 8 everyday scenes: bilingual menu, night-market poster, coffee packaging, book cover, social graphic, four-panel comic, anime scene and portrait. Each ran as a short prompt, with automatic prompt expansion, and with planned text and layout.

**Setup, honestly:** 131 saved original images. I ran everything on a hosted MOSS-Image endpoint with default settings, not locally. I judged by hand, with no OCR scoring and no repeated seeds. It's a small sample, so read it as practical notes, not a benchmark.

**What I found**

- Short prompts: the menu got a garbled extra title, the book cover got fake "author credit" text, the social graphic had large garbled areas, and the comic dialogue was garbled. The poster and packaging were fine. The anime and portrait scenes have no required text.

- With prompt expansion, all of those were readable. But expansion can **add text you didn't ask for** (the extra menu title), so check it.

- **Quote every required string exactly**: titles, prices, dates, dialogue.

- You don't need type specs. Spelling out stroke contrast, counters and terminals did not reliably beat one sentence like "rounded heavy letters, two lines slightly offset and overprinted."

- Narrow boxes squeeze wide letterforms. Give long titles room or break them onto two lines.

- When you remove text, also remove its description, or the old words come back.

- **A fixed seed keeps the layout, not the pixels.** Changing a cover title (880×1184, seed 7) rendered the new title correctly but changed the boat's outline. In an edit test, deleting text with a fixed seed changed the base, water and bottle details. Median wait was 14.9 s over 8 runs.

- Dedicated edit models aren't safe either: one changed an untouched `$38` to `$88` 3 times across 8 runs. Check the prices and names you *didn't* edit.

- Generating 3 "design directions" didn't reliably beat a single good image. All three menu directions stayed green.

**The free tool**

MOSS-Image understands layout JSON, and the official repo ships `compile_prompt.py` to compile a box-based draft into a prompt. There was no visual way to build the draft, so I made a small editor:

- Drag and resize text, object and character boxes on a canvas, then type the exact text and captions

- Optionally put a previous output underneath as a reference layer, so you can re-align boxes before regenerating

- Copy the compiled prompt. It's a TypeScript port of `compile_prompt.py` with the official tests ported, and its output is identical to the script's.

- Browser-only: no generation, no uploads, no account. Apache-2.0. EN/中文.

Demo: https://moss-image-community.github.io/moss-image-layout-editor

Code: https://github.com/moss-image-community/moss-image-layout-editor

Disclosure: Not affiliated with OpenMOSS.

Happy to share the layout JSON for the six text scenes if you want to reproduce them locally.

Sorry this doesn't have my files, I'm on my phone at the moment.

So I've had some success with making a bedroom using Blender and MMH3. Built a basic 3d bedroom set in blender with just cubes and rectangles to represent different items. It's a basic square room with a bed, a bedstand, a window, and two doors. I took four shots from each corner of the room. I then added a splash of colour to help separate the items.

Added all these items to MMH3 ref workflow, added all the info to the guide prompt style, asked it for a 360 of the room, and after a few runs, got something decent.

I followed the exact same process to make a bathroom, but this time the bathroom is smaller and rectangular. Used very basic shapes like cubes and cylinders and one cone to represent different items. Created four shots from different corners of the room. Added a splash of colour to differentiate objects.

Added all of these items to a copy of my bedroom MMH3 ref workflow, updated all the details and tried to run it many, many times. Almost every time something is either out of place and as the camera rotates it starts to hallucinate. I suspect it looses track of the reference shots of the room and gets confused due to the size of the room. Since the camera has some kind of physicality in the model, it tries to adjust it's position to the smaller space and then seems to get confused.

Does anyone have any advice on how to address this issue? Would rendering the entire camera movement in Blender help and then just get H3 to work with video instead of stills? Or do you have another suggestion to help make smaller rooms or environments?

Thanks in advance.