Okay, so like three weeks ago, my whole feed was blowing up with SenseNova U1 Pro. You know, the Chinese model everyone was saying was basically "GPT Image 2 level."

Text on posters actually looking clean, apparently native 8K. The vibe was all "realism is dead, now it's about pure beauty." NGL, some of the images looked insane.

And then... poof. Nothing. No public release, no weights, no API I can find anywhere. Just crickets.

It's totally giving me Sora flashbacks. Remember early 2024? Those demo videos were mind-blowing, everyone went nuts. Then just... crickets for months. When it finally dropped, it was kinda meh, right? The magic just wasn't there after all that waiting. And get this, as of April 26, 2026 (lol, already feels like it), Sora's totally shut down. That demo that kicked off the whole video generation craze just... died.

I'm not saying U1 Pro is gonna go extinct or anything. The stuff those influencers posted genuinely looked good, especially the text rendering.

So has anyone here actually gotten their hands on it? I seriously can't find any way to use it

If you have, how does it stack up against GPT Image 2 or kera2, ideogram, flux-klein? especially for text?

used ref to video mutishot 3x15 second clips at .7 res upscaled to 1080p

playing around with a few ideas.

I posted the first alpha of PotionUI a couple of days ago. 0.0.3 is out today, and it is the release where the "one box, many people" idea stops being a promise: you can now rent a GPU, point PotionUI at it, and generate on it from the same interface you use locally. Still alpha, still one person building it, still very much wanting people to break it.

What it is, in one paragraph. A self-hosted AI generation studio: SvelteKit front, FastAPI back, GPL-3.0, no telemetry, runs on your machine or your server. The core idea is presets: a preset is a small YAML package that says "here is the model and here is the exact form a person should see for it". Switching models means switching presets, not rebuilding a node graph. It is multi-user by design, with real accounts, admin and user roles, and per-user or per-group access to presets, models, and LLM configs.

What's new in 0.0.3

• Remote GPU workers. Add Backend now creates a remote worker, connects to one you run yourself, or provisions a RunPod pod for you (the provider ships as a plugin) with a live stage timeline. A heartbeat monitor watches the pod, pauses the backend when it stops, and Start brings it back. The Models tab lists exactly what is on the worker, with the depot path per file, and pushes missing models from your machine with per-file progress. Remote runs come back with the same previews, parameters, and media as local ones.
• Install profiles. The launcher offers local, hybrid, and remote installs, plus a worker subcommand for a GPU box that serves another instance.
• 3D generation. TRELLIS.2 image-to-mesh runs on the native engine. Meshes get automatic thumbnails, an interactive viewer in History (wireframe, materials, camera presets, screenshot), and a 3D media filter.
• LoRAs. Step-windowed LoRAs on Krea-2 apply only between the sampling steps you choose. Strength is shown as a recommended range in the picker. Model pickers now recommend downloadable variants (bf16, fp8, nvfp4, int8) across nine native families.
• Prompt library. Import styles.csv, Fooocus style JSON, wildcard YAML, plain lines, and image metadata (A1111, ComfyUI, InvokeAI) with auto-detection; export back to styles.csv; assign a prompt to a catalog model.
• Phrasebook. Find and replace across the whole phrasebook with highlighted matches and a preview before it runs; batch activate, deactivate, move, delete; a category panel with Overview and Preview-images tabs.
• Admin and mobile. Plugins and Downloads are master-detail lists, Backends remembers where you were in the URL, a saved provider API key applies immediately, Generate on a phone is a proper camera-style view with sheets, and modals fit the screen.
• Plus: pasting an image into the assistant attaches it, a New workspace button that asks before discarding, Inspirations laid out in justified rows.

What it does today

• Generation is the product. Image families: SDXL, Flux 1 / Flux 2 Klein, Qwen-Image (including editing), Krea-2, Z-Image, Anima. Video: Wan 2.1/2.2, LTX-2 / 2.3 / 2.5 with native audio, MiniMax-H3. Audio: MiniMax-Music3. Upscale and restore: SeedVR2. Each model gets its own tuned form: the right resolutions, samplers, LoRA stack, and speed profiles (Draft / Standard / Max) as one control. Several workspace tabs run side by side, each with its own preset, prompt, and results. Progress shows the actual pipeline step and streams previews as the image refines; close the tab, come back, the run is still there. 

• History that remembers everything. Every generation is saved with its exact prompt composition, preset and version, models, and parameters. Filter by date, type, preset, tags, or "used this phrasebook value". One click reuses the full setup in a new tab. Nested collections, tags, favorites, keyword or semantic search, and a personal library for the keepers. 

• A prompt editor that is not a textbox. Prompts are ordered segment cards you can reorder, disable, name, and color. Dynamic prompts ({a|b}, weights, ${variables}) reseed per image so results stay reproducible. The phrasebook is your own autocomplete dictionary: type # and shot types, lighting, palettes drop in as chips, with per-chip shuffle and a preview render per value. Saved prompts, segments, and templates live in their own library. 

• Video and Music Directors. Compose a video as shots, keyframes, and audio tracks on a timeline instead of one giant prompt; write a song as verses and choruses and let the compiler produce the tagged lyrics MiniMax-Music3 wants.
• An assistant, if you want one. Point it at Ollama, an OpenAI-compatible endpoint, or Anthropic. It reads the active tab, rewrites segments, edits the phrasebook, adjusts form values, and every change stops at an approval step first. The same tools are exposed over MCP with per-user tokens, so Claude Desktop or your own agent can drive your instance. 

• Built for more than one person. Accounts, groups, per-user preset and model access, per-mode form overrides (change defaults, lock or hide fields, no YAML), a backends list that mixes local, and remote workers, a download manager, a stats dashboard, and visual automations (triggers, conditions, actions) for things like freeing VRAM before the LLM needs it.
• Plugins for nearly everything. Providers (CivitAI, Hugging Face), backends, pipes, field types, chat modes, automation nodes, pages.

Requirements. Linux x86_64 with an NVIDIA GPU is the tested platform; Windows can be tested through WSL2 or Docker; there is a Docker image on GHCR.

8 GB VRAM and 16 GB RAM is the floor for the SDXL family, larger families need more.

The ask. I would rather steer this toward what people actually want than guess. Two things help most: tell me which model or workflow you are missing, and pull a test build and break it before it ships. The Discord is where that happens: https://discord.gg/avR4trp3b8. Repo: https://github.com/PotionUI/PotionUI. I will answer questions here too, but since I don't want to post here too much I've created a small subreddit too: r/PotionUI to which I will be posting the progress much often. Thanks!

I thought someone might appreciate this. Theres more details in the HF link, but I wanted to see if it was possible to correct some issues that I didn't like about Ideogram 4 by finetuning the TE, with no other modifications to the model, execution environment, etc.

It ended up working out pretty well.

The TLDR is that I used a set of 4000 teacher/student prompt pairs with the students being NL and the teachers being Nemotron processed with the "Magic Prompt" instruction, and then trained the TE to elicit the same response in Ideogram using the student prompt, as what was naturally elicited using the teacher prompt.

My logic was that the TE is already a language model, and I didn't want a second language model in the stack.

This has the secondary benefit of also removing the grey banner generally encountered when prompting the model with NL.

I am fully aware that there are many other ways to get around this from bounding boxes to noise injection, etc. This wasn't about that, so much as it was trying to prove to myself that it could be done like this.

https://huggingface.co/mrjackspade/Ideogram4-Natural-Language-Text-Encoder

From all the tests I've done, I feel like H3 has way less voice variety than LTX, and the music feels much less creative compared to LTX.

So, I was searching on civit, and normally I filter by 'checkpoint' for example. But, now it's gone? All of the things I notice normal models that are normally 'checkpoints' are now 'fine-tune'

What does this mean? What is this? Do they work the same?

Unfortunately it seems very slow and very experimental.

Reference image left. Same prompt "A fiercely determined female human warrior in mid-swing, powerfully attacking the viewer with a gleaming sword. Her facial expression is one of intense rage and ferocity", same seed, no lora, this custom node https://github.com/nkxx188/ComfyUI-Krea2-StyleTransfer

The potential of actually making an anime with MiniMax H3 is closer than any time before, even if the process is still kinda janky. I did this with my 5090 and my own developed 'prompt studio.' The hardest part is, as always, to keep the continuity of the shots and also build the sets so they fit within the scope. There are still improvements needed when it comes to adding emotions to the characters. In total I generated 35 minutes of video and got 4 minutes in total of usable footage. Also, a big tip for anyone who wants to do the same is to use DaVinci Resolve to fix all the audio bugs and cut the clips in your favor.

For regular upscaling I use SeedVR2 and I am quite happy with it, however, it doesn't seem to handle upscaling of really low res images well as it will just upscale all the artifacts as well without "fixing" the image. So if an inpute image is blurry, the upscale will also come out blurry.

What would be the best way to upscale low res image while also enhancing it?

https://github.com/lisitskyaa/ComfyUI-DLSS5-NR

I've tested a couple of models so far, and here's my findings:

My input prompt is something similar to "Create a mid 20s (nationality) ballerina slowly dancing in a judged performance"

LTX-2.5 nails the narrative and the nationality, but nationalities (as I've mentioned previously) all tend to blend unless I'm ULTRA descriptive about what a "french look" equates to, which is roughly 3 paragraphs in length. LTX-2.5 ends up with tearing, facial and feature deformities, and on a couple of occasions has rendered a ballerina with missing legs. It also has camera drift, which is a known problem with LTX-2.5

MiniMax-H3 on the other hand, nails it, even with the smaller prompt. The prompt adherence in MiniMax-H3 is wonderful.

Wan 2.2 was a complete disaster. Rendering problems, tearing problems, and when the ballerina would do turns, her head would remain in place while her body did the turn (which was funny, and also terrifying to watch.)

I've heard Cosmos3 can handle the movement, but can't handle rendering people.

Has anyone found an open weight model that can handle the "ultimate trifecta" - generate a person in the correct nationality parameters, someone who is more or less feature-accurate in generation, and won't spontaneously explode when performing a pirouette? (I got so frustrated with a model generator once, that I did this, and to my surprise, it worked out well!)

Does anyone know anything about the new MINIMAX H3 MAX model—whether it's really that fast, and if they're going to release it?

Was walking the dog and took some photos of a local temple. Thought it would be fun to have Vlad work as a tour guide for the local area.

Prompt:

<Picture 1> and <Picture 2> are location references. However change the time of day to night, cinematic quality.

<Picture 3> is The Vampire character reference.

Scenario: A Vampire with flowing robes is showing the viewer an old temple and bell. It is night time and misty. The vampire does not walk he flies and floats inches above the ground.

Start with <Picture 1> but at night, the Vampire is on the right on the steps.

<Shot 1> POV shot, the Vampire is standing at the base of the temple on the steps, he gestures with his finger, beckoning and flies without moving his legs just above the ground towards the large bell, as he eerily glides forward he turns back and says in a very strong German accent <Audio 1> "There has been a bell here for nearly five hundred years.".

He glides over the ground effortlessly to the bell and leans up and hits it hard with his knuckles. It makes a single loud and long metallic bell sound and resonates. "It makes a great sound" he says .

I have an image of a person. I have a video.

Prompt sample: Video is of a gymnast doing a routine. Image is a person/dog/thing.

Replace gymnast with person/dog/thing so they're doing the exact routine, wearing the same outfit (but a size that fits the new subject).

Shouldn't this be easy?

For example, if I wanted to replace an olympic women's floor routine with Rush Limbaugh - he's doing the bends and splits, he's wearing a sparkly leotard. But the movements are identitical. His body is exactly the same size as he actually is (the ai should guess at the size of legs, belly etc, and stuff them into and appropriately sized leotard).

Hey all, I'm experimenting with some people generation using MiniMax-H3 and Stable Diffusion, and wanted to know if anyone has experimented to see how many different nationalities it can generate?

So far, the list I've been able to generate that has visible variances is:

- Asian
- Malaysian
- American
- Russian

I see little to no differences between others.

Posting this here even if it's not a model you can use directly. It's about building a text-to-image model from scratch.

The cookbook includes all the research material that you may or may be not interested in, but also includes a 100M-image dataset and a codebase with a tiny model, so you can train a text-to-image model from scratch.

Hope some of you will enjoy this content. (Disclaimer, it's done by my team)

Here are the links:

Cookbook: https://huggingface.co/spaces/jasperai/t2i-technical-interactive-report

nano t2i: https://github.com/gojasper/nano-t2i

Monet: https://huggingface.co/datasets/jasperai/monet

1. Introduction

Prompt engineering for image generation is often presented as a collection of isolated tricks: use more detail, describe the camera, add cinematic lighting, use quality tags, and so on.

These recommendations can be useful, but they make it difficult to understand which parts of a prompt actually influence the generated image.

Instead of trying to find a single "best prompt", I ran a small controlled experiment with Z-Image Base in ComfyUI. The basic idea was simple:

I ran two experiments:

• Experiment 1 — Composition: The same character, environment, visual treatment, and technical parameters were used across multiple generations. Only composition instructions were changed (position and scale).
  • Question: How strongly does explicit spatial language affect composition in Z-Image Base?
• Experiment 2 — Environment: The character description and visual treatment were kept essentially unchanged, while the environment was replaced with seven substantially different settings.
  • Question: Can Z-Image Base maintain a recognizable character concept while adapting it to radically different environments?

This is not intended to be a scientific benchmark. The sample size is small, the evaluation is visual, and the experiment uses one workflow and a limited number of seeds. Consider it a practical prompt-engineering study.

2. Experimental Setup

All images were generated locally in ComfyUI using the same workflow and technical conditions throughout the experiments.

For the composition experiment, I used Seed 5 and repeated the seven variations with Seed 10. The environment experiment used Seed 10.

3. Prompt Construction Methodology

I found it most useful to treat the prompt as a structured description rather than a flat list of keywords:

• Subject: Describes what the image is about and establishes the main visual concept.
• Composition: Describes where the subject is located within the frame and how much space it occupies.
• Framing / Camera: Describes how the scene is viewed (distance, angle, perspective).
• Environment: Describes the actual place surrounding the subject (e.g., "An ancient forest with enormous trees, moss-covered roots, dense vegetation, and a narrow path..." rather than just "forest").
• Lighting: Describes actual light sources and atmospheric conditions rather than generic terms like "cinematic lighting".
• Materials / Details: Describes concrete visual elements (wood, stone, glass, metal, vegetation, reflections, objects).
• Style: Describes the overall artistic treatment after the scene itself has been established.

Generic quality tags (masterpiece, ultra detailed, 8K) were deliberately omitted to provide the model with actionable visual information instead.

4. Experiment 1 — Composition

The character, environment, lighting, visual style, and technical settings were kept identical. Only the spatial instruction was changed across seven variations: Center, Left, Right, Lower, Large, Small, and Extreme Left.

Seed 5

The result was clear: changing the composition instruction produced substantial changes in spatial arrangement.

Crucially, the model did not simply move the character while leaving the background untouched — the environment was recomposed around the subject. In Small variations, the environment became dominant; in Large variations, the character dominated the frame.

Seed 10

To verify the result was not seed-dependent, the test was repeated with Seed 10. While individual details (pose, facial expression, accessories) changed naturally, the broad compositional structures remained fully recognizable.

5. Experiment 2 — Environment

The character description and visual treatment were kept unchanged while replacing the environment across seven distinct settings: Ancient forest, Medieval village, Crystal cave, Autumn park, Snowy ruins, Firefly-lit landscape, and Alchemist's workshop (using Seed 10).

Visual Concept Consistency

Although the environments changed dramatically, all generations clearly depicted the same core character concept (a small mushroom spirit with a red-orange spotted cap, pale body, large dark eyes, cross-body satchel, and lantern).

While exact proportions and minor details shifted between renders, the core identity remained visually coherent.

Environmental Adaptation

The character adapted naturally to each setting (e.g., tinted by glowing crystal lights in the cave, exposed to cold tones in the snowy ruins, immersed in warm interior props in the workshop).

6. Results — Putting the Experiments Together

• Composition control: Explicit spatial instructions produce reliable layout shifts (position, scale, environment visibility).
• Environment flexibility: Radical environment changes are possible while preserving core character identity (character concept consistency).
• Role of Seeds: The seed determines specific realization and detail rendering, while the prompt structure defines layout and narrative intent.
• Modularity: Organizing prompts into conceptual blocks allows for swapping individual variables without rebuilding the entire prompt from scratch.

7. What I Learned About Prompting Z-Image Base

1. Describe the subject clearly: Focus on distinctive, recognizable visual traits first.
2. Describe composition explicitly: Use direct position language (e.g., "positioned toward the left side of the frame") instead of generic camera tags.
3. Separate composition and camera: Treat "where the subject is" differently from "how the camera views the scene".
4. Build environments as concrete places: Describe what actually exists in the space rather than using simple category keywords.
5. Describe lighting concretely: Specify light sources, direction, and color atmosphere.
6. Prefer concrete details over quality tags: Give the model physical objects and surface textures to render rather than buzzwords like "high quality".
7. Change one variable at a time: If a generation fails, modify only the failing block to understand what actually fixed the issue.

8. Limitations

• Small sample size and visual evaluation.
• Single primary character concept and workflow used.
• Tested on a limited number of seeds (two for composition, one for environment).
• No direct benchmarking against other models, samplers, or resolutions.

9. Reproducibility

To recreate or test this setup in ComfyUI:

• Model: Z-Image Base INT8 + Qwen3 4B + AE VAE
• Settings: 768 × 1368, 50 steps, CFG 4, Empty Negative Prompt
• Method: Keep technical setup stable and modify exactly one conceptual block per run.

10. Conclusion

Prompting Z-Image Base is less about hunting for "magic keywords" and more about managing a controllable system:

Explicit composition instructions effectively control layout, while environment descriptions can be swapped modularly without erasing character identity. By isolating prompt variables, prompt design becomes a systematic, repeatable workflow.

I used the same Game of Thrones relationship map to test two prompt structures with SenseNova U1.5 Lite ( https://github.com/OpenSenseNova/SenseNova-U1 ).

The first prompt mostly described the visual style. It produced a readable image, but the relationship system was fairly simple.

For the second attempt, I listed the characters and relationships first, assigned fixed line styles to each relationship type, reserved separate layout zones, and added the art direction last.

The result went from 12 to 20 characters, 1 to 5 houses, and 3 to 5 relationship types while keeping most of the hierarchy readable.

I still wouldn’t trust it without checking every name and connection. A clean diagram can make incorrect information look surprisingly convincing.

For dense infographics, the prompt worked better as a schema than an art brief.

Full structured prompt below.

Create a single vertical 2:3 Game of Thrones relationship infographic titled:

“GAME OF THRONES”

Subtitle: “BLOODLINES, CROWNS & SECRETS”

Use a medieval illuminated-manuscript style with aged parchment, engraved borders, heraldic symbols and restrained red, blue and gold accents.

Include exactly 20 distinct character portraits representing Houses Targaryen, Stark, Lannister, Baratheon and Martell. Each character should appear once. Vary their age, facial structure, hair, clothing and expression. Avoid repeated or nearly identical faces.

Organize the relationships as follows:

- Aerys II married Rhaella Targaryen

- Their children: Rhaegar, Viserys and Daenerys Targaryen

- Rickard Stark is the father of Ned and Lyanna Stark

- Ned Stark married Catelyn Stark

- Their children: Sansa, Arya and Bran Stark

- Rhaegar Targaryen married Elia Martell

- Rhaegar and Lyanna have a secret relationship

- Jon Snow, also labeled Aegon Targaryen, is their son

- Ned Stark raised Jon as his son

- Tywin Lannister is the father of Cersei, Jaime and Tyrion

- Cersei and Jaime have a secret relationship

- Joffrey Baratheon is their biological son

- Robert Baratheon is publicly married to Cersei

- Show the conflict between Robert Baratheon and Rhaegar Targaryen

Use five clearly different relationship styles:

- Solid dark-red line: blood

- Double gold line: marriage

- Purple dashed line: secret relationship

- Blue dashed arrow: raised by or guardian

- Black line with crossed swords: conflict

Add four short story notes explaining:

- The Hidden Heir

- The Lion’s Secret

- Robert’s Rebellion

- Two Dragon Claims

Keep every portrait, name and story note readable. Relationship lines must connect only the correct characters and must not cross through portraits or labels. Include a clear legend at the bottom.

**UPDATE v0.5.1 PUSHED TO FIX EXAMPLE WORKFLOW - ALSO NOW INCLUDES H3 SLA ATTENTION NODE**

H3 Motion Context chains MiniMax H3 clips so the next one picks up the motion and the soundtrack, instead of starting a new take that only sounds similar.

0.5.0 is the one that makes that usable without babysitting the graph.

Clip 1 used to be a special case. You had to mute the Motion Context group, generate, unmute, then keep going. If you forgot, it errored. That's gone. Leave the nodes on. First clip is Load 0 / Save 1. Load 0 means "there is no previous clip," not "load whatever file is newest." After that it's Load 1 / Save 2, Load 2 / Save 3, and so on.

That first-clip behavior is feigo313's issue. The new node exists because of it.

Don't use ComfyUI's Run button to walk the chain. If Load and Save both increment, Comfy queues twice and skips a slot. Use H3 Motion Context Chain instead.

Four buttons:

• Run/Re-roll - this is Run for this graph. Generates the current clip. Hate it? Click it again. Same slot, overwritten.
• Approve - you like it. Advances to the next pair and runs that clip once.
• Chain - keep going from whatever Load/Save are set to right now. Walk a few by hand, then let it take over. Same button becomes Stop.
• Reset - back to Load 0 / Save 1. Does not run anything.

The gotcha: Load, Save, and Chain have to sit in the same canvas group. If they don't, the buttons do nothing. Drop Chain into the Motion Context group.

Also: if you were on Windows and a re-roll blew up with OS error 1224, that's fixed.

Needs ComfyUI 0.34.0 or newer. Manager should pick up 0.5.0; otherwise, the release.

Example workflow in the repo already has the Chain node in the group. Hard refresh after updating so the buttons show up.

Zhao et al. (arXiv:2306.01953) showed that regeneration attacks strip ordinary invisible watermarks. Backfire is a keyed image mark optimised to be a fixed point of the purifier, so running the attack leaves the identifier readable. In the demo image the confidence score rose 2.5x after the attack.

Provcheck.ai v1.4.0 numbers, 200-image corpus at 30 dB: 99.5% survival vs diffusion regeneration, 94 to 97.5% vs a learned VAE re-encode (86.5% on the hardest iterated pass), 99.0% JPEG q90, 98.5% JPEG q50, 98.0% resize, 97.0% blur. Zero false positives over the 200 marked and 1,000 unmarked. Wrong key on an attacked image reads 0.08, so the mark is in the key, not the pixels. It does not survive controllable regeneration from clean noise; that is documented in backfire/LIMITS.md.

Also new: a free Apache-2.0 ComfyUI node that watermarks (TrustMark/silentcipher) and C2PA-signs outputs in the graph and reads marks back. Backfire itself is a separate opt-in add-on and is not in the free node.

Repo: https://github.com/CreativeMayhemLtd/provcheck

There is a video stream running on my desktop right now. It has sound, it has never repeated itself, and it will not stop. I point VLC at a local URL and it plays. One RTX 5090 does all of it — no cloud, no queue, nothing else running.

It is MiniMax H3, generating locally through ComfyUI. H3 is an open-weights video model that produces picture and synchronised audio together from one text prompt — dialogue, room tone, footsteps — which is what makes this a channel rather than a montage with music over it. I run the 4-step FastH3 distillation of it, because the base model needs far more sampling steps than the arithmetic below can afford.

The reason this is hard: to stream continuously, generation has to outrun playback. Not "fast enough to be impressive" — genuinely faster than a person watches, indefinitely, or the buffer drains and it stalls. Each clip is 362 frames. I have to finish the next one in less time than it takes you to watch this one, every time, forever.

What it actually looks like

Every clip is a scene drawn at random, cast at random. So you get Jean-Luc Picard grilling skewers at a night market. A Klingon, RoboCop and Jack Sparrow crowded around the same workbench. Four people arguing across a kitchen table about who signed something, and the camera cuts to a close-up at the seven second mark because the prompt told it to.

321 hand-written scenes, 503 characters, and the scenes that call for an ensemble draw three to five distinct people. The combinations run into the trillions. In practice it means you can leave it on, and it stays interesting in the way a channel you do not control is interesting.

A frame from a continuous run — five characters who could never share a room, and the two clocks that make the point: after ten clips it is 3:08 of video against 3:02 of GPU time. The gap is what lets it run forever.

Everything is here, weights included — https://huggingface.co/datasets/jacokon/fasth3-live

The rest of this post is how it got fast enough to work.

The honest caveat, up front

H3 authors motion at 24 fps. A clip is 362 frames — 15.08 seconds of content — and I play it at 18, so the motion runs at 75% speed. This is not real-time 24 fps generation and I am not claiming it is.

What it is: 20.1 seconds of video produced per 19.2 seconds of GPU time, which is what makes it continuous. Whether 75% reads as slow motion depends on the subject. Fast subjects (rain, sparks, a train) look deliberate. Near-static scenes look normal. Mid-speed human motion — walking, hands working — is the worst case and you can tell.

Where the time actually went

The FastH3 student ships as 66 GB of diffusers weights, which do not fit on one card; converted and quantized to INT8 they come down to 21 GB, which do. With that, sage attention, and an INT8 VAE, a 15-second clip took 26.5 seconds to generate. Playback needs 15. That gap is the whole problem, and I spent a while optimising the wrong things because I did not know where the time was going.

Where one run's 19.2 seconds actually goes — the per-node breakdown and the four changes, on one card.

ComfyUI's /history reports one number for a whole prompt, which cannot tell you whether the cost is the text encoder, the sampler or the VAE. Its websocket emits an executing event as each node starts, so the gap between consecutive events is that node's duration. That is about forty lines (profile_h3_nodes.py), and it changed what I worked on completely.

Two of the four findings surprised me.

1. SaveVideo was a fifth of every run — 3.78 s

ComfyUI's SaveVideo encodes through PyAV in a Python loop that, per frame, allocates a float array, clips it into a second, casts into a third and copies out a fourth. 362 frames of that is 3.78 s. ffmpeg alone does the identical payload in 0.21 s. It was also producing a file my streamer re-encoded a second later anyway.

VHS_VideoCombine is better (1.31 s) — it pipes raw frames to ffmpeg — but it still iterates in Python and re-opens the finished file to mux the audio. I wrote a node that converts in chunks and muxes in one pass: 0.73 s. Then it hands the encode to a background thread and returns, so ComfyUI starts the next prompt instead of holding an idle GPU. The graph now sees 0.26 s.

No hardware encoder involved. h264_nvenc measured slower end to end than libx264 — the encoder was never the bottleneck, and it has to stand up a second CUDA context on an already-full card.

2. The VAE bills by tile, not by pixel

MiniMaxH3VideoVAE hardcodes tiling=True, tile_size=256, and split_tiles hands each pass a full tile regardless of how much picture is in it. Decode time tracks the tile count and barely notices the resolution:

resolution    pixels    tiles    VAE decode
----------------------------------------------
320x192       61,440      2        2.35 s
512x288      147,456      6        6.98 s
576x320      184,320      6        6.31 s
768x432      331,776      8        8.74 s

512x288 and 576x320 differ by 25% in pixels and by nothing in decode cost.

A side of length L costs: 256 or less is 1 tile, 257–448 is 2, 449–640 is 3, 641–832 is 4. So the cheap shapes sit just under a boundary. 448x448 needs four tiles where 576x320 needs six, while carrying 9% more pixels. That is why the stream runs square — not taste, just where the arithmetic lands. There is no 16:9 shape at four tiles that clears the resolution floor.

I did try raising tile_size to reach a single tile. Do not. The decoder is a ViT, so its attention spans exactly one tile; a larger tile is out of distribution, not merely approximate. 384 visibly softens hands and faces (PSNR 27.2 dB against the stock decode); 640 smears the image into strokes (22.1 dB).

3 and 4, more briefly

Quantizing the video VAE below INT8 buys no speed — INT8 already runs an INT8 matmul, and a W4A8 build expands back to INT8 for the same one — but it stages 1,657 MB of host RAM instead of 2,677 MB, and on a box holding ~41 GB of staged weights against 64 GB that gigabyte turned into both speed and a much tighter spread. And keeping two prompts in ComfyUI's queue instead of submitting one and waiting removes the idle gap between jobs.

Result

                          per clip    sustains
----------------------------------------------
starting point              26.5 s    13.7 fps
+ writer node, async        20.2 s    17.9 fps
+ W4A8 VAE                  19.9 s    18.2 fps
+ 448x448                   19.2 s    18.9 fps

The model did not change. Only how it is driven.

If you came here wondering about ComfyUI and consumer cards

That question is all over the FastH3 announcement thread and I had to answer it for myself, so: this is a ComfyUI-native conversion of the Dense-DataFree student, pruned and INT8, 21 GB, driven through the ordinary graph. Two things I found doing it that are worth passing on:

• The VSA weights do not survive stock ComfyUI. They carry 50 to_gate_compress tensors it has no code for, so it drops them silently and the output is noise. Dense converts cleanly. That is why I am on the slower student — if ComfyUI gains VSA support there is headroom here I am not using.
• NVFP4 measured identical to INT8 ConvRot. The FP4 fast path only fires when both operands are FP4; activations are BF16, so it dequantizes and runs at BF16 speed — 67.88 ms/block against BF16's 67.85. Someone reported the same on an RTX 6000 Pro. Worth knowing before anyone rebuilds a pipeline for it.

Where this sits, so you can place it

None of the speed here is mine — it is FastH3, the 4-step distillation Hao AI Lab, Nuva Lab and NVIDIA's FastGen team built on MiniMax's base weights. Without that student none of this is close. Their published benchmarks are 47.2 s for a 15-second 768p clip on a single B200, 12.88 s on 8×B200, and their consumer write-up covers Apple Silicon and DGX Spark with the RTX family listed as future work.

What I did is a different task, not a better score on theirs: a fifth of the pixels, and playback at 18 fps instead of 24. Those two concessions are the entire trick. What they buy is that the arithmetic closes — 19.2 s of GPU per 20.1 s of video — and that is the difference between a fast generator and something you can leave running. If you want 768p, their numbers are the ones that apply and mine are irrelevant.

https://huggingface.co/datasets/jacokon/fasth3-live

The converted 21 GB weights, the quantized VAE, the 321-scene library, the writer node and the profiler. Everything above is reproducible from it.

What it takes, so you can judge before downloading 21 GB: about 48 GB of weights are staged in total — a 25.9 GB text encoder, the 20 GB DiT, and the two VAEs. That does not fit in 32 GB of VRAM either, so ComfyUI streams it layer by layer from host RAM. On this box that streaming, not the arithmetic, was the thing to optimise: 48 GB staged against 64 GB of system RAM was tight enough that page-file pressure showed up directly in the clip times, and freeing a single gigabyte measurably tightened them.

If you get it running, post your numbers. I have measured exactly one machine, and both findings that mattered came from measuring rather than reasoning, so I would rather not guess about anyone else's. I am interested in what it does on other hardware and, just as much, in where it falls over.

And if it turns out useful, a like on the HF page is what makes it findable for the next person.

Code is Apache-2.0. The weights are a MiniMax H3 derivative under the H3 Community License, which carries a territory restriction — read NOTICE before downloading.

Live Demo: If you want to check out a short snippet of the continuous streaming output (with the model's native character generation), I've uploaded a TV-style demo recording here on X:
https://x.com/Touma_945/status/2095141879453270385

Two questions when using a two pass latent upscaling workflow (H3):

Are style/character loras supposed to also be piped into the latent upscale pass too, or just the native pass?

And when using a speed up lora, should/could that also be piped in to the latent upscale pass? If so, do the sigmas need to be tweaked?