Here's a one click workflow so you can create Seamless Vlogs.

https://github.com/roycho87/Seamless_vlog_workflow

https://github.com/roycho87/seamless_video_combiner

https://github.com/roycho87/minimax_continuous_audio_splitter

Also, here's two useful nodes you might like used in the workflow.

https://github.com/roycho87/h3_clown_anchoring

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

I wanted my finished illustrations to look like an actual manga page: crisp ink lines, blank paper for light areas, solid black for dark hair and clothes, and screentone only where it’s needed.

It uses Qwen-Image 2.1 Turbo (edit) to decide what should be black, white or toned, then a small finishing node prints it with real halftone dots. There’s also a lite workflow without the edit model.

The node is a single small Python file (numpy/opencv/torch only), MIT licensed.
GitHub: https://github.com/ashukae/ComfyUI-MangaScreen
Also in ComfyUI Manager, search “Manga Screen”.

Have fun experimenting with it! If you run into any problems, let me know here or open an issue on GitHub. Thanks!

I've been doing some testing to check the creative variety of MOSS image. It has got quite some cinematic looks in it.

Nothing fancy about the workflow, just straight from the comfy template.

diffusion model: moss_image_sft_int8_convrot.safetensors
text econder: qwen3.5_9b_int8_convrot.safetensors
vae: flux2-vae
steps: 50
cfg: 3
sampler: euler
scheduler: sgm_uniform / simple

With these settings 4k res is rendering in about 55 sec on a GTX5090 with peak VRAM 19,5 GB.

Great fun so far!

Every image was made using base model at cfg4 and 39 steps and at around 1.5MP

Same prompt, same seed, no lora

Fizgig LoRA Isolation: train 2 identities into one LoRA and keep everyone else looking like themselves.

A normal LoRA of a person spreads their face onto everyone else in the picture: strangers in the background, a friend beside them, a crowd. LoRA Isolation stops that. Your subjects can stand together in one picture, or next to someone the model already knows, and every face stays its own.

The numbers (Krea 2, same pictures, same settings): with a normal LoRA, 48 of 50 strangers came out looking like the trained person. With LoRA Isolation, 0 of 50. Likeness of the trained person stayed the same (ArcFace 0.78 vs 0.77).

Demo video: (same as above) https://youtu.be/CNh4sN5vN_8

A second person in a LoRA is usually the problem. Here it's part of the fix: learning two identities together is what teaches the LoRA that each face belongs to its own trigger. They don't need to be the same gender, and yo uegt a great multicharacter LoRA. In the demo the second person was a woman, and every stranger was a man, demonstrating it did not have to be the same gender as me to preserve the isolation (that bit was a surprise to me tbh).

How it works: DOP at the base, with Fizgig's own layers on top.

• DOP (Differential Output Preservation), from Ostris's AI-Toolkit
• Multi-subject identity anchoring
• Fused-token class decoupling (gwelt, a man trains as gweltman)
• In-frame negative-pair compositing with causal-order captions (stranger first)
• Per-sample LR scaling, strided DOP and balanced sampling
• Class-aware training paths for people, animals and things, and styles

Tips:

• Train two people even if you only want yourself. The second face is part of what keeps strangers clean.
• Two trained people in one picture, plus someone the model already knows, works well. Three or more trained people in one picture is less reliable.
• Prompt with the joined word (gweltman man at a cafe) and describe the other people.

The side-by-side training pictures use 32 generated strangers with natural skin texture, so they don't pull your LoRA towards poor skin and no real person's photo is used. They download with your models.

It's all set up on one card on the Training tab, and works on every model in Fizgig except ACE-Step (the music model). Tested on Krea 2, with more model testing to follow.

*And before anyone points it out, its not perfect, I know but I think its progress and its fully documented in my github, and opensource. One thing I'd like to improve is less lip similarities - but maybe some ideas will come from people using it *

How to set it up (video): https://youtu.be/8uW5NdL5b20

Release notes: https://github.com/shootthesound/Fizgig/releases/tag/v8.4.0

Fizgig on GitHub: https://github.com/shootthesound/Fizgig

I tested a few samplers and schedulers on the MOSS Image model in addition to Euler. These are worth using if you want to try out realistic images, I got pretty good results with them even at cfg 3:

samplers: heun, heunpp2, exp_heun_2_x0, dpmpp_sde, dpmpp_2m_sde, res_2s, (res_2m)

schedulers: simple, sgm_uniform, beta, normal, linear_quadratic, beta57, sigmoid_offset, power_shift, radiance_shift, bong_tangent

I noticed that the euler_ancestral_cfg_pp, lcm, and er_sde schedulers primarily generated Asian women, in case anyone is interested in that.

Based on my very first tests, the pairs that followed prompts the most closely were dpmpp_sde/radiance_shift and dpmpp_2m_sde/radiance_shift, but overall, radiance_shift did a better job of keeping the prompt consistent.

In my test, I used SFT model with the 8-step SFT lora_latest with a strength of 0.7 and a resolution of 1536x1536. Generating one image took 28 seconds on a 3090 graphics card.

The original workflow includes a shift node; it’s best to delete or disable it, because it only generated noise for me when used with the comfyUI models (Thanks to Kijai for the models!). The models and the good basic workflow I used to generate the images can be found here:

https://huggingface.co/Comfy-Org/MOSS-Image

Update: I created a plot using the combinations above and Euler. I've posted it here, the prompt is included in the image, the image contains some adult content:

https://huggingface.co/buckets/Mykee/MOSS-Plots/tree/Moss%20best%20sampler-scheduler%20combos.png

base model with turbo lora , 8 steps 1 cfg euler/simple

tried different things , its got some variety , can do a lot of different things for a small model,anatomy is really good unlike some other models

https://huggingface.co/Abiray/MOSS-Image-SFT-INT8-convrot

I recommend the INT8 as a start. nVidia RTX20x+ & RDNA2 (RX6000)+ are good. ARM needs fairly recent GPUs to have the right OpCodes; Raspberry Pi 5 & M5/A17 Pro+ for NE support.

If those seem too slow, or if really VRAM constrained, then try a GGUF quant.

Also there is a SFT banding fix LoRA.

render speedups: https://huggingface.co/darask0/MOSS-Image_4-step_adapter_lora

upgrade your Flux VAE : https://github.com/ClownsharkBatwing/RES4LYF

OSS for the win!

edit: early LoRAs & LoRA training in comment.

Hey guys,

I have been working on the consistent character portable format (.char) for a while & couple of reddit users asked me if multi character is possible for image & video generation.

I have enabled the same in Omnichar with upto 4 characters in the same video or images.
Here I have created 3 workflows:

1. Encode Characters (one workflow, which builds .char with MMH3 & Flux support)
2. Use multi .char with MinimaxH3
3. Use multi .char with Flux2 Klein 9B(4b also supported)

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

Official repo: https://github.com/omnichar/OmniChar (Opensource)
ComfyUI Node: https://github.com/omnichar/ComfyUI-Omnichar/tree/main (Opensource, Multi character support is not yet available)

Next up, I will be enabling the same via ComfyUI node.

Hope it's helpful.

Hi! I sometimes train models and one thing always seemed very suboptimal for me. This is VAE latent files that take much more space than original data, while VAE should compress data, not making it more heavy. This is mostly because jpeg and video codecs do there job and compress data very well, while latents are almost uncompressed. So I tried to make something like jpeg but for latents.

I want to give a heads-up right away that this thing have very narrow use case when your latent dataset is large enough that it doesn't fit your local disk, so you have to use some s3 storage which may cost a lot when the dataset is so large.

Anyway, VaeZip is a PyTorch-based library that implements several latent quantization codecs and stores the compressed tensors in common Safetensors files that are much smaller then if you store these tensors in fp32.

The codecs are designed specifically for VAE latents: some of them exploit both spatial redundancy and that the VAE latent distribution is usually normal. That allows to store latent tensor with about 3 bits/value precision (10x smaller files) while keeping pixel MSE at 0.0003 after decoding.

For example, one of the best codecs uses a combination of global range scaling, local range scaling with square spatial blocks and so called “Lloyd-Max table” which is essentially codebook that is tuned for the sample distribution. After that it quantizes values to 2-8 bits and packs them.

The codecs were selected from the benchmark that compared ~50 algorithms on 8 image and video VAEs by the reconstruction quality, fidelity, space usage and I/O latency.

I have also measured the impact on pretraining a small T2I flow matching DiT with latents compressed with different codecs. In one run the loss curve is indistinguishable from the fp32 baseline with just 6 bit storage.

Maybe some of you here do some large scale pretraining or tuning, hope you find this useful!

neat model.

F2K 9B is superior to F3K _|_B. Evolving backward.

Faak you Black Forest Labs.

I tried upscaling, T2I, texture upgrade, N-SFW, SFW, Anime..

Pleased to announce, F3K sucks in everything, Cheers.

(Left) lora.safetensors (Right) lora_latest.safetensors

Euler, simple, 8 steps, 1 megapixels took 5 secs on 4070 super.

The skin looks plasticky in studio photo style, but I like its amateur snapshot style.

https://huggingface.co/lodestones/MOSS-Image-SFT-8-steps-dmd

The other images removed by reddit filter.

https://civitai.red/posts/31700334

I saw a post somewhere, I forget where, that suggested using sigmas instead of steps. I dug into this a bit, found the sigma schedule used by Qwen2.1, and had Claude derive a set of sigmas that follows the same sigma curve but with 12 and 14 steps. I can confirm that Qwen2.1 Turbo produces a MUCH better image when using the 12 or 14 step sigma schedule. I am attaching an image with the sigmas and workflow modification you need to run this setup.

8-step sigmas: 1.0, 0.978453, 0.954180, 0.926626, 0.895080, 0.845148, 0.704534, 0.414568, 0.000000

12-step sigmas: 1.000000, 0.985926, 0.970690, 0.954180, 0.936216, 0.916954, 0.895080, 0.866147, 0.811803, 0.704534, 0.526271, 0.291856, 0.000000

14-step sigmas: 1.000000, 0.988010, 0.975164, 0.961423, 0.946670, 0.930788, 0.914152, 0.895080, 0.871055, 0.832937, 0.755721, 0.639338, 0.463134, 0.253695, 0.000000

Same sampler as normal: Euler (*edit* er_sde is pretty good too)

Any Idea why Moss isn't working from this workflow? Just generating noise :(

just apply it as is in your comfy node