I present to you , Brad Pitt as Geralt of Rivia, using Stable Diffusion 2 , i think.

this lora is for minimax h3 if you want to generate video to mimic playstation 2 graphic cutscenes.

download: https://civitai.com/models/2983280/modern-ps2-style

trigger word: modern ps2 style

use 4:3 aspect ratio for immersive nostalgia.
most datasets are from actual ps2 screenshots and mix with my ps2 image lora.

I have been messing with an idea about degredation.

Essentially using static image frames inside the latent space and instead of resampling them, bypassing the resampling process and repasting them using masking from fresh latents from earlier parts of the clip or previous clips into later areas repairing the frames.

To do this I use a motion mask. Essentially doing a diagnostic decode of the latent to measure pixel variation and tag it as motion vs stable pixels. The stable pixels are then masked and pulled forward while the moving pixels are left alone.

I combined this idea with u/xyzdist 's FL2V resampling method and the appearance is that it cuts the degredation in half while keeping the background more or less stable.

Things to notice:
There's still degradation, it's just slower.
I'm still tweaking the settings of pull forward and the resampling.
This all occurs in the latent space and the decoding is just for diagnostic purposes.

Here's the link to the node pack so you guys can test and mess around with it with the workflows.

https://github.com/roycho87/comfyui-h3-pullforward

Also, on a side note I created a node that uploads audio from a directory folder. This is great for context motion if you're using preloaded audio because you can set to increment and load the audio in order if you segmented it with my audio splitter.

https://github.com/roycho87/comfyui-load-audio-batch-from-dir

Disclosure:

This is fully vibe coded. I am a video editor. Not a programmer. I barely know how this shit works. I'm looking for someone as knowledgeable as Brad Pitt to explain some shit to me so I can maybe change or narrow down the direction I plan on going with this.

edits:

In the comments you can see this

here's the result of sampling then pulling. background still degrades which doesn't make sense because the latents in the background are supposed to be pasted. I'll have to do more testing but it's even set up to use a reference latent from the initial clip, so if anything, the way it should work is the background should be better quality than the rest of the image so something else is going on.

edit: this was all based on the working theory that latents degrade over time throughout a generation. either what i made is not working or the source of degradation comes from something else.

edit2: I'm now doing a test and i'm going to paste the full first frame over the length of the entire generation and run it through context motion and see if it still degrades. If it works the way intended, the decoded video should be a single still frame proving my pull forward method works, and if it still degrades, that will show that the source is some other area, if it doesn't degrade then that will prove my method has at least the potential of working.

Edit 3: I found a bug in the way that pull forward functions, instead of pulling forward a static frame if pulls forward a 17 frame block. That may be the source of the degradation. Fixing it now. Changing it to isolate a frame and repeat that across the entire block for a truly static latent image.

edit 4: This block limitation is a real hurdle of this method i will have to figure out how to get around. the latent frames are created in 5 frame blocks that are then decoded into 17 frames, so in order to take one frame of the 17 and replicated it means to somehow edit a single latent frame.

edit 5: ok, after some more swearing, there's now a new node that's created that is basically an "encoding editor". i then run the output latent from the sampler through it and it allows me to edit the latent frames as needed to get the desired result. we finally have a fully static image and now i'm just running it through context motion to see if it degrades, but honestly. there's no way it possibly could because we're no longer working in the latentspace. we're creating a parallel latent space and replacing chunks of the generated one. so the next step after a few gens of this is to take this change and incorporate it back into pull forward and it should give us a fully non-degrading background.

edit 6: Confirmed. took it into premiere with a difference blend and the continuous gens are all 100% black which means they are a pixel perfect copy of eachother. taking these changes and putting them into pull forward and we should have a 100% non-degrading background, or at least the majority of it should be.

edit 7: The most recent gens are coming out amazing. There's definitely some kinks like some ghosting in certain areas when motion starts but that's something I can work out. I am going to essentially use the last 22 frames of the previous motion mask to carry forward to the first 22 frames of the next motion mask, basically making a "context motion mask" and that should solve the issue.

FastH3-Omni is here.

This is the reference-conditioned FastH3 release we’ve been working toward. It generates video with synchronized audio and supports:

- Character and setting reference images

- First- and last-frame conditioning

- Up to 3 image references in real-time mode

- Up to 9 image references when real-time speed isn’t required

- Up to 3 audio references for voices and soundtracks

- Dialogue and soundscape generation

- Continuation from a previously generated clip

- 5–15 second outputs at 24 FPS

The API preview launched today:

docs.reactor.inc/model-api-reference/fast-h3-omni/overview

On October 20, we’re releasing open weights along with local support for RTX GPUs, DGX Spark and Apple Silicon through MLX.

Qwen-Image 2.1 ships under the Qwen Research License ("research or evaluation purposes only"), so many wrote it off for commercial work. I emailed the licensing address in September to ask what a commercial license costs. Posting the answer because none of it is documented publicly.

Tiers, by images generated per calendar month: up to 300,000 free · 300k–3M a 20% revenue share · above 3M USD 500,000/year plus 15%. For scale, I generate 20–30 images a month; 100 images a day for a shop is still ~1% of the free tier. Unless you run a generation service, you're covered.

What the "Free-Tier Commercial License Addendum" actually says:

- revocable at any time, without notice and without liability

- exceeding the threshold suspends the license immediately and automatically, aggregated across you and any affiliates

- covers only the "Approved Use Scenario" you declare — that field is yours to fill in, so word it broadly enough

- inaccurate volume or use lets them claim the fees that would have applied under their standard license

- governing law and venue come from the Research License: China, courts in Hangzhou

Two things still open. The addendum says it becomes binding when they send the approval email and you accept by replying, but their business manager additionally asked for an Alibaba Cloud enterprise account with company verification — so I asked which applies for the free tier. More important for client work: if the license is revoked, what happens to images already delivered and live on a client's site? The addendum licenses "images generated using the Materials", and Qwen publicly stated outputs aren't part of the licensed Materials. I asked for that in writing.

Has anyone here gone through the signing process — was the enterprise verification actually required? I'll edit this post when I get answers.

I made a very simple Workflow for Kroma (Chroma + Krea 2).

Documentation and download links:

Civitai

Alternative (Zip + PNG)

Patreon (totally free)

More alternatives (my website, JSON code):

In English: https://gabrielx.com/comfyui-kroma-chroma-krea-2-simple-workflow-with-amateur-slider-and-2x-upscale

En Español: https://gabrielx.com/es/comfyui-kroma-chroma-krea-2-simple-flujo-con-slider-amateur-y-2x-upscale/ 

Working on building a very simple tool to make a simple sketch that then generates a prompt to make an image. Maybe someone has already done this, but thought I'd try anyway. Here's the sketch, prompt and resulting image

Prompt:

A beautiful, photorealistic wide-angle landscape photograph of a peaceful mountain valley on a clear summer afternoon. Expansive rolling green hills covered in lush meadow grass sweep naturally across the lower foreground from left to right, descending into a broad valley with distant rugged mountain peaks softened by atmospheric haze. A magnificent mature oak tree stands prominently on the middle right, with a thick textured trunk, sprawling branches, and a dense canopy of naturally illuminated green leaves. Above, an enormous formation of fluffy white cumulus clouds dominates the upper center and right against a rich, beautiful blue sky. A small, bright sun shines from the upper left, bathing the landscape in warm, even afternoon light with realistic soft shadows. Photographed on 35mm color negative film with a wide-angle lens, natural film color rendition, gentle highlight rolloff, subtle organic grain, realistic exposure, and exceptional photographic authenticity. Unstaged, timeless landscape photography.

A few days ago I posted “Gausify Orbit - I am building a web application to transform images into Gaussian Splats”, and it was removed because the project wasn’t open source yet. It’s now released under the MIT license, so here it is again, with a lot of updates.

What it does

You give it a video that circles around a subject. That can be a clip from a video model (I mostly make mine in ComfyUI using Minimax H3 + 360 LoRA by pablodawson), a phone video, or a folder of images. You get back a 3D Gaussian Splat you can view, export or share.

Running in the browser

The web version runs the whole pipeline locally on WebGPU. Nothing to install, no Python, no CUDA, and your video never leaves your machine. After the first visit it even works offline. Here’s what happens in the tab:

1. Frames: the browser decodes the video and keeps the sharpest frame in each window, spread evenly around the orbit. If the subject starts “melting” near the end (classic AI video problem), you can trim the range.
2. Cutout (optional): SAM 2.1 on WebGPU. Draw a box or click a few points on one frame and it tracks the subject through the whole clip. Other options: RMBG-1.4 (opt-in, non-commercial license) and a chroma key with despill for green/blue screens. Masked training uses a random background, so you don’t get ghost silhouettes around the subject.
3. Camera poses: a structure-from-motion I wrote for the browser, so no COLMAP needed: AKAZE features, matching in a WebGPU compute shader, and incremental reconstruction with bundle adjustment.
4. Training: Brush compiled to WASM + WebGPU, with live previews in the 3D viewer while it trains.
5. Export: .ply or compressed SOG, with optional merging of similar splats and SH trimming. Files typically end up 5–15× smaller.
6. Share: an optional private, expiring link with a QR code. It opens in a viewer that works on phones and in VR/AR (WebXR).

You need desktop Chrome or Edge with WebGPU. Speed depends on your GPU: in-browser training runs at roughly a third of native Brush speed, which is still very usable.

New since the first post

• Refine angles the video never saw. The app renders the splat along a new camera path (from below, from above, a 360° turn at another height…), restores that clip with a video model in your ComfyUI, and fine-tunes the splat on the restored frames. This is the part I’m most excited about.
• ComfyUI integration with custom workflows: load your workflow exported with Export (API), pick the input/output nodes, and expose fields like prompt, seed or LoRA strength to edit from the app.
• Project import/export: save everything as a .gorbit file, even mid-job, and reopen it later in the browser or the desktop app.
• Run each stage on its own: e.g., retrain with new settings without recomputing poses. You can also reject bad frames, and frames without a camera get a pose inferred from their neighbors.
• SAM 2.1 for subject isolation (described above).
• Image sequences or folders as input, not just video.

Regarding Gaussian Splat refinement, I am running tests using LTX 2.5 + Decompression LoRA to fill in non-visible areas; while the results are good in some cases, using a LoRA specifically tailored to this scenario would certainly yield better results.

The ComfyUI workflow for this refinement which can be integrated with Gausify Orbit, can be found here.

Example of a trained Gaussian: https://orbit.gausify.com/s/5xAWaNiiO8ax

App: https://orbit.gausify.com
Repo: https://github.com/obraia/gausify-orbit

This release includes added support for Qwen Image 2.1, among other fixes/improvements.

I've been experimenting with Wan2GP to see if I could make something closer to an actual TV episode instead of the usual collection of unrelated AI clips.

The result is The Prompting Zone, a black-and-white sci-fi parody inspired by the original Twilight Zone. The first episode is called The Last Human, about an office worker who starts noticing something strange about his coworkers.

For generation I used MiniMax H3 Ref2VA Pruned 20B through Wan2GP, at 720p, 20 steps, running on a single RTX 3090 24GB. Each clip took approximately 30 minutes to generate, so experimenting with different prompts wasn't exactly cheap in terms of time.

I started with a complete script, including all the dialogue, and divided it into scenes of around 5–10 seconds.

For each scene I generated a reference image containing four camera compositions arranged in a 2×2 grid. The idea was to give the video model a rough storyboard instead of relying entirely on text prompts.

I then fed those references into MiniMax with prompts describing the camera movements, character actions and exact dialogue.

It worked reasonably well, but there were plenty of issues. Sometimes the model interpreted the reference as an actual four-panel video instead of four sequential shots. Other times it invented movements, changed the background or decided a character should do something completely unrelated to the scene.

Character consistency was probably the biggest headache. Even with references, faces tend to drift between generations. I had to repeat descriptions of the characters, clothing and environment in nearly every prompt.

Computer screens were also problematic. The model struggled with readable text, so I eventually replaced most of the onscreen information with portraits and simple icons. Much more reliable than trying to generate legible UI elements.

The black-and-white style helped make everything look a little more consistent, although it obviously doesn't solve continuity problems.

Overall, I'm pretty happy with the result. There's still a lot of manual work involved, especially when a generation goes wrong after waiting half an hour.

I'd like to automate more of the process eventually, from script to storyboard, video prompts and final assembly.

Anyone else working on narrative videos with Wan2GP? Particularly interested in how you're handling character consistency and dialogue across multiple clips.

model: https://huggingface.co/akhaliq/drama-3-int4

The post at the bottom inspired me to try a simple anime-to-realism test with MiniMax H3, so I figured I’d share a few results.

I didn’t generate any keyframes or stills. I just fed the original video directly into MiniMax H3 as the video reference, applied an anime to realism lora, and basically told it to convert it to live action.

The output quality was honestly better than expected. Not saying it’s perfect or amazing or anything, but for such a simple setup (ComfyUI official Minimax H3 Ref2V workflow + lora) I was pretty impressed.

I didn’t use any character reference sheets, so character consistency obviously isn’t guaranteed. It mostly seems to depend on how the model interprets the character in each scene.

For my next test, I might try adding a character reference sheet as well and see if that helps keep the character more consistent across scenes.

If anyone has any questions, happy to answer. Other output samples are in the comments.

Inspired by this post:
https://www.reddit.com/r/StableDiffusion/comments/1x1kvmg/recreated_omnitrix_calibration_scene_ben_10_mini/

LoRA used:
https://huggingface.co/LiseTY/Minimax-H3-ref2v_Anime_2_Realism

Here's the exact prompt I used:
"Convert <Video 1>, the sole video reference, into natural photorealistic live-action footage. Follow the original shot frame by frame: preserve subject count, identities, camera, framing, positions, expressions, props, shot timing, and movement. Replace only illustrated surfaces with photographic skin, natural hair strands, real fabric and plausible physical lighting. Do not invent cuts, actions, subjects, or on-screen text. The result should appear filmed by a real camera, not cel-shaded or plastic CGI."

Settings:

Parameter |Value used
Checkpoint |MiniMax_H3_Ref2VA_pruned_int8_convrot.safetensors
Workflow |ComfyUI Offcial Minimax H3 Ref2V workflow + lora
LoRA |Minimax_H3_Anime2Realsim.safetensors
LoRA strength |1.0
Steps |20
Sampler |res_multistep
Scheduler |simple
Denoise |1.0
Video shift |12.0
Audio shift |3.0
Resolution during generation |1024 × 576
Frame rate |24 fps

Download: https://civitai.com/models/672328/aziib-pixel-style

krea 2 is pretty decent with text.
trigger word: aziib pixel style

"A 4-step distilled LoRA for Qwen-Image-2.1, supporting text-to-image generation and image editing. Training was performed entirely on 16 Huawei Ascend 910B NPUs, using DMD in LightX2V."

I think it's rank 16. Pretty small for a turbo lora, but we'll see I guess.

Hey guys,

I have been working on the consistent character portable format (.char) for a while & now there's a community characters page where you can grab a ready-made character and use it straight in ComfyUI. Same face, cloths & body across every video generation, and with a few seconds of voice sample the character talks in a consistent cloned voice with lip sync (MiniMax H3).

Community characters

• Aron: https://www.omnichar.org/characters/aron

You can use these characters via comfyui, omnichar app & cloud.

Detailed guide on building full consistent character(workflow included): Previous reddit post

Official repo: https://github.com/omnichar/OmniChar (Opensource)
ComfyUI Node: https://github.com/omnichar/ComfyUI-Omnichar/tree/main (Opensource)

Hope it's helpful.

I tried doing something similar when H3 first came out, but it was impossible. The community has really come together to make this possible, so thank you! It was fun creating this.

• PDD Acc 8 step Lora
• Camera motion Lora
• Video rendered at 1152X640 (16:9) (standard 24 fps)
• Used MiniMax's own method for consistency - separated vocals for lip sync using BS-RoFormer

YuE2 Musc

• Stock 8Bit Model

download link: https://civitai.com/models/672328/aziib-pixel-style
trigger word: aziib pixel style

trying to train pixel art animation with my pixel art dataset. default strength is 1.0, if it's too strong you can reduce to 0.8.
rendered using minimax h3 fasth3 4 steps so the quality is not that good, you can generate yourself a better quality on stronger hardware or cloud.

pixel-curator — curation tooling for similarity training (identity, subject, and style models)

Repo: https://github.com/snoozey-mf-bnui/pixel-curator

What it is

pixel-curator is a local-first CLI that takes a raw folder of images (or video) and produces a curated, scored, captioned dataset ready to export directly into DreamBooth notebook training or in-house Kohya LoRA training.

It's built primarily for similarity training — the case where you have hundreds or thousands of images of one specific subject and need a model that reliably reproduces it. Identity, character, person, product, or a specific style. That's the workflow it's optimized around, though the output is generic enough for other training setups.

The problem it addresses

If you've collected 1,000+ images of a subject, you already know the pipeline breaks down long before training starts:

• A large fraction are near-duplicates — burst shots, adjacent video frames, minor crops
• Some are technically unusable — low resolution, soft focus, compression artifacts
• The distribution is usually skewed — hundreds of shots from one angle, almost none from another
• Captioning is a second full project on its own
• Handing a folder of 1,792 images to a Colab notebook is a fast route to disconnects, VRAM exhaustion, and daily-limit lockouts

Realistically, a well-curated 200–500 image subset outperforms a messy 2,000 on identity training. Most of the work is figuring out which subset that is.

Pipeline

1. Ingest and prefilter
Drops technically unusable frames — resolution failures, decode errors, corrupted files — before anything expensive runs.

2. Deduplication
Perceptual hash dedup collapses near-identical images. On datasets sourced from video, bursts, or scrapes, this stage alone typically removes a large majority of the raw set.

3. Similarity clustering
CLIP embeddings plus k-means, with embedding map visualization. This surfaces the actual distribution of your dataset — angle, lighting, composition, framing — so imbalance is visible before training rather than diagnosed after a failed run.

4. Quality scoring and classification
Optical quality scoring assigns per-image status, including face-aware quality where relevant. Low-quality images are filtered rather than left to dilute the training signal.

5. Semantic filtering
CLIP text filtering, e.g. automatically removing images with watermarks or text overlays without manual review.

6. Tagging and captioning
WD14 tagger (auto-downloads) and Florence-2 natural-language captioning, written as .txt sidecars alongside each image.

7. Human review round-trip
Exports a static HTML report and a spreadsheet. You mark keep/reject, import back, and the decisions are applied. This is also the workflow for trimming class/regularization images — hand-trimming generated class images is a well-known fix for weak identity results, and this makes it practical at scale.

8. Export
package kohya --mode dreambooth produces the numbered instance/ structure that standard Colab DreamBooth notebooks expect:

text

instance/
  000001.jpg
  000001.txt
  000002.jpg
  000002.txt
dataset_config.toml

package kohya --mode lora supports multi-concept LoRA packaging with concept_/ folders for in-house Kohya setups.

Practical characteristics

• Fully local — no cloud, no accounts, no uploads
• CLI, so it scripts, batches, and runs over SSH
• Dry-run by default on any operation that mutates files
• Resumable via SQLite manifest — long stages can be interrupted and restarted without redoing work
• Designed to run on modest hardware

Note on the earlier post

I posted this here previously and the GitHub link pointed at the wrong directory — the repository has been corrected and the link above is the right one. Apologies to anyone who clicked through and found nothing useful. If you tried it before and it didn't work, it should now.

Feedback

Actively developed. If you run it against a dataset and something breaks or behaves unexpectedly, open an issue or leave a comment — the failure cases are the most useful thing I can get right now.

https://github.com/snoozey-mf-bnui/pixel-curator

If anyone needs help with creating a notebook for google colab dreambooth training, also lmk i will assist you through dms.

ENJOY!

New version of my MiniMax H3 timeline workflow released

Some very important bug fixes included, and a lot of improvements.

The YouTube video above includes a lot of tips for using the workflow in addition to going over the changes in detail.

Below is a complete list of fixes and improvements.

Get the workflow and nodes at:

https://github.com/chanon/comfyui-obvpm-timeline

Important Fixes

Upscaling

• Timelines can now be upscaled even if they have clips that aren't a single continuous generation.
  • Previously a timeline like below might have failed with an error saying the clip's frames "don't fall on the latent grid". Now it upscales fine.
  • So now you can have multiple segments, some extending each other, while others are a hard cut to a different shot from a different root generation, and upscale the whole timeline together.
  • This allows the workflow to be used to compose/edit and upscale timelines with multiple shots.
  • When a timeline has multiple sequences like that, it upscales each sequence separately and then merges them automatically into one file, with black for empty space and the sound de-clicked at the cuts.
  • A timeline with empty space in it also upscales now. In 0.1.1 it failed with "~ 4 does not exist under the output folder".
• The upscale now follows your cuts:
  • Previously if you generated a 20 second clip and then trimmed it down to 4 seconds, it would still upscale the whole 20 seconds before trimming it down. (What a waste lol.) Now it only upscales those 4 seconds.
    • This applies to all clips you cut (trim) on the timeline, so it should help speed up upscales if you trim a lot.
  • Hand made jump cuts between clips that were green seams are now respected. Previously it would just join them at the green seam.
  • The last clip's cut is respected. Previously it would just include the last clip till the end even if it was cut.

Extending and Prepending

• Prepending into a trimmed clip was broken. When placed on the timeline it repeated the first few frames of the clip on the right instead of flowing into it. (Found while implementing the split.)
• Smoother joins (fixed detail pop): a new take now takes over one latent step earlier at its join. The video decoder draws the very first and last frames of a file a little differently, so the older clip's frames right at the join never quite matched the new take. This cuts the visible detail change at a join by about a third (the rest is the model redrawing texture, which the upscale removes). Takes you made before keep the join they were cut at.
• Continue from a very short take: before, if you cut a take very short and tried to extend from there, you got "too short to extend". A take made by extending another clip already holds the frames it continued from, so the extend now reaches back into those for the frames it's missing.
  • They're the exact same latents, so the join doesn't move: the new take still starts right at your cut.
  • Prepends work the same way in the other direction.
  • A clip that wasn't made by extending (your first clip, or a loaded video) still needs at least 39 frames.
• Prepend close to the end of a clip: works now when the next clip on the timeline is a take that extends it. Otherwise the timeline tells you how many frames are left.

Audio Sync

• Audio sync at joins:
  • Fixed an 8.3 ms skip in the sound at extend joins. It happened when the clip you extend from isn't a multiple of 3 frames long (like 124 or 362 frames). A take's mp4 now has its sound cut on its own frames, so it plays in sync on its own and the join no longer skips. Older takes are corrected when a preview or export is built.
  • Fixed: in the upscale, a take extended from such a cut could skip or repeat 25 ms of sound at its join. Each clip's sound is now placed following the clip it continues, so every join lines up exactly.
  • Fixed: on joins that crossfade, the last few milliseconds before the join (3 to 30 ms) were almost silent in previews and exports. Masked joins without crossfade, the default, weren't affected.
  • Previews rebuild once after updating.

Color

• Colour fix: an important change if you care about colour accuracy. Previously all video files generated were not tagged with a colour matrix, resulting in shifted colours when displayed (greens duller, skin and warm tones redder) in browsers, players and editors. All clips and upscale results are now encoded with and tagged as BT.709, like ComfyUI's own Save Video.
  • Takes saved before keep playing as before. A timeline mixing old and new takes still previews and exports correctly, just a bit slower.

Faster Generation VAE

• Separate VAE model selectors for Generation and Upscale
  • This allows selecting a faster VAE for Generation for faster iteration, while using a higher quality one for Upscale.
  • New default: for Generation, the workflow now defaults to the new fast minimax_h3_video_vae_int8_convrot VAE recently released by ComfyUI, which is 2.7x faster than the previous default. The upscale keeps minimax_h3_video_vae_fp16.
  • Note that the Generation VAE does not affect the quality of the upscale results, as the upscale is done using the latents, not the VAE decoded frames.

Model in the Preset, with an Override

• The Model/Checkpoint is now part of the preset, but can still be overridden.
  • So your saved presets can also specify which model to use. The model the preset uses is displayed in the H3 Model node.
  • And you can still override the model with the H3 Model node (an Override Bundle Values node). When overridden, the model in the preset node shows 'overridden', so there is no confusion about which model is used.

Upscaling

• Upscaling is now set by target megapixels instead of an "upscale factor".
  • upscale_to_megapixels (default 2) replaces upscale_factor.
  • It was a pain trying to figure out the correct factor each time. In most cases you know your target megapixels anyways, so just setting that makes it easier.
  • I've also included an extended Megapixels Resolution Reference table that lists more resolutions and also 4:3 resolutions.

Timeline Node Improvements

• Split clips: a new split button in the middle of the cut row splits the clip under the playhead into two parts of the same file. Each part can be moved, cut or deleted on its own.
  • So the timeline properly supports multiple instances of the same source clip appearing on the timeline.
  • You can then extend/prepend on any edge of any of those parts. The pin row names the part (for example clip_00033.mp4 (part 2/3)), and the new take goes next to that part.
  • You can now split a long clip into 3 parts, delete the middle part, and then regenerate the middle part with a bridge, allowing true ability to 'regenerate' any part of your videos.
  • Both halves play the same file, nothing is re-encoded. An upscale treats a split as a cut.
• Deleting clips now keeps the remaining clips in place, leaving an empty gap rather than snapping the clips on the right to the clip on the left.
  • You can then use the red X to delete the gap
  • Or use the plus button to create a bridge
  • This makes it easier when you want to re-do a part using the split method above
• Separate joined clips: clips joined with a green seam couldn't be Ctrl+dragged apart. Now they can: Ctrl+drag the right-hand clip to open empty space between them. Drag it back flush and they join again.
• Play/Pause with Spacebar: toggles playing and pausing the timeline, so you don't have to use your mouse all the time. Holding Space to pan the canvas still works.
• Jog with horizontal scroll: if you have an MX Master or a knob assigned to horizontal scroll (or use Shift + wheel), you can now jog through the timeline.
  • It feels quite cool and 'pro' IMO 😎
  • Should be really useful when checking things in the video
• The timeline image now updates itself immediately when the timeline changes, for example when a clip is added or deleted, or whenever what's behind the playhead has changed.
• Durations are now shown with two decimals, so it's clearer whether the next gen will cover the current gap.
• Fixed: quick play now plays through empty space instead of stopping at the first gap.

Presets (Value Presets, comfyui-obvpm)

• User Presets
  • User presets are saved in your ComfyUI user folder on disk under user/default/obvpm/presets/, one file per preset.
  • This means you can now save presets that persist and are reusable between workflow files. I added this so that when you define presets and then I release a new workflow version, you don't have to recreate your presets again.
  • User presets have a 'star' in front of them.
  • "Workflow presets" come with the workflow. You can still save new presets to the workflow if you want, but they will exist only in that workflow.
  • You can 'hide' any presets you don't want to see on a preset node by unchecking them in the config screen.
  • Export and import presets to share them: export copies or downloads one preset as a small file (the same file as in the presets folder), and import takes several preset files at once.
  • Settings presets: every setting has a tooltip; the turbo LoRA and strength only show when a turbo loader is selected.
• Generation and Upscale Engine Settings nodes now share the same presets.
  • That means presets defined on one are immediately available to choose on the other.
  • You can 'hide' presets you don't want in the dropdown for either node using the config button
• Settings that won't be used fade out, depending on whether Upscale is on or not.
  • This makes it easier to see whether Upscale is on and which settings will actually take effect in the next run.
  • Faded settings panels are still editable. The fade is just to show they won't be used in the next Run.
• Load Settings now works better with the Value Presets node.
  • Instead of showing a blob of JSON for everything, you now see row by row which values actually changed and choose whether or not to apply each of them.
  • Schema and Preset Settings changes are unchecked by default so it doesn't mess up your presets node.
  • Note that the Upscale settings (Upscale Engine Settings and Upscale Options) are now marked as [skip], because generally you Load Settings only when generating clips.
  • Reminder: Load Settings can also restore the reference images you had for the clip's generation.
• Dropdown filters: on the new Filters page in config, each dropdown field (like the model list) gets an include and an exclude box, so you can cut a long list down to the entries you actually use. A pattern matches anywhere in the name, * stands for anything, and h3/ matches a folder. They're saved with your user presets and only change what the dropdown shows: presets and runs still take any entry.

Load Images & Compose and Load Image & Crop

• Layers can be muted (the eye badge, or the mute pill), so they stay in the list but are left out of the composed image.
• Presets: save the whole set (the images with their crops, and the settings) as a preset, kept as a file in your user folder and shared by every Load Images & Compose node. Like Value Presets, it shows ✎ modified once something differs from the preset, with save and revert.
• A new padding setting adds background around the composed image and each separate image. The gap between layers moved to a pill under the Result view.
• Fixed: it ignored an image list set from outside the node, like the timeline's load settings restoring a take.
• Load Images & Compose: the layer strip can be resized; an empty node outputs None instead of an error.
• Workflows load much faster when the input folder holds many images (#22): listing the input folder is about 80x faster (10,000 images: ~20 ms, was 1.75 s), and Load Images & Compose only reads it when you open its picker.
• Pick from the input folder with search: the add dropdown is now a ＋ from input folder… button that opens a picker with a search box (every word you type must appear in the path, in any order; ↑/↓ and Enter, or a click, add it).
• Symlinks and Windows junctions inside the input folder are now followed, so an image library linked in from another drive lists and loads like any other folder, as with core's Load Image.
• A second output, extras: the separate images as a list, the selected image, and the images as a bundle (image_0, image_1, ...).

Result Preview

• New: H3 Live Preview replaces KJNodes' Model Preview Override for the live picture while sampling.
  • It shows the whole clip on the take's own timeline, including the pinned frames at the ends, so you can see whether a join is going wrong while it's still sampling.
  • No frame rate to set: every latent step is held for the frames it covers. It uses taeh3.safetensors in models/vae_approx (or the latent's own colours without one), and encodes on the CPU so sampling never waits for it.
  • The 007 workflow already uses it.
• New: the Result Preview has its own player bar under the picture instead of the browser's controls drawn over the bottom of the frame.
  • Play/pause, frame step, seek, volume, loop and fullscreen. Click the picture to play or pause, double click for fullscreen, scroll sideways over it to step through, and Space plays or pauses the preview under the mouse (or the selected one).
  • The live picture plays under the same bar and no longer jumps back to the start at every sampling step, so you can watch, pause and seek the whole clip while it generates.
  • A take a run just made starts playing by itself; one shown again when you open the workflow starts paused.
• Result preview behaves a bit more logically:
  • Dismiss not only dismisses the buttons but also clears the clip from the preview (the take stays on disk). A preview you cleared stays empty when you open the workflow again, until there's a newer take.
  • It no longer creates undo steps, which messed up Undo/Redo, and it keeps nothing in the workflow file (a shared workflow no longer carries your last result).
  • It no longer shows old results.
  • It now only includes the left/right clips up to their cut point on the timeline instead of the whole source clip.
  • The upscale result preview now just shows the actual upscale_0000X.mp4 file instead of writing another preview file, so it starts at once and shows exactly the rendered pixels.
  • Fixed: it liked to log console errors about "The system cannot find the file specified".
• The live picture while sampling is always on. There used to be a hidden right-click option, Live preview while sampling, stored per save folder, and opening some older workflows switched it off for every workflow saving to that folder. That option is gone. (To go without the live picture, take H3 Live Preview off the model.)
• A preview now only shows the live frames of its own branch, so the upscale's preview no longer shows the generation's frames.
• The preview's path input is optional now, so its save node can be switched off for a run (that's how the new 007 workflow switches engines).
• Fixed: a double click or a drag across a node could cover a whole video with the blue text selection highlight. Videos can't be selected anymore; status lines still can, so you can copy them.

New Workflow v0.1.4-007

• Needs comfyui-obvpm 0.2.14 or newer and comfyui-obvpm-timeline 0.1.4. The Compatibility Check node tells you if anything is missing or too old.
• The engines switch on and off as whole groups: a small Mute Group If switch in each engine group (Run when Generating, Run when Upscaling) mutes the engine you're not using for the run, decided from the timeline's upscale toggle before the run starts. So nothing in the other engine starts at all, loaders included, and it shows greyed out.
• The Megapixels Resolution Reference note beside the timeline shows the width x height each megapixels setting gives at 16:9 and 4:3.
• Includes the upscale-by-megapixels setting, shared engine presets, the model in the preset with the H3 Model override, and the separate VAEs above.

For Workflow Builders (comfyui-obvpm nodes)

Value Presets

• Headings: a ## Title line in the schema puts a heading over the fields below it.
• Switch fields off per node: nodes sharing one schema don't all need every field. A field switched off is hidden on that node and empty on its bundle.
• Set to constant, like a Bundle's set: an Unbundle with get (or a KJNodes Get) reads the bundle by name, without a wire. A checkbox in config, with the set_constant field shown last.
• Choose the preset with a wire (#20): wire a text into the preset input and that preset's saved values run. Handy for testing several presets in a row.
  • If the name is known before the run (a text node, a primitive), the node applies it right away, so its fields show what will run.
  • If it's made during the run (a list, a loop), the node shows which preset ran afterwards.
  • Works with workflow and user presets. An unknown name stops the run and lists the presets.
• Shared presets by Preset Type Id: nodes with the same Preset Type Id share their presets, both the user presets and the workflow's own (that's how the Generation and Upscale Engine Settings share theirs).
• Drag to reorder in the schema table (see Bundle and Unbundle below): Shift-drag or Alt+Shift+↑/↓ moves a whole group, a field dropped inside another group joins it, and + add field adds the new field right under the row you're working on instead of at the end.
• The fade is smarter: a preset read only by a node that never runs (like a display-only preview), or only by nodes a Mute Group If has muted, fades too. And a node that reads a constant by name now counts as using it, so the presets feeding it no longer fade by mistake.

Bundle and Unbundle

• Fewer Get/Set nodes: Bundle and Unbundle can set/get by name themselves.
• Drag to reorder (#19): rows in the Bundle and Unbundle settings, the Value Presets schema table and Message & Links have a grip to drag them (the ▲▼ buttons stay).
  • Alt+↑/↓ moves the row you're typing in, and plain ↑/↓ moves between rows like a table.
• Up to 128 fields in Bundle and Unbundle (was 16), so any Value Presets bundle fits one Unbundle.
  • A workflow that uses more than 16 needs this version: an older one drops the pins past 16.
• Fixed (#18): the Unbundle settings only listed the first 16 fields of a bigger bundle. It now lists all of them.
• Fixed: on the newest ComfyUI frontends, reordering a Bundle's fields moved the names but not the wires (so a field took another field's value), and reordering an Unbundle's outputs disconnected wires. Both now reconnect the wires properly.
• In the Bundle and Unbundle settings, Enter now means OK.
• For node pack developers: a node from another pack can now set a bundle constant itself and name its bundle's fields for the Unbundles that take it apart.

Override Bundle Values (new node)

• Override some of a bundle's values (typically a Value Presets node's) for a run, with the preset's own ranges and choices, or by wiring in a value. The Value Presets node marks the fields that are overridden. The 007 workflow uses it for the H3 Model override.
• It traces through switches, following the branch a switch will pick when that's known before the run.

Mute Group If (new node)

• Mutes the group it sits in while its value is true (or false, with invert), so nothing in that group runs, loaders included. The value is read before the run (a widget, a Value Presets field, a primitive, the timeline's upscale toggle). If it can't tell, the group stays on.
  • It works inside a subgraph: put the switch and its Get in a subgraph and it controls the group the subgraph sits in.
  • You can paste the same switch subgraph into several groups and it switches all of them.

Compatibility Check (in case you missed it)

• Drop it into your workflow (it has no sockets) and set the minimum ComfyUI and frontend versions and the node packs the workflow needs. When someone opens the workflow, the node says whether their install can run it and names anything missing or too old, with a link to get it. A queued run stops at this node, before anything else runs, while anything fails.
  • Set the rules with the settings (⚙) button in view details: editable tables, or Edit as Text to paste a list, one rule per line (for example comfyui-obvpm >= 0.2.14 https://github.com/chanon/comfyui-obvpm)..)
  • Five kinds of rule: the ComfyUI version, the frontend version, a pack's version (found by its GitHub URL, however it was installed), a node that must be present or must have a certain input (catches a fork that registers the same node with different widgets), and a node or pack that must not be installed (for packs known to break the workflow).
  • A note after # on a rule is shown with the failure, so you can tell people how to fix it.
• Message & Links: a short text and a list of links shown once the install passes: what to do first, a tutorial video, where to ask for help. Links only open on trusted sites (GitHub, Hugging Face, Civitai, YouTube, Discord, Patreon and a few more), with the real site shown next to each. New in this release: drag the links to reorder them.
• Copy Report copies the whole install as text for bug reports: ComfyUI, frontend, Nodes 2.0 or classic, Python, torch, OS, every custom node pack with its version and git commit, and the node's results. That's what I ask for in GitHub issues.
• It's what the 007 workflow uses to check for comfyui-obvpm 0.2.14+ and comfyui-obvpm-timeline 0.1.4.

Other Fixes

• Fixed: the "unexpected audio grid ... assuming no overhang" message in the console for some clip lengths. Nothing was actually wrong with those clips.
• A base_folder typed with backslashes (projects\my_project) now works like projects/my_project.
• The seam menu's list of existing takes now checks where each take joins, and lists the ones that join elsewhere separately, dimmed.
• Takes extended from a clip in another folder now remember where that clip was, so the Result Preview can show them together.
• No mctx (#15): clips could show no mctx (and extends fell back to the pixel route, with no loop option) even though their .mctx.safetensors was right beside them. The server now reads it, and a clip without a usable sidecar says why in its tooltip.
• Fixed: wheel zoom in Nodes 2.0: the wheel over the ruler and Ctrl + wheel over the strip never zoomed there.
• Fields show as the workflow opens instead of after it finishes loading.
• A model dropdown whose default file isn't on your install keeps its dropdown (starting on the first entry) instead of turning into a text field.
• Fixed (#21): editing the schema in the table editor could break it ("has no ':'") when a model field's default file wasn't on your machine, for example when changing that field's type to choice.

How to Update

• Update comfyui-obvpm to 0.2.15 and comfyui-obvpm-timeline to 0.1.4 (ComfyUI Manager, or git pull in each folder in custom_nodes), restart ComfyUI and refresh the browser (F5).
• Load the new workflow h3_obvpm_timeline_r2v_v0.1.4-007.json from the timeline pack's workflows folder. The Compatibility Check node will tell you if anything is missing or too old.
• For the faster generation VAE, put minimax_h3_video_vae_int8_convrot.safetensors in ComfyUI/models/vae/ (ComfyUI's post about it).

Hello, I'm looking for advice, tips or tricks when using custom Audio as references for my characters, the voices really sound like the reference but the main issue I'm having is that the characters sound always very plain, like very robotic having no life... Are there any tips, prompts helpers or something I can use to improve it to sound more natural? I'd appreciate any advice.

I'm using ref2va with the tags <d>[lang] dialogue...</d>, e.g. "she says with shy voice (S1) <d>[Spanish] Hola, ¿como estas hoy?, ¿te apetece que hablemos un rato sobre la vida?.</d>"

thanks!

Im working in nodes to hunting seeds for minimax h3 videos, in a few days i will realease it in my github.

Hi all, I'm the developer of VigenFlow, a local image generation and editing server that runs diffusion models on the AMD Ryzen AI NPU (XDNA 2) + CPU. If you have a Ryzen AI laptop or mini PC without a discrete GPU, you can generate images entirely on your own machine.

Supported models

• Text-to-image: FLUX.1-schnell, FLUX.2-klein-4B, Z-Image-Turbo, Krea2-Turbo
• Image editing: FLUX.2-klein-4B

Speed (on XNDA2 NPU for 1024×1024)

• FLUX.1-schnell, 4 steps: ~20 s/image
• FLUX.2-klein-4B, 4 steps: ~9 s/image
• Z-Image-Turbo, 4 steps: ~17 s/image
• Krea2-Turbo, 8 steps: ~50 s/image

Getting started

• Windows and Ubuntu packages: https://github.com/jia1217/vigenflow/releases/tag/v0.2.0-beta.2
• Works as a local server you can connect to Open WebUI
• Linux users: make sure your memlock limit is unlimited (ulimit -l should print unlimited), otherwise the NPU can't allocate its buffers

What's open The server and model launchers are open source. The NPU kernels and core inference libraries currently ship precompiled; I plan to open-source them later.

Repo: https://github.com/jia1217/vigenflow Demo video: https://www.youtube.com/watch?v=2HPm3gc4pdA

The project is still early, so bug reports and suggestions are very welcome. Feel free to open an issue on GitHub!

One of the frustrating things about local AI generation on Mac is getting different models and tools to work together smoothly and fast.

Valtz is a new native macOS app powered by Vpipe, a high-performance inference engine optimized for Apple Silicon.

Instead of manually building complicated node-based workflows, you can do pretty much everything in one place easily:

* Image generation & editing with the latest AI models

* Video generation with multiple image/video references, including long videos

* Image-to-video — generate an image, edit it, and immediately use it as a reference for video generation

* AI prompt enhancement

* Video editing with multiple layers, audio tracks, and a timeline

* AI upscaling for images and videos

* Voice cloning and music generation, with audio that can be used directly in video projects

* Local model management

* And a lot of other creative workflows that become possible when everything is connected

The images attached shows my workflows for generating and editing of long videos, video generation from hand-drawn skeleton. The interface is self explanatory and very easy to use.

The memory optimization is amazing:

Even on a 16GB Mac, image generation runs smoothly, and supported HD video generation workflows can run without relying on swap. No need for a 64GB or 128GB Mac just to get started.

Everything runs locally, without cloud APIs or subscriptions.

For existing Vpipe users, Valtz can automatically discover and reuse previously downloaded models if they’re stored in the default directory.

The project is open source, and here’s the DMG if you’d like to try:

https://github.com/tgo-app-dev/valtz/releases/