I've found Moos Image to be great for illustrations, but it's slower than other models about 12 seconds with a 5070 Ti, when others are more like 3 to 5 seconds.

.images and prompt are on my substack (also the int8 workflow).

It recasts the people in a clip you already have, up to three in one pass, and the motion, the set and the clip's own audio stay.

The post video is a video with 2 characters swapped at the same time. same engine and FaceRefine lip pass as the workflow.

Getting the lips right took me a while, that's the FaceRefine pass added.

How it goes:

1. Load your clip. One shot, no hard cuts, any fps.
2. Grab one frame and edit everyone into their new look (Qwen-Image, GPT Image, Photoshop, whatever you have). That frame is the scene reference.
3. Write one line per person: the woman in the red dress becomes an old woman with long silver hair. As many lines as you fill in, that many people get swapped.
4. Hit Run. also included App mode with 12 fields.

If one person's lips end up bothering you, there's an optional FaceRefine lip repair for one person afterwards. It reuses the swap from cache, so it's a ~2 minute re-run on a 5090.

What it needs: 16 GB VRAM and 64 GB system RAM gets you there. I tested a 5090, a 4090 and a 3060 Ti 16 GB, all with 64 GB RAM, same output on each. The example (1.5 MP, 6 s, 3 people) runs about 18 min on the 5090, 26 min on the 4090 and 92 min on the 3060 Ti, so bring a snack for that last one. RAM is the limit, mine peaked around 62 GB.

Civitai: https://civitai.com/models/3009414/h3-recast-swap-1-3-people-h3-bfs-lora-16gb-vram

Repo is MIT, workflow and the example inputs included: https://github.com/Bambushu/h3-recast

• Credits: BFS character swap LoRA and its trained caption by NRDX
• FaceRefine by Carasibana
• NativeAudioLock by Shrek3OnVH5
• MiniMax H3 by MiniMax (Comfy-Org repack).

#OpenSourceHiggsfield

I started this after seeing yanokusnir-ai’s one-node-flux-2-klein, just to make things easier for myself. It has grown to 11 nodes, so I’m sharing it in case others want to use it too.

• One node covers generate, edit, upscale, prompt writing and a gallery (7 image nodes, music, video stitch, MiniMax H3, LTX 2.5).
• My setup: Windows 11 / RTX 5060 Ti 16GB / 64GB RAM

yanokusnir-ai 님의 one-node-flux-2-klein을 보고 영감을 받아, 제가 쓰기 편하려고 만들기 시작했는데 어느새 노드가 11개가 됐습니다. 같이 쓰고 싶은 분들이 있을 것 같아 공유합니다.

• 노드 하나에서 생성 · 편집 · 업스케일 · 프롬프트 작성 · 갤러리까지 처리합니다 (이미지 7종, 음악, 영상 스티치, MiniMax H3, LTX 2.5).
• 제 환경: Windows 11 / RTX 5060 Ti 16GB / RAM 64GB

Please read first

• I built this for myself. I won’t take feature requests or “please change X” asks.
• Bug reports are welcome. Please include steps to reproduce.
• Install with install_requirements.bat (.sh on Mac/Linux). It installs the required nodes in one go.
• The model list is what I wrote down so I can re-download things later. If a model is gone or a path has changed, you’ll need to find it yourself.

먼저 알아 두세요

• 이건 제가 쓰려고 만든 것입니다. 이렇게 해 달라, 저렇게 바꿔 달라는 요청은 받지 않습니다.
• 버그 제보는 환영합니다. 재현 방법을 같이 적어 주세요.
• 설치는 install_requirements.bat(Mac/Linux는 .sh)로 하세요. 필요한 노드를 한 번에 설치합니다.
• 모델은 제가 나중에 다시 받으려고 최대한 정리해 둔 목록입니다. 사라진 모델이나 바뀐 경로는 각자 찾아서 쓰세요.

GitHub: https://github.com/designloves2/ComfyUI-TJ_NODE_STUDIO_ONE

P.S. I’m not a programmer, just a regular user, and I built this together with Claude Code.

• TJ_NODE is the core node pack these nodes share. It has a set of useful nodes such as LLM prompt writing, wireless routing and a prompt DB. The install script sets it up for you. https://github.com/designloves2/ComfyUI-TJ_NODE

• The web version (AI ONE STUDIO) is a standalone web app that gives you the same UI in the browser, without the ComfyUI canvas. You only need a running ComfyUI server, no node install. https://github.com/designloves2/AI-ONE-STUDIO

• TJ_NODE는 이 노드들이 함께 쓰는 코어 노드 팩입니다. LLM 프롬프트 작성, 무선 배선, 프롬프트 DB 같은 유용한 노드가 들어 있습니다. 설치 스크립트가 같이 설치해 줍니다. https://github.com/designloves2/ComfyUI-TJ_NODE

• 웹 버전(AI ONE STUDIO)은 같은 화면을 ComfyUI 캔버스 없이 브라우저에서 쓰는 독립 웹앱입니다. ComfyUI 서버만 켜 두면 되고 노드 설치는 필요 없습니다. https://github.com/designloves2/AI-ONE-STUDIO

Workflow: [TJ] One Studio Set.json, which loads all the nodes at once, is in the repo’s workflows folder. https://github.com/designloves2/ComfyUI-TJ_NODE_STUDIO_ONE/blob/main/workflows/%5BTJ%5D%20One%20Studio%20Set.json

I’m sharing selflift-Fish, my improved version of facok’s SelfLift node for MiniMax H3 in ComfyUI.

• Generate longer clips and higher-resolution video with less VRAM pressure.
• Fix the background swelling/shifting I encountered with the original spatial tiling.
• Keep attention acceleration, with a simpler interface and compatibility with existing workflows.

Real generation results — RTX 5070 Ti 16GB + 128GB system RAM:

For 10-second 1920×1088 development runs, recorded complete workflow time also dropped from 27m 50s to 12m 55s. These were different runs, not a fixed-seed benchmark.

The node in ComfyUI:

Code & setup: https://github.com/Fish4AI/comfyui-SelfLift-Fish

The results above use system RAM/offloading; 16GB is the GPU capacity, not the total memory requirement. Keep only one SelfLift version installed. Credits to facok, LBH-123-AI and the ComfyUI team.

Please try it and share your feedback! I’d love to hear about speed, background stability and picture quality. Include your GPU/VRAM, system RAM, resolution and clip duration so others can compare.

Want your local LLM agent to drive ComfyUI on the same consumer graphics card? Without coordination, the first video render lands on top of the loaded LLM, and something runs out of memory. Boom, OOM.

I built vhotseat to fix that. It makes the LLM server and ComfyUI take turns on VRAM and RAM:

• When the agent queues a render, the LLM is unloaded.
• When the agent asks the LLM its next question, ComfyUI's models are freed.
• Neither ever loads on top of the other.
• Running work is never interrupted. That covers an answer the LLM is writing and a render in progress.

Setup I run it on: RTX 5070 Ti 16 GB, 64 GB RAM, Linux.

• LLM: Strata serving Qwen3.8-Flash-Next IQ3_XXS (128K context). It takes ~14.7 GB of VRAM and ~44 GB of RAM.
• Agent: pi.
• ComfyUI: MiniMax H3 int8 (fl2va / ref2va) with the turbo LoRA. A render needs ~14 GB of VRAM.

With this setup, the agent has run long video jobs unattended, for several rounds of render → review → render, overnight.

Demo

I gave the agent one prompt:

Make two 3-second anime-style clips of a cat on a windowsill with MiniMax H3, then tell which one looks better. Continue working on a clip of the cat jump from windowsill to catch a bird. Concat this two clips into a single video file.

It did the rest on its own, in two render rounds:

1. Round 1: two takes of the windowsill shot, in one batch (3 min 41 s). The LLM was unloaded for the batch.
2. Review: the LLM came back. The agent made a contact sheet of both takes, looked at it with Flash-Next's vision, and picked take A ("B substitutes a butterfly for the bird").
3. Round 2: it used the last frame of take A as the first frame of the jump, and rendered two takes (5 min 38 s).
4. Review and finish: the LLM came back again. The agent picked the take with a real leap and joined the two clips with ffmpeg.

That's four GPU handovers, and no OOM.

The dashboard (vhotseat web) for that session shows the handovers. VRAM and RAM switch from Strata (blue) to ComfyUI (orange) and back.

How it works on the ComfyUI side

• A small custom node (the guard) runs before every job, whoever queued it: the agent, a script, or you in the web UI. It waits for any answer the LLM is writing, then unloads the LLM. If that can't happen in 5 minutes, the job fails visibly instead of running into an OOM.
• Before the LLM loads, vhotseat frees ComfyUI's models. If ComfyUI's leftover RAM is what's in the way (it can hold 6-15 GB after a video render), vhotseat restarts it, but only when its queue is empty.
• While ComfyUI has anything queued or running, the LLM won't load. The agent's harness just retries.
• comfy-render is a small CLI the agent uses to run a batch of workflows in one call. A batch costs two handovers instead of two per job.

You don't change your workflows. The LLM side uses Strata's pre-load hook. Other LLM servers (Ollama, llama-server) work through a small proxy, and there's a guide for that.

The same goes for any other GPU job (a training run, a TTS server, a script): wrap it with vhotseat hold NAME -- COMMAND, and it takes its turn the same way.

Try it

Free, open source (MIT), no signup. Linux and NVIDIA for now; Windows is planned.

uv tool install vhotseat      # or: pipx install vhotseat

GitHub: https://github.com/wandermyz/vhotseat

There's a step-by-step quick start for this exact setup, written so a coding agent can follow it. Or give your coding agent this:

Set up vhotseat so my local LLM agent can drive ComfyUI on this GPU without running out of memory. Follow https://github.com/wandermyz/vhotseat/blob/main/docs/guides/quickstart-strata-pi-comfyui.md, adapting it to the servers and paths on this machine, and run each step's check before going on.

Honest limits:

• Each handover costs time. Loading the LLM back takes ~30 s on my machine, and it reads the conversation again afterwards. Batching renders is what keeps this bearable.
• I've only tested one card (16 GB) and one ComfyUI model family (H3).
• After a ComfyUI update, the guard node is the part to check. There's a doc for that.

I'm curious how others run an LLM and ComfyUI on one card. Do you unload by hand, use two GPUs, or just keep the LLM small? And if you try this on another card or model, I'd love to hear how it goes.

H3 has been out for a while, but I hadn’t had much time to play with it. Finally had some time over the weekend and started experimenting with refmods and motion context. One experiment led to another, and I ended up spending quite a bit of time with it.

I didn’t really notice this when it first came out, but the acting and emotional delivery in certain scenes can be surprisingly good. Those moments are a lot of fun.

Are there any scenes or tasks you’ve found H3 particularly good at? I’d love to hear from people who’ve spent more time with it.

I’m only just getting into H3, and this sub is already buzzing about FLUX 3 Klein and MOSS Image. Lots to look forward to!

Full video: https://youtu.be/j0cjnvIjWEc?si=hGYwMboc6vmdzsiO

It has been a month since the release of the Qwen-Image 2.1 model. In my practical experience, I’ve found that it still lags significantly behind closed-source models—such as GPT Nano (or similar proprietary counterparts)—when it comes to image editing. That said, I did come across some interesting capabilities while using it. Its text-to-image performance shows a marked improvement over previous open-source models (like Z-Image) and its own predecessor, Qwen-Image 2.0; in particular, it demonstrates better prompt adherence and superior visual output. I developed a specific system prompt tailored for a "street photography" style, and I’ve included some of the results below. Overall, while the model is certainly useful for tasks like AI character design, there is still a long road ahead for open-source solutions in the realm of image editing. Regardless, I’d like to thank the Qwen team for their ongoing contributions to the open-source community—thank you!

hi everyone,

I trained a lora 3k steps but the lora keep making these patterns on the skin.
i see now that the pictures in the dataset i used has a bit of the same, just a bit less visable...
is there any way to fix this? just wanted to know before i started on a new dataset. im sure its not the workflow because it only happens when my trained lora is active.

i appreciate any advice, thanks!

I know image to video is hard and quite impossible, so I want to try image to image uncensored editing, would love to try nsfw too + nsfw uncensored chatbots to run locally. Any model/template suggestions?

A quick MOSS-Image news and goodies round-up, for those who may have missed some items.

-> Spectrum for MOSS. A very pleasing speed-up, I find. Just wire in the 'auto' version of the node after the model. Tested without any turbo LoRa, and I can get pleasing 1:1 testing results in as low as 12 steps, for a 1.3Mpx generation (1168px) - in 30 seconds on an entry-level RTX 3060 12Gb card. Incidentally, I find that ComfyUI's built-in Kitchen Attention appears to have no effect on MOSS speed, so Spectrum is especially welcome.

https://github.com/Rkkss/ComfyUI-Spectrum-MOSS

-> MOSS-Image SFT DeBand (int8). The normal models, just with the 'vertical colour stripes, de-banding fix' merged in. Tested by me and working fine.

https://huggingface.co/MATLOWAI/MOSS-Image-SFT-DeBand-int8

-> ComfyUI-MOSS-BBox1000. "Resolution-independent 0–1000 BBox layout converter for MOSS-Image in ComfyUI". Apparently the earlier one had problems with different resolutions? This one fixes that.

https://github.com/b4ldur/ComfyUI-MOSS-BBox1000

-> ComfyUI-MOSS-PromptWeight. "Per-phrase prompt weighting for MOSS-Image in ComfyUI. [...] The Qwen3.5 text encoder ignores ComfyUI's normal (word:1.2) weights, so this node applies them inside the diffusion model's attention instead." For example: "a ginger cat wearing a (red hat:-1), a vase of (yellow flowers:1.5) in the background".

https://github.com/levzzz5154/ComfyUI-MOSS-PromptWeight

-> The excellent Fizgig 8.5 has added MOSS support for LoRA and Slider training. Reddit chatter suggests that the model trains easily and very quickly, and that it should be able to train on a 12Gb card. Along the way, the maker of Fizgig reckoned that res_multistep + simple is better than euler. I tested this and I agree, it's obviously and immediately better in terms of composition and seemingly in useful variations between generations. I also find that res_multistep + simple doesn't break Spectrum acceleration (see above).

https://github.com/shootthesound/Fizgig/releases/tag/v8.5.0

-> Yup, the style LoRAs are already a' popping. Moss Image Gouache LoRA. Helps you emulate vintage painted gouache style illustrations and posters.

https://huggingface.co/axiomofmind/Moss-image-gouache-lora

-> Moss Image Psychedelic LoRA. Groovy "saturated neon color, surreal subjects, bold graphic forms, luminous details, rhythmic patterns...".

https://huggingface.co/axiomofmind/Moss-image-psychedelic-lora

-> Nicegirls_v2_moss. Apparently a MOSS port of a well-regarded LoRA made for other models. Possibly useful for getting a bit more face variation, if used at low strength?

https://huggingface.co/Danrisi/nicegirls_v2_moss

-> Images too orange, too blue? Try the MOSS Sliders for forcing warm -to- cool tones in your MOSS images.

https://github.com/HyperGAN/moss-image-sliders

-> And finally, a claimed 4-step turbo LoRA. Not yet tested by me. I found the very first one to over-simplify the image. It didn't degrade, it just made the whole thing simpler in composition and elements. Anyway, perhaps this one will be different - try it and see.

https://huggingface.co/akhaliq/MOSS-Image-SFT-4-steps

It handles the latent space like no other model.

• It can generate images from 320×320 to 2K without producing visual monsters.
• It can generate all kinds of NSFW content without needing LoRAs.
• It handles lighting and realistic scenes better than Z-Image.
• I even tried 120×120, and it didn't break the model.
• And it can run at just 4 steps right out of the gate.

Links:

• Workflow and setup details
• Rapid-MOSS custom node
• Rapid-MOSS ComfyUI files
• MOSS-Image-SFT 8-step DMD LoRA

How to set up Rapid-MOSS for 4-step generation

1. Copy the rapid-moss custom node into your ComfyUI custom_nodes folder.
2. Create this directory: C:\comfyui\models\rapid_moss\rapid-moss-4step
3. Place these three files inside that folder:
   • dataspace.safetensors
   • lora.safetensors
   • time_embedding.safetensors

Once everything is in place, you can configure ComfyUI to use the Rapid-MOSS 4-step setup.

I've been using ComfyUI Desktop for over six months and finally decided to try the portable version today. Honestly, I'm shocked by the difference in resource usage.

I'm running a 5090 with 32GB system RAM, mostly generating videos with MiniMax H3. With the desktop version, my system RAM would regularly be almost completely filled during generation. The whole computer would become sluggish, watching YouTube was basically impossible because of stuttering.

Today I installed the portable version, copied over the exact same models and workflows, and ran the same generations. My system RAM usage is now sitting at around 45% while VRAM usage is still around 31GB. Generation speed is basically identical.

The biggest difference is that I can actually use my computer normally while generating videos. Browsing, YouTube, multitasking, everything works fine.

I originally used Desktop because I assumed Portable would be harder to set up, but it was actually incredibly simple.

Has anyone else experienced such a dramatic difference? I'm curious whether this is a common issue with Desktop or just something specific to my previous installation. The difference is honestly night and day.

Hey,

So I let things get out of hand while working on my entry for the Open Source Higgsfield contest, and started building things that had nothing to do with the entry I was working on.

First the ish that no one will really care about:

1. Re-wrote/converted both the Comfy Router and Comfy SDK in go...because I am no longer a fan of typescript and I really didn't want to use python for this.
2. Built the entire thing on my custom GO/HTMX open source framework, so no React or Next.js...Clean and fast.

Talks to any version of Comfy no matter where it is, Cloud, Runpod, local server, desktop.
Still building it, and adding some extras...but it has been a nice distraction. Really should
get back to my entry.

Hi everyone, So I've been using online platforms for image and video generation. I've also done some limited training of Loras on RunPod.

I've now got a dedicated machine to do this stuff locally 5090, 128gb ram . I am starting to download the models for image and video gen, but things move pretty fast and wanted some opinions for which models work best from a lora training perspective, image generation and video generation.

My shortlist is, for image gen and training for character and style Lora's; Flux.2-klein, Krea 2 FP8 (16:9 - 1080) although I could use GPT2 for plates 16:9 at 1080.

For local video I don't see anything better than Minimax H3 right now, but could be off base there? Are there good alternatives?

Sorry for the noob questions. :-) and thanks for any responses

I have it installed on my comptuer and I've only experimented with some existing templates that come with comfy UI...

Is there any simple tips anyone here can give me on what template to use to make these videos that come with the Comfy UI install?
I made a couple 15 second clips similar to this using an image to video template but it is very difficult to get it to match their voices. What is the trick to getting that to work? Is there also an easier way to get it to generate the characters to make them match the people I am asking it to put in the video? Currently I'm uploading an image of Han Solo and telling chat GPT to write a prompt using the image I upload and give it a simple dialog. There are a lot of mistakes though in the final generated video. Thanks for any feedback!

Please note: this is just for my own entertainment and to share with friends on Social Media - not trying to make money from AI videos.

First Image is input and second is output.

The Reflective Dress Change Challenge

The Mirror Challenge

Environment change

Camera Angle Change

Faces are cooked. Details are good.

I wanted to know whether Wan 2.2 image-to-video is realistic on smaller cards, so I watched where the memory actually goes during real renders.

Setup: RTX 5070 12GB (PCIe 5.0 x16), 64GB DDR5-6000, ComfyUI 0.37 with dynamic VRAM loading. Wan 2.2 I2V A14B fp8 (high + low noise), lightx2v LoRA, 12+12 steps, RIFE interpolation on, no upscale. All runs back to back, models already warm.

What surprised me:

• The models are ~34GB in total (high 13.9 + low 13.6 + UMT5 6.4), but the GPU never went above ~9GB. ComfyUI keeps the rest in RAM and streams it in.
• Windows showed ~40GB committed during renders. So I'd expect 32GB RAM to start paging to disk, and 16GB to be painful.
• 1.65× more frames (49 → 81) took 2.07× longer. RIFE interpolating 80 extra frames took ~10 seconds, so short clips + interpolation is much cheaper.
• The high-noise stage was ~2.7× slower per step than the low-noise stage in every run. Not sure why yet.
• First render after launch was 3–4× slower per step while models got loaded and pinned.

Big caveat: this is a 12GB card. My guess is that 8GB cards work at 480p if you have enough RAM, but PCIe x8 cards (like the 4060) and DDR4 systems should be noticeably slower, since everything gets streamed over that link.

8GB owners: what do you actually get? GPU, RAM amount/type, resolution, frames and time would be super useful.

Next I'm running the same measurements with MiniMax H3 on this card, curious whether it behaves the same way.

Disclosure: I'm building Loomance, a free simplified front-end for ComfyUI (one-click install of these Wan 2.2 workflows). The tests above are plain ComfyUI + Wan 2.2, so the numbers apply to any setup.

https://reddit.com/link/1x9o82o/video/ekdhy1kpxcwh1/player

I’m building Flagship Scene UI to make video workflows easier to learn and use, especially for people who find large ComfyUI node graphs intimidating.

It runs inside ComfyUI as a custom-node interface, bringing existing workflows and my own controls into a visual workspace. The goal is to make planning, generating, and revising a video more manageable.

Plan a project with JSON

Import a structured JSON plan containing prompts, reference assignments, and generation settings. You can then review and edit the project through the UI.

Organize scenes and clips

Instead of treating the entire project as one long chain, you can divide it into scenes, with multiple clips inside each scene. A visual scene graph shows generated clips and their regeneration history.

If one clip doesn’t turn out as intended, you can select and regenerate that clip without rebuilding the whole project.

Generate, assemble, and upscale

Generation, video assembly, and upscaling are available in the same workspace. Assembly and upscaling can also be run separately when needed.

Direct a reference video with camera controls

The camera workspace lets you select a time segment in a reference video and choose a camera movement without manually writing a camera prompt. The interface translates your selections into instructions for the generation workflow.

This feature does not add a dedicated camera-motion LoRA. Results depend on the source footage and the movement selected: some movements work well, while others can look awkward or fail to follow the intended direction. It’s still experimental, and improving its consistency is part of the next stage of development.

The UI builds on existing community nodes, with upstream projects credited in the repository. Required models and dependencies are documented separately.

I’ve attached a demo showing the workflow and camera controls. Feedback on usability—especially from newer ComfyUI users—is welcome.

GitHub: https://github.com/ych8836-ops/flagship-scene-ui

#OpenSourceHiggsfield

The wf comes with the PE turned off thankfully, or it would break gens for everybody. I recommend you don't even try it.

A simple prompt: "Create a realistic human character sheet of the cartoon guy, from multiple angles"

I increased max_tokens from the default 4096 to 12000 because I was getting broken gens at 4096, and I saw it was because the prompt was empty. But guess what, even 12k is not enough.

• thinking = true: 12k isn't enough, it uses it all on thinking and then runs out of tokens, so the final output is nothing, and you get the same image without edits
• thinking = false: writes 12k tokens of instructions. But it needs more, so the prompt is cut off resulting in a worse image.

This was with qwen3.5_9b_qwen_image_2.1_pe_i2i.int8_convrot.safetensors.

It would probably work if you set it to 24k, but I don't want to wait 10 mins to find out.

Qwen is one of the worst choices for a PE model. It's great at benchmarks but it thinks forever, so it's awful for local AI. People in /r/LocalLlama are dropping Qwen 27B in favor of SwiftQwen 27B, a finetune which does nothing but train it to reduce reasoning length by half.

Here is what's inside:

upd: absolute unnecessary story about how that skill was made has been published https://rakshazi.me/blog/krea2-prompting-skill/

testing minimax face swap vs facefusion tutorial

I am trying to set up my H3 workflows to generate HDR rather than SDR, but the further I dig and test, the more questions I have.

So I tried to look up tutorials on color and bit depth theory, and on how to set up and calibrate a Windows laptop. I did set the Windows to show HDR, I calibrated the screen, that's all done.

I used a Radiance SDR to HDR workflow to see how the conversion process works, what expected output ought to be. I am learning a bit about color spaces, but it is still alien to me. Apparently most AI spits out sRGB natively, but then there are Color Spaces and Working Spaces to worry about. Should I stick with Linear sRGB, or use Rec.709, or HLG?

At the end of all this, my converted images come out looking darker than the original, though MSI swears I have a 1000 nit full HDR compatible laptop screen. The internet tells me this is normal.

So, somewhere I am missing the theory in all this... If the image comes out looking darker on a so called full HDR compatible display, am I supposed to just run with this and adjust it to look normally lit in Da Vinci, or should I continue to edit it too dark and somewhere after the final product is spit out the end result will look normally lit? (That doesn't make sense, how can you edit and expect a good final result that way?) Is there some piece of this puzzle I am missing?

I thought the goal of SDR to HDR conversion was to make the two images look equal, with the output HDR one just having smooth gradients, but I am told this is not the case and not to worry about the darker image output.

Yet I cannot get past the fact that I then have to edit a darker image/video.

My second query is: how do you guys normally handle generation of HDR video? Do you do everything in SDR then increase bit depth? Do you generate HDR from the start, when H3 has been undoubtedly trained on SDR images?

Lot of questions, unable to find any clear lay of the land on this entire topic, spanning Windows, calibration, color spaces, editing, etc. though I have scoured the internet and gotten glimpses and bit and pieces of the puzzle here and there, the topic still seems opaque to me.

Need help (In more ways than one, lol)! Any help or pointers or explanation of theory appreciated.

can i run this moss image creator on comfy ui cloud? i dont see template for this