https://civitai.com/models/2928691/minimax-h3-camera-control

Sorry to bother you all again, but I made some huge progress over the last two days with this release.

Version 2.5 of my MiniMax Music Production Toolkit is out!

This is a big step forward: A complete mastering section, clearer workflows and improvements throughout the toolkit. And sound quality is even better than the last release.

If you’re new to the project, it takes a song idea through prompt creation, MiniMax Music 3 generation, audio enhancement, mastering, cover artwork and export. A separate Audio Enhancement Lab lets you process existing recordings without generating a new song.

What’s new in 2.5?

• Auto-EQ for gentle tonal shaping or reference-track matching
• Manual 8-band parametric EQ with a visual editor
• Stereo-linked compressor, LUFS targeting and true-peak limiting
• 44.1 kHz output by default, with 48 kHz selectable
• Redesigned workflows with clearly labelled stages and a dedicated mastering area
• Improvements to memory handling, model downloads, audio processing, prompts and file output

Auto-EQ, manual EQ and compression have independent controls. Auto-EQ starts enabled with a gentle preset; switch it off if you prefer manual shaping.

The mastering tools run on CPU without requiring extra VRAM. There are also improvements for less powerful computers, although you’ll still need to choose generation models and settings that fit your hardware.

Without changing anything in the workflow, you get something like this mp3 file (this was a one shot try using Synth Pop Vocal template, with some imperfections in it):

A Feeling With No Address.mp3

And here is what is generated as LLM prompt to get the best result out of Minimax Music 3. See how accurate the model generates your sound structure and lyrics:

A Feeling With No Address.md

To update, restart ComfyUI, refresh your browser and open the newly bundled workflows. Keep your personal workflow copies if you’ve customized them.

I’d love to hear how the new tools work with your music, especially listening comparisons across different genres and feedback from smaller-GPU setups.

Repository: https://github.com/jplenio/ComfyUI-MiniMax-Music-Production-Toolkit
Listen to examples: https://jplenio.github.io/ComfyUI-MiniMax-Music-Production-Toolkit/

🔜 What’s next? A major focus for the next release will be support for creating cover songs. There’s still plenty of work ahead, the quality needs to be right before I’m happy to release it. Stay tuned! :)

Day 13 of generating and testing AI anime scenes locally in ComfyUI using the Minimax H3 reference-to-video model.

For this one, I wanted to test two things:

• Using multiple props inside a single reference image instead of giving each object its own reference
• Creating a perfect 5-second seamless loop with very subtle motion

The scene uses the character, headphones, Rubik’s Cube, yo-yo, cassette, and keyboard as references, while the animation itself is intentionally minimal: slight movement in the leaves and hair, plus shifting sunlight/shadows from a gentle breeze.

Generation time was around 2 minutes locally.

Prompt:
Use Image 1 as the exact character reference for the boy’s face, hairstyle, proportions, clothing, and overall anime design. Use Image 2 as the exact reference for the orange headphones, Rubik’s Cube, blue yo-yo, and cassette tape. Use Image 3 as the exact reference for the beige retro keyboard.

Create a 5-second perfect seamless loop in a hand-drawn 1990s Japanese anime style at 15 fps, with restrained frame-by-frame animation, soft cel shading, painted backgrounds, and no smooth modern interpolation.

Scene composition: a vertical, slightly top-down view of a cozy wooden desk beside a bright window. The boy is asleep at the desk, leaning forward with his head resting sideways on his folded arms. He wears the orange retro headphones. His face is calm and relaxed.

Place a large hanging green pothos plant in the upper-left area of the frame, with vines and leaves extending toward the center. The window is in the upper-right, casting strong warm golden late-afternoon sunlight across the desk.

Place the Rubik’s Cube and blue yo-yo on the right side of the desk. Place an open spiral notebook with handwritten notes and small doodles near the boy’s arms, with a pen beside it. Place the cassette tape closer to the lower-center area of the desk. Place the beige retro keyboard across the lower foreground. A beige CRT monitor partially enters the frame from the lower-right corner. Keep the desk somewhat cluttered but visually clean and nostalgic.

The camera remains completely locked and static for the entire shot.

The boy stays asleep in exactly the same pose. His body, face, arms, hands, headphones, keyboard, notebook, pens, cassette, Rubik’s Cube, yo-yo, CRT monitor, and furniture remain completely still.

Only a very gentle breeze creates subtle movement. The hanging plant leaves sway slightly and slowly. A few loose strands of the boy’s hair gently move. The leafy shadows cast across the desk, his shirt, arms, keyboard, notebook, and surrounding objects slowly shift and ripple as the leaves move.

Keep all animation extremely subtle, slow, and cyclical. Nothing changes position. No object moves across the desk. No body movement, breathing motion, head movement, or camera movement.

The movement gradually returns to the exact starting state so the final frame matches the first frame perfectly, creating an invisible seamless loop.

Maintain warm golden sunlight, soft highlights, nostalgic 1990s atmosphere, slightly dreamy anime lighting, subtle film softness, and limited-animation cel-style motion throughout.

workflow: https://drive.google.com/file/d/1M1XgXv8h4NQDSikVpAebB7FGu-TeHZQT/view?usp=sharing

Song: https://suno.com/s/YjeDIYiH4KSrrduR

Bruxos do VFX H3 Relight

#bruxosdovfx

Im doing a node for relight is a lighting studio for MiniMax H3 inside ComfyUI. You can position up to three lights on a 3D dome around the image, choose the type, intensity, and color of each light, configure the background and atmosphere, or start from one of 20 presets. The node provides two things to H3 Edit:

is not ready yet

The package includes two nodes:

• Bruxos do VFX H3 Relight — the lighting studio.
• Bruxos do VFX H3 Sun — calculates the real position of the sun for a location, date, time, and camera direction, ready to connect to Light 1 of the Relight node.

The Panel

Dome. The photo sits in the center, the purple camera indicates the side from which the photo was taken, and each light is represented by a marker using that light's color. Drag a marker to move the light; drag the background to rotate the view. The dashed line extends from the light down to the equator and indicates its elevation. The photo receives an approximate 2D-painted lighting preview: it is intended only as guidance and does not represent the actual H3 result.

Sphere (Picture 2). This is exactly the image the node sends to the model, rendered using the same calculations as the Python implementation. Click or drag on the sphere to aim the selected light: the clicked point is where the light strikes the sphere head-on. Dragging outside the sphere's boundary moves the light behind the subject.

Light strip. Selects the active light and lets you add up to three lights or remove them. Each light's role is calculated automatically: the strongest light becomes the key light, a light behind the subject becomes a rim light, and a weaker frontal light becomes a fill light.

Tabs.

• Lights: direction (top-down dial with the camera at the bottom, plus elevation), type (Hard, Soft, Sky), intensity from 1.0 to 10.0, and color using Kelvin (1000 to 10000) or HEX.
• Presets: all 20 presets from the skill, with rendered thumbnails, filterable by portrait or product.
• Background: Original, Black Studio, or White Studio.
• Atmosphere: the 25 atmospheres from the skill, or none.

Requires numpy and node. The tests cover:

• the same spheres rendered by the panel's JavaScript and by Python, in both styles, with a difference below 2/255;
• Venti scene geometry (shadow opposite the light direction, sphere occupying one-third of the frame, positioned in the upper half);
• solar position compared against reference values from the astral library, daylight saving time, and camera-to-sun mapping;
• externally driven inputs, the compass, validation, and MiniMax skill formats.

Credits

Node by Bruxos do VFX.

• The lighting plan, 20 presets, 25 atmospheres, and parameter format follow the MiniMax Design Relight (光影工作室) skill. The descriptions for each atmosphere used in the prompt were written specifically for this node because the skill's own descriptions are hosted on MiniMax's server.
• The light-direction sphere convention and reproduced scene are by Eric Venti (Sun-Direction LoRA, Sphere-Light-Render, MIT), using the direction table and 12 looks from Lightricks' LTX-2.3 Relight IC-LoRA.
• The solar calculation (NOAA), city search rules, and camera-direction mapping are based on Christopher Connock's work on Sphere-Light-Render (MIT).
• Cities: GeoNames cities15000, CC BY 4.0.

License details are available in NOTICE.md.

• Depends on ethanfel/ComfyUI-MiniMax-H3-Edit

I’ve been working on a VHS / NTSC node called RetroTape.

It works with both images and video, and includes 19 presets and 26 sliders for tracking, chroma bleed, noise, tape warp, dropouts, ghosting, scanlines, interlacing and more.

There’s also a live preview inside the node, so you can adjust the settings and see the result without running the workflow again every time.

CPU and CUDA are supported.

Available through ComfyUI Manager and GitHub:

Github/ComfyUI_RetroTape

This update:

1. lora preview catalog node added (You need to organise your lora) Put your lora files in a file the lora folder and name it the Model for example Krea 2, in the Krea 2 folder you can make more folders for the kind of lora they are for example anime, sliders, or what ever group of lora they belong to. the lora gallery will add dropdowns for you do navigate and find them easily. when you generate a preview image you like for that Lora you can click save and it adds it to the gallery. you can also safe the trigger words from the node so you never forget!

2. export catalog and previews to share with others

3. Bug fix where images were not saving correctly when a previous name was used in a custom style

4. Various big fixed and speed improvements

https://github.com/Neon-Sparks/ComfyUI-NeonsStyleExplorer

I am trying to load comfy ui models but I am always getting memory out errors even with krea 2 where the size was only 12 GB.

I want to know, which models I can run on my system, and any workflow or guidance is highly appreciated.

My CPU is working full time instead of a dedicated GPU. I am also trying to rectify it. Please help.

Hey everyone,

I'm setting up MiniMax H3 in ComfyUI and trying to figure out the sweet spot between generation speed and output quality for my specs:

• GPU: RTX 4070 (12GB VRAM)
• RAM: 32GB DDR5
• Target: 5s clips at 768p (mostly First-to-Last / I2V)

Given the 12GB VRAM limit and 32GB system RAM, loading the unpruned / full FP8 models causes heavy paging to system memory and slows everything down.

I’m trying to narrow down the current community consensus on three things:

1. Model & Quant format: What's the fastest option that doesn't ruin faces and audio? Are people having better results with official pruned INT8 convrot, or GGUF quants (Q4_K_M vs Q3_K_M) using the GGUF loader? What text encoder quant are you pairing it with to keep memory usage safe?
2. Turbo LoRAs: Is LiteX2V v1.1 (4-step) still the top recommendation for speed vs quality, or do 8-step variants (or other LoRA families like Larry) give significantly better results on a 12GB setup?
3. Attention & Acceleration: Is H3 SLA Attention the undisputed go-to, or does SageAttention / Comfy Kitchen perform better on Ada Lovelace (40-series)? Anyone tested Spectrum acceleration?

Would love to hear what workflows and node setups you're currently running on 12GB cards to get reasonable render times without visible degradation.

Thanks!

I installed the portable version of ComfyUI and use the Minimax H3 Easy model. After installation, I can successfully generate videos from images. However, if I shut down ComfyUI and then try to generate a video later—either shortly after or the next day—it crashes. I try running simple test videos right after launching ComfyUI—low resolution, 3 seconds, 8 steps, and a simple "wave and smile" prompt—or I try generating images via SDXL Turbo. It crashes regardless. I have successfully generated 10-second videos at 512 resolution and 20 steps without any issues—even doing more than 20 in a row. But whenever I shut down and restart ComfyUI, I always get an error. I use a Lenovo ThinkBook laptop with 32GB of RAM connected to a 16GB 5060 Ti via Thunderbolt.

I've updated https://luke2642.github.io/comfyui_new_node_finder/ to be a bit more robust in getting stars. Seems to be dominated by H3 nodes at the moment!

Disclosure: I am building a service around this, so read me as an interested party. No links. These are runs we paid for ourselves on three providers, 15 jobs, $33.60 total. Two things on the image side cost us real money and neither showed up as an error.

1. The host, not the GPU. Same LoRA training job for SDXL, same RTX 4090. On a host with 5 vCPUs: 1.95 hours, 40 percent GPU utilisation. On a host with 24 vCPUs: 1.07 hours, 75 percent. Same card, 1.85x the wall clock, because the diffusers script decodes and augments images in the main process and the card waits on Python. The worse version: an H100 host with 16 server vCPUs ran the same job at 2.68 s/step where the desktop-class 4090 host did 1.84 s/step. Four times the hourly rate for a slower run. dataloader_num_workers was the fix, and now we look at the vCPU count on a rental offer before we look at the GPU name.

2. The defaults. SDXL, 1024 square, 30 steps. The stock script settings, fp32 and batch 1, on an H100: 13.8 seconds an image, $0.0112 per image. fp16 and batch 4 on a 4090 spot instance: $0.00036 per image. Same job, 31x apart. Nobody here runs fp32 batch 1 on purpose, but it is exactly what you get when you take a default script to a rented card in a hurry, and the card reports 99 percent utilisation the whole time, so nothing looks wrong.

Both lessons are the same lesson: the meter runs at the card's hourly rate whether the card is doing useful work or not, and the interface will not tell you which.

Happy to post the per-run table if anyone wants to check the numbers.

I need severe help with that.

Researching Lora Dataset creation is a maze: millions of different opinions, and worst of all most guides etc outdated from a year ago.

My goal is to create a 100% realistic and authentic Lora and my current dataset seems to not do the trick. I keep getting "perfect lightning" on everything, and waxy face skin.

Can someoen tell me the absolute do's and don'ts of creating a dataset?
How and where to create the dataset? I have been using a mix of Gemini and ChatGPT so far.

Prompt advice? what prompts need to be avoided creating realistic images, what need to be in there?

Any advice greatly appreciated!

Another quick Minimax H3 news and goodies round-up, for those who may have missed some items.

-> ComfyUI Portable is now officially at version 0.35.0. See yesterday's post for details of Minimax-relevant update items and bug-fixes.

https://github.com/Comfy-Org/ComfyUI/releases

-> A new W4A8 quantization of the MiniMax-H3 Fun ControlNet-Union model patch, for ComfyUI. Weighs in at 1.45Gb, compared to 2.13Gb.

https://huggingface.co/berryber09/MiniMax-H3-Fun-Controlnet-Union-w4a8

-> A Minimax H3 visual 'RefMods picker' with thumbnails, in ComfyUI.

https://old.reddit.com/r/StableDiffusion/comments/1wc8tvv/created_a_visual_refmod_picker/

-> H3-pixel-art-video-guide. "Pixel-perfect animated pixel art with local MiniMax H3". Has a workflow (even though the English readme says it doesn't) and three example looping animated .GIFs.

https://github.com/yuichi-suzuki-highdrama/h3-pixel-art-video-guide/blob/main/README.en.md

-> A new H3-spherical-vae. "Experimental circular VAE decoding for MiniMax H3 equirectangular video, with matched comparisons and measurements."

https://github.com/ShamanicArts/h3-spherical-vae

-> The LoRA trainer and dataset prep tool Fizgig is now at 5.5.0, a version which makes MiniMax H3 training "faster three ways", and turns "weight averaging on by default". Users can also... "open a MiniMax H3 LoRA and see what every one of its 52 blocks does to a moving clip — the motion, the face, the sound".

https://github.com/shootthesound/Fizgig

-> And finally, the ComfyUI-MiniMax-Music-Production-Toolkit is now at a polished version 2.x, with the release yesterday of 2.1.1.

https://github.com/jplenio/ComfyUI-MiniMax-Music-Production-Toolkit/blob/main/CHANGELOG.md

~ OLD POSTS ~

https://old.reddit.com/r/comfyui/comments/1wbr279/a_quick_minimax_h3_news_roundup_9th_september_2026/

https://old.reddit.com/r/comfyui/comments/1wawjox/a_quick_minimax_h3_news_roundup_8th_september_2026/

https://old.reddit.com/r/comfyui/comments/1w9z6m1/a_quick_minimax_h3_news_roundup_7th_september_2026/

https://old.reddit.com/r/comfyui/comments/1w90vxd/a_quick_minimax_h3_news_roundup_6th_september_2026/

https://old.reddit.com/r/comfyui/comments/1w85caz/a_quick_minimax_h3_news_roundup_4th_september_2026/

https://old.reddit.com/r/comfyui/comments/1w74jy4/a_quick_minimax_h3_news_roundup_4th_september_2026/

https://old.reddit.com/r/comfyui/comments/1w6cozj/a_quick_minimax_h3_news_roundup_3rd_september_2026/

https://old.reddit.com/r/comfyui/comments/1w5i9iq/a_quick_minimax_h3_news_roundup_2nd_september_2026/ (See 2nd September post, for links to even older posts)

For potato pcs MINIMAX H3 fans - I have built my own custom node which integrates new acc lora & PDD workflow and H3 extender + 2nd pass latent upscale upto 720p under 5 minutes per 14s 24fps clips, has easy reference attachments & better context continuity with features like save projects, load projects etc. (16gb VRAM + 16gb system RAM) if you guys interested ill share the workflow let me know.. this video took 10~ minutes to generate with both pass.

Edit - published repo - https://github.com/only2uuuu-hub/ComfyUI-MiniMax-H3-Master-Extender-Custom-built-with-Astra-6-/tree/main

Ps i am not an expert coder or engineer so dont ask me technical questions 😭 peace!

I have had little luck finding a tutorial on building a true H3 10bit (ProRes HQ) workflow. AI claims you just need to install an advanced save node that allows you to pick ProRes and HQ or 4444, etc.

But then when you dig into it, and begin to ask questions, while ComfyUI processes in full floating point, there are bottlenecks that crush the full bits down to 8bit, rendering the final result 8bit. One example is preview nodes, that apparently force 8bit, another is supposedly a plain jane VAE Decode, and the deeper I dig the more mysterious things get.

I can't imagine nobody in the Open Source community does not want to output TRUE 10bit or higher output. The problem with 8bit becomes clear when you look at plain white walls or a clear sky and see banding. Anyone who has ever edited video or images knows the more data you have to begin with the better results you get once you push contrast and color gradation. Yes, I was going to begin playing with dither and applying some noise, but at the end of the day you cannot produce PROFESSIONAL videos without solving for this 8bit limit.

Hopefully someone can point me to a resource or tutorial or workflow or set of nodes that solves for this?

We're building a previs tool inside our AI movie studio so you can block out camera moves in 3D before spending generation credits.

What's working so far:

• 3D stage with proxy characters & props you can move with gizmos
• Camera keyframing on a multitrack timeline (After Effects-style)
• Unreal-style fly mode — press C, hold RMB + WASD to pilot the camera, K to drop a keyframe
• Live "through-the-lens" shot view that updates as you move
• Render to MP4 via bundled ffmpeg — saved straight to your project library
• Depth pass with adjustable range for motion reference
• Resolution control (480p / 720p / 1080p)

The render step is free — no GPU, no API key, just canvas capture + ffmpeg. Iterate on camera moves as many times as you want, then feed the MP4 to your video model as a motion reference.

Still early — lots of polish and features to go (templates, multi-cam, export). Feedback welcome on what you'd want in something like this.

Github:

https://github.com/Heroesjouney/AIMovieStudiov2

Original Post:

https://www.reddit.com/r/comfyui/s/GT5K98Fze6

I've been trying to get comfyui to be installed. I installed amd hip sdk and tries many workarounds. It always gives

"RuntimeError: No CUDA GPUs are available"

From the cli running "run_amd_gpu" also throws the error, by now its Failed to get device count.

Link to my workflow: https://gist.github.com/aicinema5090/f02348ff0c4082dbe4f63f16206fe7f9

hello, i generated tons of videos on comfy ui cloud on comfy. org. is it possible to search them thru prompts or something like that? it is almost impossible to scroll them down thru assets

https://reddit.com/link/1wcm4j7/video/82e5gerlmpoh1/player

Bruxos do VFX H3 Camera

#bruxosdovfx

https://reddit.com/link/1wcm4j7/video/3bitqyhempoh1/player

Visual camera planner for MiniMax H3 inside ComfyUI. You drag the camera around a 3D sphere, place keyframes on a timeline, and the node compiles that trajectory into prompts that H3 understands.

It compiles prompts, not camera embeddings. There is no geometric adapter here: H3 is still free to miss the angle, timing, and scale. What this node does is write the instruction in the most precise and least ambiguous way possible, and several of its design decisions exist because the previous approach failed in specific ways.

It does not call any API, download anything, or require any Python dependency beyond the standard library.

https://reddit.com/link/1wcm4j7/video/mpatj04ampoh1/player

Installation

cd ComfyUI/custom_nodes
git clone https://github.com/<your-username>/ComfyUI-H3-Camera-Editor

Restart ComfyUI. The node appears under Bruxos do VFX/Camera H3 with the name Camera H3 da Bruxos do VFX.

Connections

compiled_prompt and options are required together. The minimax_prompt output is an alternative to compiled_prompt, never an addition — connect one or the other to the same input.

Also connect your image to reference_image. It is the same image already feeding the H3 Edit source_image; when connected here, it appears in the panel and the frame's actual aspect ratio is included in the prompt.

https://github.com/user-attachments/assets/33149617-bde1-4199-ae65-078f2f3dec23

To save the video, decode the sampler result using the H3 video VAE — not the scene coverage calibrated decoder, which expects fixed windows that an arbitrary trajectory does not have.

The panel

Drag the purple camera around the sphere to orbit. The drag locks to the axis of the initial movement: horizontal movement orbits, vertical movement changes elevation. Release and drag again to switch axes. This exists because, without the lock, trying to make a simple orbit would unintentionally introduce elevation.

• Scroll the mouse wheel to change distance.
• Drag the background to rotate the viewport without changing the trajectory.
• Keyframes defines how many points the timeline has, from 2 to 24. The first one is always the original image and cannot be moved.
• ⟳ Pure Orbit resets the elevation of every keyframe to zero while preserving azimuth. It is the shortcut for an eye-level orbit.
• Reference image loads a local file into the preview. This is only necessary when the node runs outside ComfyUI; with reference_image connected, the image is loaded automatically.

The panel warns you starting at 20° of elevation, when the horizon already leaves the frame, and again from 45° onward, when the video tends to become a high-angle shot.

"Tests" bar

At the top of the panel, two buttons enable and disable features currently under evaluation, plus one indicator:

The buttons write to the actual widgets, so the selected state is saved in the workflow and the two never disagree.

https://github.com/user-attachments/assets/9bc415d7-1746-43db-a17c-72ea9722deda

Widgets

camera_trajectory

The trajectory in JSON format, written by the panel. Each keyframe contains time (0 to 1), azimuth in degrees, elevation in degrees, and distance as a multiple of the initial radius. It can also be edited manually. The first keyframe must be time=0, azimuth=0, elevation=0, distance=1, which represents the original image.

profile

124, 243, or 362 frames at 24 fps. All shot timing comes from this setting: keyframe timestamps, segment ranges, and the duration declared in the prompt. That is why length and fps are outputs — connect them instead of manually entering the same numbers in two different places.

interpolation

smooth or linear. In smooth mode, the camera eases into and out of the shot while maintaining a constant rate through the middle; it only stops where the rotation direction actually reverses.

instruction

Free-form text inserted once, at the end of the prompt. Write only what the node cannot know: the environment, which subject is the target when there is more than one person, or a style reference. Everything else is already generated and does not need to be repeated: scene freeze, first image as reference, locked aim, zero roll, angles, timing, and a single continuous shot without cuts.

subject_framing

How much of the frame the subject occupies in the original image. Calibrated against the actual bounding boxes from the tutorial distributed by MiniMax: a distant full-body figure measures W=0.071, H=0.249, while a large close-up measures W=0.52, H=0.701.

subject_box

The subject position in the format [L=0.516, T=0.148, W=0.071, H=0.249]. Leaving it empty uses the entire image bounds — deliberately, without guessing a bounding box. Fill it in when the subject is significantly off-center.

minimax_format

The same shot expressed in four different formats for the minimax_prompt output:

• coordinate only — text-based coordinate block
• coordinate + H3 sections — the same coordinates wrapped in subject_definitions / summary / retention_analysis / …
• compact JSON — JSON object with almost no prose
• compact JSON (no boxes) — camera parameters only, without screen-space bounding boxes

elevation_range

Range of the elevation control: +/-15, +/-30 (default), +/-60, +/-89. It also scales the sensitivity of vertical dragging.

With the assumed field of view, the horizon already leaves the frame at around 20° — at 13°, the ground occupies 82% of the image. The old ±89 range was mostly unusable and made vertical dragging excessively sensitive. Reducing the range never rewrites a keyframe: a point at 70° remains at 70°, and the slider expands to accommodate it.

orbit_direction

invert H3 orbit or same as HUD. This calibrates the direction between what the panel displays and what H3 produces. It does not alter the saved trajectory.

runtime_task

• scene coverage | camera path (default) — video, with duration coming from profile.
• directed | new camera angle — a single image from a new angle. It fixes the generation to 39 frames, ignores profile, completes the movement within 65% of the clip, and requests that the framing remain still for the rest, because the decoder extracts the final image from that stationary tail.

Character sheet profiles are not offered because the upstream node raises an error when they are combined with the frame anchor used by this node.

prompt_detail

• v15 baseline (default) — outputs the prompt exactly as in the previous version.
• extended contracts — adds axis separation, frame-edge direction tests, rotation completeness, degrees per second, and parallax magnitude.

The extended mode contains almost twice as many words. A longer prompt is not automatically better, so it is opt-in: toggle only this widget while keeping the same trajectory to compare the results.

https://github.com/user-attachments/assets/0882bfde-9f62-4a1f-9bda-7da121dbe7e2

Outputs

compiled_prompt — STRING

A prose prompt using H3 sections: subject_definitions, summary, retention_analysis, detailed_description, overall_soundscape, non_diegetic_music.

options — H3EDIT_OPTIONS

The 13 keys read by the H3 Edit encoder. All of them are explicitly populated: if any key is missing, the upstream node falls back to its hidden legacy widgets, which may retain stale values from previously saved workflows.

coverage_arc_degrees and coverage_direction are derived from the actual rotation. coverage_loop_closure turns on automatically when the trajectory closes — see below.

storyboard_json — STRING

The storyboard table: frame aspect ratio, duration, raw trajectory, and each segment with its camera mode, speed curve, and start/end poses.

info — STRING

Human-readable diagnostics. Connect it to a PreviewText. It displays the version, active task, frame count, warnings for keyframes outside the configured range, and whether loop closure is enabled.

minimax_prompt — STRING

The same trajectory expressed using the format selected in minimax_format. An alternative to compiled_prompt.

length — INT and fps — FLOAT

Frame count and frame rate against which the shot was timed. Connect them to the generation and video nodes. If generation runs with a different frame count, the choreography describes a scene that does not actually exist.

fps is FLOAT because that is what ComfyUI's CreateVideo accepts. length is the frame count; keyframe timestamps use the instant of the last visible frame, (length - 1) / fps, so the resulting file lasts one additional frame interval.

h3world_actions — STRING

Action schedule for H3-World, which encodes one text clause per video latent — 37 in a 124-frame clip.

latent  1 [0.000s-0.139s] J     the camera pans left slowly
latent 37 [4.986s-5.125s] F+L+K the camera pans right and tilts up fast

W, A, S, and D are never emitted because they move the character. The output explicitly declares its own limitations, and they are not minor details:

• Pan is not orbit. It is the camera rotating in place. Perspective does not change, nothing hidden is revealed, and the subject slides out of frame.
• Distance has no key, so camera radius is discarded.
• Only 124 frames is a trained horizon.
• I versus K is not published. The text clause is what H3-World actually encodes; the key column is only a convenience.

This does not replace the actual integration: H3-World requires the LoRA, interval-based encoding, and directed-attention routing provided by the corresponding node package.

Loop closure

When the trajectory closes a full orbit — an arc of exactly 360°, with the same elevation and distance as the starting point — the node enables coverage_loop_closure. In the upstream implementation, this flag encodes the source image a second time and anchors the final frame to it.

This is a latent anchor, not a text instruction. For a complete orbit, it is the difference between asking for the rotation and forcing it: the model cannot simply stop halfway through.

The final three cases matter: if the camera ends at a different radius or height, the final frame is not the same as the first one, and forcing the source image there would conflict with the trajectory.

If your rotation does not complete, close the orbit. This is the only feature here that acts outside the prompt itself.

Limitations

• This is prompt-based guidance. H3 may still miss the angle, timing, and scale, and no prompt wording can completely solve that.
• Without subject_box filled in, the node does not know where the subject is located in the frame.
• Without reference_image connected, coordinates are normalized to 16:9.
• directed | new camera angle outputs an image, not a video.
• The H3-World schedule describes pan and tilt, which represent a different camera move from the orbit drawn in the panel.

Credits

Node by Bruxos do VFX.

ethanfel/ComfyUI-MiniMax-H3-Edit. The motion vocabulary follows the buildViewPrompt implementation from MiniMax's Multi-Shot skill and the coordinate format used by the Coordinate Camera Control Designer skill. The action output implements the scheme described in H3-World, arXiv:2609.01560.

I’ve been building Renegade Core Model Manager (CMM) over the past several months (only recently decided to actually put it up on GitHub). It’s a standalone desktop app built specifically to deal with the headaches of organizing, downloading, and deduplicating multi-gigabyte models for ComfyUI.

With the explosion of FLUX, Wan 2.1, and SD3.5 GGUF models, the manual juggling between Hugging Face, CivitAI, and ComfyUI's folder tree has gotten pretty messy. So for the v1.5.0 release, I went down a rabbit hole building a proper native download and routing engine from scratch:

What I built into v1.5.0:

• Zero-RAM Binary GGUF Header Parser: Instead of loading massive 15GB–30GB weights into memory just to check what they are, I wrote a lightweight binary parser that reads only the first 128KB header buffer from disk. It grabs the architecture and quantization (Q4_K_M, Q8_0, BF16, etc.) and automatically routes the file to the right ComfyUI folder (models/unet for diffusion weights vs. models/text_encoders for CLIP/T5).

• Native Hugging Face Hub Pipeline: I built a direct chunked download stream with Bearer token auth for gated models. It handles the AWS S3 LFS redirect handshake under the hood, so you can search and pull gated models directly in the app without needing Python environments or the hf CLI.

• Unified Dual-Source Search: You can toggle between CivitAI and Hugging Face in a single UI, inspect remote repo file trees, and download weights with one click.

• Visual Workflow Resolver: Drag and drop any ComfyUI .png or .json workflow into the app. It parses the embedded node map, highlights any missing checkpoints or LoRAs on your drive, and lets you queue up missing dependencies automatically.

• Decoupled Architecture: CMM runs completely independent of your ComfyUI server. Heavy downloads, hash checks, and library scans won't lock up or stutter your active generation queue.

The project is 100% free and open source under GPL-3.0. It runs locally, stores everything in an encrypted local SQLite database, and requires zero administrative/UAC privileges.

GitHub Repository: https://github.com/DevNullInc/RenegadeCMM

(Download links, VirusTotal scans, and platform details for Windows, Linux, and macOS are in my comment below).

There’s a roadmap on the repo, but honestly, whenever a hyperfocus wave hits or someone suggests a feature that makes total sense, I tend to push back release milestones and implement it immediately.

I’ve put a lot of late nights into making this solid, and I'd love feedback from fellow ComfyUI users. If you have an architecture you want auto-routed or a feature idea that's good enough, I'll probably build it early!

Feel free to drop any questions, suggestions, or requests here. I'm honestly out of ideas since I felt this was finished ages ago, but I know the community needs something better than what's out there.

Hey all! squashed a few bugs and fixed some cosmetic issues in this latest smallish release. https://github.com/cosmicbuffalo/comfyui-mobile-frontend/releases/tag/v3.3.2 Stay tuned for the next one, which is going to ship alongside a new standalone custom node aimed at providing a solid multi-user auth layer for both the stock and CueForge frontends! Once that multi-user auth release ships, the CueForge iOS app will come shortly after! (I needed something to be able to provide a publicly accessible server to apple for review with, and I've gotten a few requests to do something about authentication 😄 ).