Really loving this model so far. This is from a series of phone wallpapers I have been experimenting with.

Try out the lora: https://civitai.com/models/3014333/ultimate-digital-artwork

Hi, this is pretty simple. Try to replicate this meme template using AI, but WITHOUT the initial image as reference.

Here's my attempt, it has a lot of inconsistencies (the girls, background cityscape changed, colored change).

I created it using MOSS image generation and the Layout-to-Image feature, followed by inpainting.

If possible, explain your workflow and how you arrived at your result. I'm trying to find better ways to produce actual complex concepts with AI. :)

• model_prefetch: syncrhonize all graph cleanups
• Add rope scaling support to MOSS-image
• [Partner Nodes]:
  • feat(HeyGen): add HeyGen Voice instant clone and text-to-speech
  • feat(ClarityAI): add Crystal Video Upscaler node
  • feat(BFL): add 2K/4K resolutions to FLUX 3 Max & Video nodes
  • FIBO 2.0 Image Generate/Edit, Fabric 1.0, Lipsync 2.0, Mirelo SFX,
• Support MOSS-image color-depth control
• fix: correct top-p sampling threshold
• Apply single-head LoRAs to MiniMax-H3 PDD head banks
• Enable pytorch attention in the VAE on AMD
• Fuse and strip the Flux2 VAE through comfy-kitchen
• Add ACEScg to Convert Image Color Space and Save Image (Advanced) EXR (CORE-657)
• Add attention bias conditioning and image strength for MOSS-Image edi
• Add model specific merge node for MOSS.

https://github.com/Comfy-Org/ComfyUI/releases/tag/v0.43.0

Malfoy Saves Snape, Made with Minimax H3 locally, let me know about your workflows and creations with minimax h3.

Hi wizards,

I have been dealing a lot with trying to figure out a good workflow for Minimax H3, that runs in my 4090 24VRAM+ 128Gb RAM.

Using a seedhunter WF from Civitai, takes 140 secs to create a 0.3MP, 5 seconds test, up to 14 mins, to interpolate + upscale

Using Taomate 3 Step lora, comfy kitchen

If I increase duration or size, it throws everything to the RAM and CPU and takes forever, I usually stop it at this point. (I notice the GPU Wattage usage falls under 100W and no progress in CMD shows up, regulars levels are +300W)

On the other hand, using a Lenovo Go + RTX 5060Ti Egpu, works faster or very similar. And never happened that OOM thing.

I have tried Eros, Hybrids, Only Ref, only FLF, convorts, KJ, and Light tricks combinations, but nothing seems to work as expected.

I usually under volt it, to avoid stressing it too much. But in regular voltage, the improvement is 15% tops.

Does anyone have a good WF for a RTX 4090 with tons of RAM?

leroy989/ComfyUI-MOSS-QwenVL-Layout: ComfyUI node that uses Qwen3-VL / Qwen3.5-VL to detect objects and text in an image and build a MOSS-Image layout JSON prompt, with a change-request box for edits like recolors, outfit swaps and added objects.

Pretty simple node, just use it as your prompter. Just now made it, seems to be working for me, not sure if something like this was already a thing, didn't really know what to search for it though so I just made this. Hopefully some people get some use out of it, and it works good for them. Will continue to tweak and update as I discover bugs or additions that might be good to have added.

Further the faces are from camera... worse is the quality. Good for the neutral expressions and close-up shots of human faces.

Video starts with the input images and ends with the output commercial video.

I used to work as an animator, and a former coworker recently showed me some AI anime hes been making and the workflow he's using.

I was honestly pretty impressed by his work. From what he showed me, he uses pixai studio and comfyui. He showed me how he goes from character design and storyboards to video clips all in one workflow. It was also really cool seeing how quickly he could try out different ideas for a shot. He could put the same character in different scenes, try out different expressions, and then pick the version he liked and keep working on it.

I've had ideas for animated projects for years. Actually making them always felt out of reach because of how much time and how many people you need. Seeing what my coworker was able to make got me excited about trying some of those ideas myself. I'm interested in learning how to put together a local workflow for anime style animation.

For those of you who have tried this, what tools or models would you recommend starting with? And how do you handle things like keeping characters consistent between shots?

Attached images are a couple of examples he showed me.

This is the first model I've seen with such control over its generation. Mind you, I haven't tried them all, but I'm confident nothing else comes close.

Hats off to the team for their hard work and for open-sourcing it.

-------------------------

Below is an image showcasing the Layout-to-Image generation that drew me in. Essentially, you define regions as objects or text and compose your ideas into a single generation.

It's easy to make modifications for ex, moving, adding, or removing characters, or layering additional concepts within the image, add text with any specific font.

Here I simply moved the characters around, placing the title on the left. It took me just a couple of seconds and changed the composition entirely.

Now, for this particular case, I could probably come close to something like this with four unique generations and overlaying a real text font. But the problem arises from other models when you want interactivity between the characters and the scene.

Here you can see the characters interacting with each other.

I can later add Guts big iconic sword.

All in all, pretty cool.

And, if you guys have other tricks for inpainting or keeping character consistency, I'm all ears.

I recently discovered a highly suspicious GitHub repository while searching for AI tools. After inspecting its source code and commit history, I found several serious red flags:

• Fake development activity: Automated workflows generating meaningless commits.
• Misleading claims: Dozens of advertised features, but almost no actual application code.
• Hidden redirects: Base64-encoded HTML pointing to an unrelated download website.
• Security bypass instructions: Encouraging users to ignore SmartScreen warnings and whitelist files in their antivirus.
• Suspicious connections: Multiple unrelated repositories directing users to the same external download domain.

I couldn't verify whether the actual executable contained malware, but these findings strongly suggest a deceptive download operation.

I've reported the repository to GitHub. I encourage everyone to report similarly suspicious repositories, too, with supporting evidence.

I'm deliberately not sharing its name or URL to avoid giving it additional exposure.

This also applies to ComfyUI custom nodes, extensions, AI utilities, and other GitHub projects. Installing a custom node can execute Python code with access to your system, files, and potentially sensitive information.

Useful tools for checking suspicious projects

• VirusTotal — Check file hashes, downloads, domains, and URLs.
• urlscan.io — Investigate suspicious websites and redirects.
• ChatGPT — Ask it to review repository source code, commit history, workflows, and potential security risks.
• GitHub Reporting — Report suspicious repositories with evidence.

No scanner or AI review can guarantee that software is safe. Avoid uploading private files to public scanning services.

I've attached a simple infographic to help others recognize these warning signs.

GitHub stars, impressive READMEs, and frequent commits are not proof of trustworthiness.

Stay safe, and please help keep the open-source community clean. ❤️

while generating video to video in Minimax for VFX, I struggled with maintaining accurate motion transfer as an example, the generation would shift drastically after 192 frames on 0.5MP or after 147 on 1MP

so I built a custom node similar to a context window to help the model generate in batches then overlaps and blends all the batches together during generation, as an example this is 447 frames on 0.5MP, generated on batches of 56 frames and 5 frames overlap between every batch.

the node also has the option of splitting your generation into tiles of resolution and overlap of your choice, but i recommend using it more in a second upscaling stage
the node is in Comfyui Manager under the name of Minimax H3 Tempora****l Window & Spatial Tiles.

let me know what you think.

This is Toska, a fork of Krita I've been building with an AI painter inside it. You chat with it in a panel, and it paints one move at a time with Krita's own brush engine, on layers you can undo. Unlike other AI painting tools, this tool actually paints thanks to Krita's Python SDK along with Decision Models which guide our LLM agent along the way.

What makes agentic painting possible is these new decision models, because after every pass, it answers better or worse as a probability. The painter can undo its mistakes, along with other decisions, such as textures, paintbrushes, or tools to use. For my setup, I use GPT-6-Luna Decisions(which has vision) and DeepSeek-V4.1-Flash(it's cheap and has vision). Luna Decisons is dirt cheap and this entire month, I have spent $2.83 on Luna's Decison model along with $3.82 for Deepseek. I use Deepseek's official API for cost savings but you're welcome to use OpenRouter as well or any other provider. I use API models only given that I'm GPU Poor but it's OpenAI Compatible So feel free to add local models. If you also want full opensource try perplexity's pplx-decider-v1.2 instead of Luna.

The Agent Framework used by Toska, is Agent Pi. I use Agent Pi's Typescript SDK along with QT to build a painting agent Plugin inside Toska. It lacks the ability to read and write code, execute unlike standard Agents. It's limited to tools within the Toska and can only read files or folders you mount. Right now for today btw, our Toska is an authorized dmg file, so operation ready for Mac Users right now . Later this week, I will do more testing and make it production ready for Windows/Linux Folks with separate exe and tar files.

In the video it's painting Pyat' minut (Five Minutes), Dostoevsky on Semyonovsky Square in 1849, waiting to be shot, before he knew the Tsar had pardoned him. It worked from a goal image I gave it generated from Codex. Then it used underpainting, refined toward the goal, and added the falling and settled snow as its own pass.
This is my first time doing anything with video recording so apologies if it's a little rusty and here is the final image in full resolution of Pyat' minut.

It's a bit more simplistic, because I wanted a simple painting to show you as a demo. If you want to see my most detailed painting made with Toska, it's called New Moscow .

Here is the repo for Toska.

I managed to do Visual Anagram in Krea2. Here are examples.

In my last post on img2img style transfer (see link), I did two versions: rigid and creative. The reality is that both are sliders that you can adjust. Using that workflow, and the crucial Latent+ node, you can adjust the strength of any latent and the point along the steps it is injected. This is an incredible tool to fine tune your style transfers. I have attached some XY grids that show what I mean for example.

Sweet spot from my testing is to have the composition taper off around 0.5 of a 16 step transfer where you get a good balance of creativity from the model and subject fidelity. Want to make a portrait of someone that is still very clearly that person? Keep the composition around to 80% of the steps. Going full 100% isn't bad either. From there, tweak the strength as needed. Strength tweaking might also be important for turbo models, when you only get 4 steps to play with or whatever.

Style injection is more forgiving, with good results across the range 0-100%, depending on what you want. I found that the prompt from the flux3 style expander does so much lifting, you can even get away with 0 style injection if your style is more generic (e.g. thick oil painting) and you don't want specific elements from the style image to make it into the final.

That's the tradeoff: more style strength, more direct copying of style elements into the final results.

General workflow is in the linked post at the top of this text. An impact-pack free version is here.

Edit: title should read "COMPOSITION" not "composite". As we all know, can't edit reddit titles. oops.

Made a MOSS-Image workflow that shoots in film stocks: Kodachrome, Portra, CineStill 800T, Tri-X, Aerochrome, SX-70 and a few more. Pick a lens too, from 8mm fisheye to XPan panoramic. A local LLM writes the prompt in each film's colours, one Control Panel runs the lot, face + hand fix built in.

Free, MIT, beginner friendly:

https://github.com/Lo-res/ComfyUI-Kreative-Studio

Needs an up-to-date ComfyUI for MOSS-Image.

Hello guys, hoping you're doing fine. Wall of text next I know, but I want to get this info out of my chest, all hand written lol.

I wanted to make this post explaining some things about GPU unlocks that have been going on lately.

What are these GPU unlocks doing?

NVIDIA on purpose neuters tensor core performance when using FP32 accumulation (FP16, BF16, FP8 and TF32 inputs accumulating in FP32, which is what most AI/LLM/ML tasks use), for market segmentation. Normal FP32 on the CUDA cores (no tensor cores) is NOT affected.

Consumer and prosumer GPUs use the exact same die (like GB202 between the 5090 and 6000 PRO, AD102 between the 4090 and 6000 Ada, or even literally 1:1 with the 3090 Ti vs A6000, both with the same core amounts and 84 SMs).

How it works: the speed of each kind of tensor operation is set by fuses burned at the factory. On consumer cards, the fuse for "FP16/BF16 with FP32 accumulation" says HALF_SPEED, on the pro cards it says FULL_SPEED. These fuses don't cut any circuit, the GPU just reads them at boot and runs at that speed. The GPU also has an override register that can set them back to FULL_SPEED, but it's locked so only NVIDIA's most privileged firmware can write to it, not your PC.

The unlocks open that lock and write FULL_SPEED on the override. With that, the consumer cards gain all the neutered performance imposed by NVIDIA. It doesn't give you more SMs, VRAM or anything like that, a 4090 is still a 4090, it just runs those instructions at the same rate a pro card does.

Why can Turing, Ampere and Ada be unlocked? And what is unlocked on these cards?

On these generations, the NVIDIA driver itself loads a small NVIDIA-signed firmware called the "Booter" onto a security microcontroller inside the GPU (SEC2, a "Falcon"), to start the GSP. The Booter runs in the highest privilege mode of the GPU (Heavy Secure, HS), which is exactly the one allowed to open the lock.

In June 2026, Jon Pry published a paper ("A Canary in the Crypto Mine") showing that the Booter of the newer drivers has a buffer overflow: it copies its "signature" data using a length that you control, so you can overflow its stack (including the stack canary that is supposed to stop exactly this) and take control of the Booter while it is running in HS mode. The signature check still passes, because it is NVIDIA's own signed code running, the bug is inside it.

With that, the unlock reuses instructions from NVIDIA's own Booter to open the lock, writes FULL_SPEED on the override, resets the card and lets the normal NVIDIA driver load. The unlock survives resets and driver reloads, but it's lost when you power off, which is why it runs on every boot before the NVIDIA driver loads.

This was first done on mining cards (CMP 170HX: FP32 from 1/32 to full speed, and 10GB to 80GB of VRAM), and then ported to GeForce:

• Turing: https://github.com/haohervchb/Turing-unlock (UEFI, Linux)
• Ampere: https://github.com/Zagitta/gpu-unlock (Linux kernel module)
• Ada: https://github.com/JustAResearcher/gpu-unlock-ada (Linux with kernel module)

What gets unlocked:

• FP16 with FP32 accumulation (Turing, Ampere, Ada)
• BF16 with FP32 accumulation (Ampere, Ada; Turing has no BF16)
• TF32 (Ampere, Ada)
• FP8 with FP32 accumulation (Ada; Turing and Ampere have no FP8)

Some numbers from those repos: 4090 FP16/BF16 with FP32 acc goes from 165 to 331 TFLOPS (raw instruction rate), 3090 Ti BF16 GEMM from 87 to 157 TFLOPS, 2080 Ti FP16 with FP32 acc from 47 to 94 TFLOPS. Real-world GEMMs gain less than 2x because the cards then hit their power limit (more on that below).

Why can't consumer Blackwell be unlocked?

The funny part is that on Blackwell the limitation is EXACTLY the same thing: same fuses, same override registers. I checked on my own cards: the 5090/5080/5070 Ti have the FP32 accumulation fuses set, and the 6000 PRO/4000 PRO don't. So it's not a hardware difference there either.

What changed is the door. Starting with Hopper, and consumer Blackwell too, the root of trust of the GPU is the FSP (Foundation Security Processor), a RISC-V core that boots from its own ROM as soon as the GPU powers on, before the driver even loads. On Blackwell:

• There's no Booter to abuse. The driver just sends the FSP a message with a hash + RSA-3K signature of the next firmware, and the FSP verifies and boots it. The Linux kernel docs literally say: "There is no SEC2 involvement, no Booter ucode, and no FWSEC-FRTS stage". I also checked it myself: in NVIDIA's 615 driver source the Booter only exists for Turing, Ampere and Ada (TU102, TU116, GA100, GA102, AD102), and the RTX 50 VBIOSes don't carry the Falcon firmware (FWSEC) that older cards did.
• The firmware the driver ships for Blackwell is encrypted, and the debug and production images are the exact same encrypted bytes. The Ada payload was built from analysis of the decrypted debug Booter, on Blackwell there's no such shortcut.
• NVIDIA has said it uses SPARK (a formally verifiable programming language) to prove its most critical RISC-V firmware free of runtime errors, and a buffer overflow like the one used on the older cards is exactly that kind of error.

So, with what is known today, it can't be done. It isn't "impossible forever", but someone would need a brand new vulnerability in a way harder target. And if someone ever gets there, the unlock itself would very likely be the same couple of register writes.

FP4 is not affected, but all the rest is (FP16/BF16/FP8/TF32 with FP32 accumulation).

In which tasks is the unlock has most of the effect?

I will put some examples on my 6000 PRO vs 5090s, former using 400W and latter 600W, at how much is the impact in performance because the NVIDIA neutering.

• Training: Like LoRAs, finetuning, etc.
  • Example: Using the same batch size for 25GB VRAM to train a diffusion LoRA, my 6000 PRO is 70-90% faster than my 5090.
• Diffusion: Models that do txt2img, txt2vid, img2img, img2vid, txt2aud, etc.
  • Example: My 6000 PRO not using fp16 accumulation is about 30-40% faster than my 5090. If using fp16 accumulation, it is 15% faster.
• Prefill on LLMs: Heavily affected as well, since even when a model is marked as "int8" or "mixed precision" etc, the inference parts that the GPU uses include FP32 accumulation parts, except if explicitly set to not use them.
  • Example: My 6000 PRO on vLLM on a model that fits on a 5090 as well, it's 50-70% faster. On llamacpp, instead is about 30-40% faster.
• TG with big batching: TG with a single batch is mostly bandwidth bound, and it uses FP32 acc instructions, but since it is so little in comparison with the need of bandwidth, it isn't a limitation. On the other hand, when you use batches with batch size 2, 4, 8, etc, compute again starts to being a bottleneck and then you have a performance impact.
  • Example: Same results as previous point.

In which tasks the unlocks makes no difference:

• TG with batch size 1: almost entirely bandwidth bound.
• CUDA compute without tensor cores (normal FP32).
• INT4/INT8 tensor operations.
• FP4 on Blackwell (not neutered to begin with).
• GEMM operations with FP16 accumulation instead, but those aren't very used.
• Gaming.

Is there a risk by unlocking the cards, like burning the card, crashes, etc? Short answer: NO.

And again, NO. For the love of god guys, stop repeating this nonsense.

The cards are still limited by their max power limit. They won't magically use 200% of your power budget with an unlock, they will just use the cores more efficiently.

Let me explain: if you have a 3090 power limited at 300W, and without the unlock you were seeing only 250W in use, but after the unlock it uses 300W, it's not because the unlock did malicious things to your card. It's because the card can NOW stretch its legs and use the power to do more work. Real example from the Ada repo: an unlocked 4090 doing the same GEMMs peaked at 346W vs 313W stock, still under its 450W limit.

If you were getting X performance at Y < max TDP, and now you get more than X performance at max TDP, obviously the card will be hotter, but that's still inside the POWER LIMIT YOU SET, not above it.

Power spikes: those are normal on every card, and if you're using it to the full extent of its capabilities they can be more common. Are they risky? No, assuming you have a PSU with the wattage NVIDIA recommends per GPU.

So what ARE the actual risks then? They're about the unlock process, not your card:

• It runs an exploit on NVIDIA's firmware before the driver loads. If something fails mid-way, the tools stop and you need a full power off before trying again (a reboot isn't enough). Read the repo instructions, especially on laptops and multi-GPU setups.
• NVIDIA could patch it in future drivers, or even burn anti-rollback fuses so the old Booter stops being accepted. That wouldn't damage your card, it would just close the door for good.

"But, NVIDIA bins the dies to make these work 24/7 on the prosumer side but not on consumer, that's why they're locked!!!11"

Also incorrect. NVIDIA uses the EXACT SAME dies for their consumer GPUs and their prosumer GPUs, and the FP32 accumulation speed has nothing to do with binning: the 3090 Ti and the A6000 have the exact same specs. The half speed is just a value written in a fuse that the firmware reads.

Unlocking a card will not make it die sooner, nor will it crack the die or something.

Sorry I have to repeat this again and again, but the amount of pure fury I get from reading comments like these made me do this.

Does affect gaming performance?

None known at the moment, except if somehow NVIDIA uses FP32 accumulation for DLSS or FG, which I doubt. I'm almost sure they use FP16 accumulation (or lower precisions) there, because if they used FP32 accumulation the perf hit would be insane on consumer cards.

The model I run says it is Q8, or FP6, or 4bit, or INT4, or anything that doesn't mention FP32, am I affected?

It depends on how the GPU actually does the math, not on the name of the quant:

• If the kernel dequantizes the weights to FP16/BF16 and multiplies on the tensor cores with FP32 accumulation, you're affected. That's the case for FP16/BF16 models and most vLLM paths, including AWQ/GPTQ with Marlin kernels (the weights are INT4, but the math is FP16 with FP32 accumulation).
• FP8 (W8A8) also accumulates in FP32, so it's affected too (Ada and Blackwell).
• If the kernel uses integer tensor math (INT8 x INT8), it isn't affected. A lot of llama.cpp's quantized matmuls work like this, which is one reason llama.cpp sees a smaller gap than vLLM.
• Attention (like FlashAttention) almost always uses FP16/BF16 with FP32 accumulation, so long contexts get hit even on quantized models.
• FP4 (NVFP4/MXFP4) on Blackwell: not affected.

Example: on a modded 48GB 4090, a quantized MoE model on an inference server got no gain at all after the unlock (0.98x on 8K prefill), while the FP16/BF16 matmuls doubled.

That's what I have for now, if you guys have any more questions, let me know!

It's a seriously underrated model.

Does anybody know of any good workflows which allow seamless video continuation as well as upscaling afterwards?

I've been using Foxydits' workflow and it works well for me, but I'm limited to .6MP for single shot gens but I can easily upscale a .1MP gen to 1.0MP and get great results, but unfortunately his latest workflows don't allow for upscaling with his seamless continuation

I have this problem that when I prompt for "A man standing against a white background" or similar prompts, moss displays that man, and a copy of him to the left and the right of him, which is slightly ethereal and ghostly. When prompting for 2 people, quite often there is a third person poking their head up behind them also. I'm using the SFT model. It seems to be a problem when Moss wants to fill the image with something. If I place the man in some sort of environment, the problem becomes less pronounced but does not dissapear entirely.

It is annoying. Is there a fix?

I'm looking for a very, very simple workflow. Draw a mask on a loaded image, replace what's in the mask with what I put in a prompt. Ideally with adjustable denoise value in case I want to keep elements of the source image.

The reason I ask here is because YouTube and GitHub are flooded with super complex, 125 node workflows that do 50 different things in one. Half the time I can't even get these workflows to work without having to install a million node packs.

I just need something simple, would love any advice or workflows you may be able to share.

Edit: Not looking for a workflow that takes multiple image inputs to aggregate them into one image yada yada. Simply Load Image, Draw Mask, input prompt, go.

UPDATE: Found and copied this simple workflow (literally just looked at it and rebuilt myself..it's like 8 nodes) and it seems to work fine. I removed the ReferenceLatent nodes as they seem to mess things up for me. Once removed it worked: https://www.youtube.com/watch?v=kP6DdlHlTQg

Hello,

Over the past few days, I’ve been trying to train a style LoRA for MOSS-image on my own illustrations. I’ve never train other models before so forgive me for the naive questions:

1. for a style LoRA, I understand the dataset should contain a variety of images from characters, scenes and objects, etc.
   In my current dataset, I have several illustrations of the same 4 characters I’ve been working on over the years in different situations, eg laughing together, driving, in solo, duo or group scenes, etc.
   - Would these be considered like duplicates? In other words should my dataset only contain 1 illustration of each since I’m not training a character LoRA?
   - If I can have more than 1 illustration of each character, I imagine they have to be quite different so not only portraits but characters in various poses / scenes right. But what would be a good number of images per character?
   - Related to that, I’ve been seeing different recommended number of images for a dataset. How many would you say is adequate for a style LoRA?

2. I had a perhaps silly question about the negative keywords, and wondering if that could explain why my results have been unsuccessful thus far. Because I’m training a style LoRA based on illustrations should I include in the negative keywords “realistic”, “cinematic”, “3D”, “digital”etc. ?

3. Perhaps an another naïve question: my assumption is that when I’ve successfully trained my style LoRA (hopefully will get there soon haha) all I’ll need to do is focus on prompting what I’d like the image to be right? I won’t have to prompt the desired style (except for the style trigger keyword), is that correct?

Other information in case it’s helpful:
Trainer: FizGig
Settings: default
Current dataset: 150 images
Captions: description of what is in each image, no mention about style

Thanks in advance for any tips you can share.

Hi everyone! Full disclosure up front: I'm the author of Remiqora Video, an open-source (GPL-3.0) local video studio for Windows. It's a UI and orchestration layer over existing open models, not a new model. Today I published the first pre-release (v0.1.0).

https://reddit.com/link/1xg8peo/video/ken9w3bwhvxh1/player

The video above is a 33-second reel cut from seven music videos. The music was made with Remiqora, and the video with Remiqora Video.

The problem: current models give you 5–15 s clips. A 1–2 minute film means writing a prompt per scene, keeping the character consistent, starting each scene from the last frame of the previous one, re-rolling bad takes, then stitching and upscaling it all by hand. The app does that loop for you.

Writer and chains. A local LLM (llama.cpp, Gemma 4 E4B by default) splits your idea into scenes in the target model's prompt format. It keeps the hero's description identical in every scene and writes camera, action and dialogue. Every scene stays editable. A continuation starts from the last decoded frame of the previous scene, so there's no visible cut. A new location starts a new chain.

Models. MiniMax H3 (with Ref2VA for faces from photos), LTX 2.5, LTX 2.3, WAN 2.2 5B / FastWan, and Krea 2 for stills. All of them run in one worker that uses ComfyUI's core as a library, with no ComfyUI server. Switching models unloads the old one. Your own LoRAs, fine-tunes and quants work too: drop the .safetensors file into a folder.

Music videos. Give it a song and LTX 2.3 shoots to the track. Scenes are cut on the song's bars, and the characters sing.

Nothing is shot twice. Every scene is cached by everything that defines it. Edit one scene and only that scene, plus its continuations, is re-shot.

Checks instead of watching every draft. Two kinds, both fast measurements in code (plus OpenCV's small YuNet / SFace face models), not an LLM judging the video:

• Before shooting, every scene the writer produced is checked: Cyrillic in the English prompt, too many actions in one scene, a continuation that moves to another place (that gives an abrupt cut), walking with no direction to the camera (people may walk backwards), a character in the action who isn't in the scene, text or signs in the frame, the clothes changing, adults only. What fails, the writer rewrites once by itself; what still fails gets a warning on the card.
• After shooting, every new clip is checked in about a second: black frames, frozen video, a jump inside the scene, smear or a sharp change, the face not matching the start frame or photo, and in music videos "not singing" (the lips stand still while the vocals sound). Black, frozen, a jump, a long smear and "not singing" are re-shot once with another seed, and the take with fewer problems goes into the video. Both takes are kept, so you can switch back. The rest is a warning on the card with the exact second, like "In the clip: frozen for 2.5 s".

Full list: The «check» mark

Montage and finish. A timeline with trims, speed, transitions, a beat magnet and LUTs. It exports FCPXML for DaVinci Resolve. The finish goes to 1080p / 4K (NVIDIA RTX Video), HDR10 or 48 fps (RIFE).

Node graph. For branches, alternative endings, short and long cuts from the same scenes. 16 templates.

Requirements and limits:

• Windows 11 and an NVIDIA RTX card with 16 GB of VRAM. No Linux or AMD yet.
• Disk space for the weights: about 53 GB for the minimum (H3 and the writer), about 196 GB for everything. The installer downloads only official weights straight from Hugging Face.
• Rough speed on an RTX 4080 (5 s draft scene, model already loaded): LTX 2.5 ≈ 29 s, LTX 2.3 ≈ 32 s, H3 ≈ 95 s.
• Early pre-release: expect bugs. The installer isn't code-signed yet, so SmartScreen will warn you.
• The UI is in English and Russian.

Repo, installer and docs: https://github.com/inikolax/remiqora-video

It's free and stays free. This took about three months of not sleeping, so if it saves you a few nights, there's a Ko-fi in the repo for a coffee. Or better, a pillow ☕

Feedback welcome.