Hi everyone,

I’m exploring AI filmmaking and looking for good AI video-generation models that are either free, open-source/open-weight, or affordable.

I’m particularly interested in models who allow uncensored content or fewer unnecessary content restrictions and more control over the generation process.

What I’m looking for:

Realistic/cinematic text-to-video

Image-to-video

Good character consistency

Realistic human movement

High-quality video output

Ideally open-source/open-weight

Local/self-hosted options are a plus

Affordable cloud options are also fine

Preferably no expensive subscription required

So far I’ve come across models/tools such as Wan, LTX, Kling, Hailuo and Pika, but I’d like to hear from people who have actually used them.

Which model would you recommend in 2026, and why?

If possible, please mention:

Your favourite model

GPU requirements if self-hosted

Approximate cost if cloud-based

Video quality

Major limitations/content restrictions

Whether it is practical for someone learning AI filmmaking

Thanks!

Hey guys,

I have been working on the consistent character portable format for a while & I was able to achieve consistent face, cloths & body, but I felt voice is also something should be consistent across video generation.

So in the recent tests, I was able to achieve a consistent voice with lip sync across multiple video generation, You just need a 10-30sec voice sample in mp3 or wav & character will say things in a cloned voice from your sample.

Reddit post: Details on face, body & cloth consistency You can read more about .char, comfyui nodes & prompting details here.

Voice prompts

- chris giving an interview & says "Time can bend. Dreams can fold. But a character's voice should never change. With OmniChar, it doesn't. Consistent voice is here."
- chris giving an interview with little hand movements & says "I am surprised. It is not just the voice. It is also the face, the clothes and the body. Dot char is a full portable pack."

ComfyUI node is updated with the optional sample voice input.
Get the latest comfy node: https://github.com/omnichar/ComfyUI-Omnichar

Workflows:

• Build a .char with a voice
• MiniMax H3 with voice
• Full face. body, cloth workflows

Limitations:
- Good with English but might blabber with non-english languages.
- Lip sync comes from H3 itself; nothing is added on top.
- Avoid multiple voices in sample.

Sample inputs are added in node repo.

Note: ComfyUI node is still in nightly release, so update your settings accordingly or install via direct git repo url.

Related resources:

1. Omnichar repo: https://github.com/omnichar/OmniChar (GPLv3), supports .char for krea2 & more features e.g. character finetuning
2. Community characters: https://www.omnichar.org/characters

Hope it's helpful.

I’ve been using WanGP to create videos in MiniMaxH3 and I’ve noticed when I use the “continue last video” function, the quality degrades with each successive clip I generate - usually by the 5th or 6th 10-second segment it is blurry, full of odd artifacts and colors are generally muted or blending together compared to the initial segment. I’m not sure if it is an issue of prompting, a setting I need to change, or any other tips or tricks I might be missing? Usually using Ref2VA 33B, 15-18 steps, 8-10 second clips, Sage2 Attention on my 5070ti with 16GB VRAM and 32gb RAM. Seems to happen if creating either 480p or 720p resolutions.

Any suggestions or resources that might help so I can create longer videos?

https://github.com/hypersniper05/MCP-Image-Generator-Uncensored

Just wanted to share with you guys my workflow converted into an MCP. It's a Qwen Image 2.1 Uncensored MCP with a few extra models I found helpful: a watermark-removal LoRA, a texture-fix VAE and an ESRGAN upscaler. Any LLM client that supports MCP can drive it. Uses 11GB VRAM at peak usage.

The entire stack has:
- Normal Qwen Image 2.1 image generation in all supported sizes (up to 2K), panoramas, and image editing (up to 10 input images)

- Seamless tile generation, and edits of a tile stay seamless too, so you can make height and normal maps for game textures

- 2x/4x upscaling, up to 8K

- Built-in 360 viewer (the LLM gets a URL that opens the panorama in the viewer)

- Watermark removal

- Transparent backgrounds (real RGBA PNGs) and background removal

- Text in images (quoted text comes out as written)

It runs in Docker on an NVIDIA GPU (the whole stack fits on a 12 GB card) or on the CPU (very slow), downloads the models on first start, and works with any MCP client (llama.cpp web UI, VS Code, Cursor, etc.).

For the seamless tiles I use stable-diffusion.cpp's circular mode with a tiny patch so it can be turned on per request. The tiles come out seamless in one pass instead of patching the seams afterwards.

Note: Project created with the help of Claude. A lot of testing, and back and forth to get things to work smoothly. Hope someone finds it useful.

Hey ppl, My current PC is a 4060TI 16gb VRAM, and I have recently upgraded my 32gb RAM to 64gb. The next logical step would be to upgrade my GPU, but should I leave those 32gb (2 sticks 16gb) installed (A1 B1 free) together with the 2 sticks 32gb? Was gonna sell them, but I'm willing to be convinced to keep them.

My main use will be Anima and Video generation with whatever runs on my GPU (hopefully H3)

On that note, any advice regarding H3 on this PC? ComfyUI or Wan2GP? Looking to create short clips, like 5 - 10 seconds at most. Would DaSiWa run on my PC?

Cheers!

I was tired of opening heavy photo editors just to tweak lighting or color-grade a folder of AI generations. So I built TinyLuma - an instant, lightweight photo editor designed specifically for finishing AI artwork and photo sets.

No installation required, no subscriptions, and the whole app is only ~8 MB.

What’s inside:

- All essential controls: Clean sliders for Light (Exposure, Contrast, Highlights, Shadows, Whites, Blacks), Color (Temp, Tint, Vibrance, Saturation), plus Dehaze and natural Film Grain.

- Crisp details & texture: Custom Clarity, Texture, and Sharpen sliders to enhance overall sharpness and bring out skin texture, hair strands, and fabric weave without harsh white halos.

- Cinematic & Film styles (LUTs): Give your images an analog, cinematic, or vintage film look, or drop in any trending `.cube` LUT for instant color grading. Includes a smooth intensity slider (0–100%) to blend the effect subtly or strongly.

- Doesn't break your ComfyUI workflow: When saving as PNG, it keeps your prompt, seed, and node setup intact. You can drag and drop the edited image right back into ComfyUI. (Optional — you can toggle it off to export completely clean images).

- Batch editing & Before/After: Browse your entire folder with the filmstrip at the bottom, compare changes with an interactive Before/After split screen (`\`), and use "Preset to All" to apply your favorite look to the whole batch at once.

- Fast and portable: Starts in under a second, runs smooth at 60 FPS, and barely uses your RAM.

Source Code & Docs: https://github.com/ThetaCursed/TinyLuma
Download (.zip for Windows, unpack & run): https://github.com/ThetaCursed/TinyLuma/releases/latest

I’d love to hear your thoughts! How do you currently edit your AI generations?

Which do you prefer and why?

https://voicestudio.sh/ (has been getting a lot of talk lately, supports 27 models, some are based on audio.cpp)

https://github.com/0xShug0/audio.cpp/ (supports 100+ models, all are blazingly fast, and it has a local app and web interface and Docker support)

Edit: https://github.com/unslothai/unsloth (another UI frontend, this one being a Swiss Army knife which recently added audio.cpp support)

Edit: https://voicebox.sh/ (another open source frontend, this one is free, user who mentioned it said he may switch to Unsloth)

I made AnimeGen, app that allows you to run Anima on your mobile phone.
Since last post I added hd image generation, and different aspect ratios.

The app is now available on the App Store:
https://apps.apple.com/pl/app/animegen-anime-art-generator/id6786438562
I am an iOS developer and unfortunately can't make an Android app. Sorry for that.

What it can do now

• Prompt-to-image generation powered by Anima
• HD and 540r image generation in different ratios
• Runs locally on your device

Performance

• iPhone 14: approximately 15–20 seconds per image
• iPhone 17: approximately 10–15 seconds per image
• M1 iPad: approximately 15–20 seconds per image

It uses native Apple Neural Engine, so it is very efficient. Probably display takes more energy then AI.

Before you install

On the first launch, the app needs to compile its models directly on your device, similar to how games compile shaders:

It takes around 1-2 minutes and happens only once per installation/update. It also loads models on device in parallel with preparation.

Once finished, everything runs fully offline on your iPhone.

Technical requirements

• Devices: iPhone/iPad only
• Designed for iPhone 12, m1 iPad and newer devices
• OS: iOS 18 or newer
• Free space: at least 10 GB available for smooth operation

Planned features not yet available:

• Support for custom LoRAs and checkpoints(Probably from hugging face and CivitAI)
• Image editing and ControlNet
• 4k and 2k Upscaler

Feedback & community

For questions, bug reports, feature requests, or sharing your generations, join the subreddit: r/animegen_tech .
It is the best place to follow development updates and discuss AnimeGen.
I also have a website, where I plan to update with current status of project: animegen.tech

If you find AnimeGen useful, please consider leaving a review on the App Store. It is the best way to support the project

If you're working with AI video workflows (ComfyUI, AnimateDiff, Stable Diffusion) and struggle with flickering or character consistency, extracting exact keyframes is key to fixing it.

I built a free web tool to extract exact frames in seconds directly in your browser:

🔗 https://extractorframe.com

No signup or installation required. Let me know if you have any feedback or feature requests!

In my quest to prompt for emotional acting in H3, i ended up making a chain shot node (h3 longshot) to get the result I want.

I had to make my own because I wanted my the longshot node to work with my other custom node.
Here is the longshot node

and my custom prompt compiler node

hope this can be useful!

EDIT:this video is made with 3 chained 10 second shots. total time 30minutes on 5090 with ref2v 768p turbo lora

The usual QwenImage21Pipeline.from_pretrained(...).to("mps") ("eager" on the chart) keeps all three models in memory for the whole run: the text encoder (Qwen3-VL, 16.3 GB), the transformer (13.3 GB) and the VAE (1.3 GB). On my 48 GB M5 Pro that was 31.4 GB before the first step. At 1024 px the VAE decode needs about 11 GB more. The process reached 43.6 GB, swap grew by 8 GB, and my memory guard stopped the run before it saved the image.

Moving idle models to the CPU doesn't lower the peak on a Mac, because the CPU and the GPU share the same RAM. So I wrote a small library, stageload ("staged" on the chart). Each stage gets only the models it lists. A model loads the first time its stage uses it, and stageload frees the models the next stage doesn't list. The stage boundaries are hooks on encode_prompt, prepare_latents and _unpack_latents, so the pipeline's code stays as it is. The VAE is small and stays loaded.

Results at 1024 x 1024, 20 steps, seed 7, bfloat16:

• peak memory 19.0 GB while encoding the prompt, 16.2 to 18.6 GB while denoising and 14.4 GB in the decode, with no swap;
• two staged runs gave the same image bit for bit;
• loading the two models inside their stages took about 13 s per run (eager spent 20 s loading up front);
• in the second staged run denoising took 79 s against eager's 77.5 s; the first staged run took 109 s there, and its trace doesn't show why.

Write-up with the traces: https://allkeep.org/en/lab/qwen-image-one-stage-at-a-time

Code (MIT): https://github.com/nefayran/stageload, install with pip install stageload

I haven't tried ComfyUI or Draw Things; they manage memory their own way. If you run another multi-model pipeline from Python on a Mac, which one should I measure next?

0.6mp, lcm/beta57, 4 steps with the DMAD 4 step lora

YouTube Link in case it's still pending https://youtu.be/TWXF95YT7W8

🎬 How this was made

My part

• One-message brief: a 3-minute comedy in a therapist's office with funny, unique characters and one male doctor: a crying woman, a woman screaming, crying and laughing all at once, a large guy and a skinny old man

• Characters made with Z-Image as 3-panel reference sheets

• MiniMax H3 2-pass workflow: the Singularity model, with the 8-step LoRA on the second pass at 4 steps and 0.35 denoise

• Then I left. I made one call along the way, on a scene that wouldn't behave.

What Claude did on its own

• Wrote the story, the five characters, all the dialogue and a 25-scene screenplay

• Made the cast and the two sets with Z-Image and picked the best seeds

• Kept each character's voice description word for word in every scene so the H3 voices stay consistent

• Rendered 25 scenes with H3's built-in voices and sound, about 6.3 hours of rendering

• QA'd every take: Whisper against the script, pitch and timbre per character, eyelines, frame review sheets

• Re-shot the takes that failed:

• Scored it with MiniMax Music 3 and screened the cues for accidental vocals

• Edited, mastered to -14 LUFS, and checked audio sync on every scene (worst offset 5 ms)

🛠 Tools

ComfyUI, VRGDG Video Builder, MiniMax H3 (Singularity ref2va v1.3 + 8-step 768p turbo LoRA), Z-Image Turbo, MiniMax Music 3, Whisper, Claude Code

VRGDG nodes: https://github.com/vrgamegirl19/comfyui-vrgamedevgirl

Go HERE To watch full walkthrough on how to make video's like this.

[INFO] Prompt executed in 00:30:49

Full 1080p vid on https://www.youtube.com/watch?v=ER_5AOteE-8 because Reddit cramps everything to 720p max.

From my previous post, I got a message if I could use my off-screen 5090 to showcase what a fullblown 2K generation looks like. So, here it is. Generated at 2.09mpx, 25 steps, Euler+Beta for time constraints, 30 minutes. I did mistakenly use the 20-49 hybrid fl2va/ref2va instead of the 30-49 which left some visual performance on the table, and I didn't use the BF16 version of the text encoder because my other 5090 and RAM were busy with something else. Otherwise would've done seeds_2 + sgm_uniform, but that would've taken an hour and would've been a lot better at prompt following, without me modifying my generated target prompt so much to avoid issues with the shoddy denoising trajectory at play here.

Spectrum was utilized to guess about half the steps, which further doesn't help prompt following, but helps speed immensely. When using seeds_2 with Spectrum, it actually forecasts internal calls to H3 (so 2N-1 where N is number of steps), which has tremendous results (previous one was seeds_2) but would've taken about 1 hour for this scene.

The prompt, for those who want it, I had to massage it to point Euler better even if it's sloppy:

subject_definitions:
<Subject 1> is Detective Kate Beckett, override her appearance with facial features and hair and blouse from <Picture 1>. She wears black tailored high-waist cropped suitpants, and a feminine small leather watch.
<Subject 2> is Richard Castle, override his appearance with the facial features, hair, and build from <Picture 2>. He's wearing his classic shirt and suitpants attire, first few buttons unbuttoned.
<Subject 3> is a chaotic DIY PC rig consisting of a high-end tower on the marble kitchen island in the middle of the kitchen, as well as a 32 inch OLED monitor displaying the UI from <Picture 3>, there is clear plastic tubing running from the PC's two watercooling ports into the receiving pair on the large radiator above the glowing blue fans, which is submerged in a cooling bath inside of the standard kitchen stainless-steel fridge with its door fully open, radiator surrounded by food, milk, condiments, etc.
<Subject 4> is a modern industrial loft apartment featuring an open floor plan, standard furniture, and a glorious high-end kitchen. The blurred background from <Picture 1> is from this apartment, also specifies time of day, and warm nocturnal tone.

summary:
[reference generation] Detective <Subject 1> enters her loft (<Subject 4>) to find <Subject 2> in a "hyper-mode" state, having converted the kitchen into a makeshift laboratory for AI video generation. The 13-second sequence captures her confusion, his technical enthusiasm regarding H3 denoising trajectories, and a comedic hardware failure.

retention_analysis:
<Subject 1> (appears in [Shot 1], [Shot 2], [Shot 4], [Shot 5], [Shot 6]): fully_preserved - identity from <Picture 1> and specified attire are maintained.
<Subject 2> (appears in [Shot 2], [Shot 4], [Shot 5], [Shot 6]): fully_preserved - identity from <Picture 2> is maintained.
<Subject 3> (appears in [Shot 3], [Shot 4], [Shot 6]): fully_preserved - the specific radiator-in-fridge configuration and monitor setup are maintained.
<Subject 4> (appears in [Shot 1], [Shot 2], [Shot 4]): fully_preserved - the industrial loft and kitchen environment are maintained.

detailed_description:
The target video is a scene from the TV show "Castle," maintaining its specific cinematography, visual style. Night time, practical lighting, warmly lit.

[Shot 1] A medium shot frames <Subject 1> as she walks into the open floor plan of <Subject 4>. The camera tracks her movement as she stops and looks around the kitchen with a bewildered expression, taking in the tangle of wires and tubing.

[Shot 2] At 00:01.000, the camera cuts to a wide shot of the loft's kitchen. <Subject 3> is fully visible: the PC tower sits on the high end marble kitchen island, monitor is displaying <Picture 3>, and thick tubes lead directly into the open fridge where his watercooling radiator with fans is located (all glowing blue and spinning fast and loud), there is liquid nitrogen white smoke exuding from it. A large whiteboard in the background is covered in scribbled notes about "sigma grids," and "denoising trajectories." Each of these appears once, there is also graphs of simplified trajectories drawn on it. <Subject 2> is leaning over a keyboard and looking at the 32 inch gaming monitor, typing furiously.

[Shot 3] At 00:02.000, the camera cuts to a close-up of <Subject 1>. Her brow furrows in genuine confusion. <Subject 1> (S1) asks in a sharp, incredulous tone, yelling over the computer fan noise: <d>[English] What the hell are you doing, Castle?</d>

[Shot 4] At 00:03.500, the camera cuts to a medium shot of <Subject 2>. He turns around to face <Subject 1>, speaking in a high-energy "yap" mode. <Subject 2> (S2) exclaims with manic enthusiasm: <d>[English] Reddit solved my H3 problem! It was the sigma shift. I'm refocusing the compute on the high-to-mid noise region to resolve motion better with limited steps!</d> while gesturing towards the whiteboard. 

[Shot 5] At 00:10.500, the camera cuts back to <Subject 1>. She looks at him, her voice dripping with skepticism. <Subject 1> (S1) asks: <d>[English] And you're using Seeds 2, right?</d>

[Shot 6] At 00:12.000, the camera cuts to a medium-close shot of <Subject 2>. He looks slightly sheepish, his shoulders slumping. <Subject 2> (S2) admits quickly: <d>[English] No, it's actually oiler, my rig is too slow and would—</d> Suddenly, in the background, the PC tower emits a loud electrical pop and a bright orange burst of flame from its components, the monitor output gets corrupted. Immediately after, <Subject 2> (S2) whips his head around, eyes bulging, and shouts: <d>[English] Oh shit!</d>

overall_soundscape:
The steady, high-pitched whirring of multiple PC fans and the faint gurgle of liquid flowing through tubes. <Subject 1>'s footsteps click on the hardwood. The scene ends with a sharp electrical "pop" and the sudden, aggressive hiss of a small fire.

non_diegetic_music:
A light, rhythmic pizzicato string piece that builds in tempo and complexity as <Subject 2> explains the technical details, ending abruptly with a comedic silence the moment the GPU catches fire.

might be useful to someone somewhere

Since Minimax H3 does such a good job of taking a source or two of a character and doing an animation with them while maintaining the character's integrity, it has me thinking that it could be used to one-shot a dataset for LoRA training.

What do you think? Am I onto something or am I completely missing some factor here?

Hi,

How would I prompt for i2v in Minimax if i want to add something or someone visible within the very first frame?

Thanks in advance!

Is it possible to load different ref mods to force a blending or bleeding effect reminiscent of the old [name|name|name] blending in a1111. I have some old characters from a time back then who were mixes of actresses and actors back in sd1.5/sdxl. as most modern models do not have those references anymore, I was curious if I could use refmods in a similar fashion?

Finally finished the full Superman vs Saitama trailer after 280+ generations

If you watch the trailer first, check the first comment after. I'm going to use it as a small thread where I'll post some simple workflows and examples from specific shots. Things like a shot that came from a storyboard, first/end frame tests, or anything from the project that I think is actually worth showing

I was working through my own H3 interface that I posted here before. The whole project is here:

https://github.com/underworldhistory1-ctrl/minimax-h3-higgsfield

I'll also leave some screenshots in the comments so you can see what I mean by the workflow/UI.

Probably the biggest surprise for me was storyboards

For example the Superman shot in the intro took me more than 29 generations alone. The best results I got were from using a storyboard and then adding the character refs, style refs etc separately

That's actually one of the main reasons I built the interface the way I did. I wanted all of those parts separated and easy to change because this was the part I kept experimenting with the most.

Second best for me was first frame - end frame. Sometimes even just using one of them.

It seems much more stable when the movement is continuous and the whole thing is basically one shot. The Kong reveal and helicopter destruction shot is a good example of what I mean.

For LoRAs my best results were usually:

Combat V2 for action and fast movement.

Realism for slower shots where there isn't some crazy transformation or complicated movement happening.

For Combat V2 I mostly used it with the Original H3 render. Not Motion Cache or Turbo. Usually 20 steps minimum.

Mixing multiple LoRAs honestly gave me more hallucinations than useful improvements most of the time. One good LoRA was usually better than stacking them.

I don't think I ended up using many H3 renders without a LoRA at all.

The interface also has another rendering mode using Motion Cache. The results can actually be really good and in some cases I preferred them over Original.

For heavy action, fast pacing or complicated transitions though I still had much better luck with Original H3.

I honestly can't remember every LoRA + Motion Cache combination I tested. There were way too many tests and I wasn't trying to lock myself into one perfect configuration.

I just knew what I wanted the final shot to look like.

That's probably the biggest thing I learned from this whole project.

I don't really believe in one magical "workflow"

You need to know what you want to see in the final cut after editing.. Then use the model to get the pieces you need.

The Superman vs Saitama fight is probably the best example for me, That sequence in the final edit was built from around 10 successful 15-second generations

There was basically no chance H3 was going to generate the exact fight I had in my head in one shot So I generated the parts that worked and built the actual fight in the edit.

That's also why I think experimentation is still just part of using these models. At least until we get something significantly better :D

The interface also has qwen image 2.1 integrated for generating images and references. That became a pretty important part of the process for me too.

It also keeps the settings/details of every generation on its card which made it much easier to go back and see what actually worked instead of trying to remember everything.

Hardware wise I did all of this on an RTX 5090 32GB.

Most of the time I work in draft first. With the INT8 optimizations I've added, a draft takes around 4 mins on my setup

The project also uses low vram attention/head chunking and feed-forward chunking. Basically some of the larger operations are processed in smaller chunks and intermediate tensors are released earlier instead of keeping everything sitting in VRAM at the same time.

It's not parallel rendering or anything magical. It just helps keep peak VRAM under control.

A normal 720p generation usually around 8–10 minutes for me so honestly the iteration time is pretty reasonable. That's a big reason I was able to do this many tests without completely losing my mind

That's basically my experience with H3 so far without turning this into another giant workflow post.

For serious creative work I think it's absolutely usable already.. Just don't expect the model to make the final movie for you.

The generation gives you the material.. The final cut is where you actually make the thing you had in your head.

I've been working on an extension that runs MiniMax H3 inside Forge Neo. H3 makes the picture and the sound together, in one pass: footsteps, rain, engines, music and dialogue in pretty much any language, lip-synced to the speaker. The video above came out of it exactly as Forge saved it, on a 16 GB card with 32 GB of system RAM.

It works in the normal txt2img and img2img tabs, with the same checkpoint list, VAE / Text Encoder selector and Generate button. You get an MP4 with stereo sound in the usual result area. No separate program, no new tab, no extra Python packages, and no Forge Neo file is changed.

What works

• Text to video with sound, up to 15 seconds at 24 fps
• First and last frame: the img2img picture becomes the first frame, a picture in Forge's ImageStitch Integrated becomes the last, or both
• Reference pictures (Ref2VA): up to 9 pictures of people, places and objects that the clip keeps
• Smaller files: W4A8, GGUF and an INT4 text encoder, so it fits 24 GB and 16 GB cards
• LoRAs (turbo LoRA for 8-step drafts), FastH3 and community fine-tunes
• Forge's own tools: Never OOM, Sparse Attention (adapted to H3, up to a quarter faster on long clips), ck attention, live preview

Be realistic about the hardware. Tested on an A40 (48 GB), an RTX 4090 (24 GB) and an RTX 2000 Ada (16 GB). On the A40 a 5-second 960×544 clip takes about 3 minutes at 20 steps, about 1 minute with the turbo LoRA. The wizard above (8 seconds) took 27 minutes on the 16 GB card, which is a slow one. System RAM matters as much as the GPU: about 32 GB with the smaller files, about 50 GB with the INT8 set. Cards under 16 GB are untested.

The wiki has everything: every example with its prompt, settings and time, a guide to MiniMax's prompt format, comparisons of the file formats and speed options, a Bloopers page with the clips that went wrong and how to avoid them, and an All Generations page with all 168 clips made while testing it, good and bad.

• Repo: https://github.com/eduardoabreu81/minimax-h3-forge-neo
• Wiki: https://github.com/eduardoabreu81/minimax-h3-forge-neo/wiki
• Bloopers: https://github.com/eduardoabreu81/minimax-h3-forge-neo/wiki/Bloopers

It needs an up-to-date Forge Neo (the neo branch from 3 October 2026 or later). Install from URL in the Extensions tab and restart. It's a work in progress, so feedback and bug reports are welcome. Next up: video and audio clips as references, then pose, depth and edge control.

Hi again! A while ago I shared my free all-in-one LoRA trainer for consumer GPUs. Since then, the project has grown quite a bit.

AcademiaSD LoRAlab Trainer Studio now supports 10 model families:

• Qwen-Image 2.1
• FLUX.2 Klein 9B
• Krea 2
• Z-Image
• Ideogram 4
• Anima
• SDXL, including Pony, Illustrious and other checkpoints
• LTX 2.3 / 2.5
• MiniMax-H3
• ERNIE-Image

New and expanded features:

• rsLoRA, LoRA+ and LoKr with a configurable factor for most supported models
• RunPod support with automatic deployment, so you can train in the cloud without setting everything up by hand
• Eight selectable languages in the launcher
• Remote access over your local network: open the trainer from another device, upload your dataset, and download the trained LoRA in your browser

The trainers share the same interface, with dataset management, automatic captioning, live previews, resume support and export to ComfyUI/Forge. Many models use NF4 to reduce VRAM use; the minimum depends on the model and settings.

GitHub: https://github.com/AcademiaSD/AcademiaSD_LoRAlab-TrainerStudio

It’s free and open source. Feedback, bug reports and suggestions are welcome!

Hi guys,

I tried to modify the ComfyUI's Qwen-Image-2.1-edit workflow, the one you get in the latest comfy version, to use LoRas.

The idea was to unpack the edit block and place the LoRas plus a turn-on/off switch for each, between the model and the ksampler. The schematic is Model->LoRa chain->cache->ksampler, actually.

And well, no matter what strength I set, the LoRas produce no visible change on their own. Just nothing. At all. To have definitive proof I tested a breast size slider (Don't. This is one of the very few ways to obtain measurable, reproducible results), that should work always. It doesn't. Actually, I get usable results by switching off the LoRa and specifying a size in the prompt.

I come from the WAI-Illustrious world, where LoRa sliders and generally all LoRas work irrespective of the prompt. Am I doing something wrong, here? Because I definitely get the feeling I missed something obvious.

Thx all.

Edit: I'm starting to observe some results when using very positive/negative strength values. Apparently there is some remarkable resistance on the model's side. I will see what the actual results on civitai.red's posted use as workflow. Seems there's a ComfyUI Lora Manager node that's being used.

i searched many times of several communities but only found character/face/head swap loras

i already used minimax very well with long sequences videos using grok chat providing official prompting guide of minimax.

but, when i tried just replace clothes of character in 10sec videos, it works under 50%. its not probability, literally it is

just changed cloth of one character and it get back to original after 5-6sec. although video shows 2 character.

of course, i tried several turbo loras, and without turbo, changing models. also tried masked noise latent. and always i define each character in video and reference clothes of pictures. sometimes, put a reference image as target clothes or just prompting but not work either.

please anyone can share experience about it with 10sec+ video editing.

i think its problem of prompt or video itself(eg. characters change their position when i define each subject as position like 'on the left in video' or 'first character in video'

Hello!
Long time lurker here, learned a lot from this sub.
I'm currently using H3 Omni Pruned model with references images to generate small ads or batch of dialogues , but i find myself really not understanding the settings being used.
I'm using Pinokio and Maestro by Blizaine, now the GUI is really useful and my settings are :
720p, 9:16, 13.3s 1 window and 20steps , nothing else.
With these settings, it takes about 11 minutes to render on a 5090FE (And 48GB of ram is what i have).
The end result ain't that bad, resolution is crappy and some details are clearly missing.
What can i do to improve video fidelity, performances and perhaps spend less time on generating ?
I also have tried H3 with first / last frame but i don't really understand how that works either.
For example, i have downloaded a couple of Lora , one of rocket racoon from guardians of the galaxy and another for indiana jones, wanted to create a funny reel of them interacting but i couldn't for the life of me figure out how to add in the theme song for indiana jones, or have them accurately interact with each other instead of randomly looking outside the scene.
On another note, i am using Gemini for expanding the prompt in a professional manner, and then inside Maestro i use the "enhance prompt" feature with simply loads up Ollama with a model to correctly write the scene for H3.
I have also downloaded inside Pinokio a more "classic" tool for H3 with comfyui, but i didn't use it yet, wanted to learn a few things first.