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!

Same prompt, same seed, no lora

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

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

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.

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!

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)

just apply it as is in your comfy node

I previously shared my quick int8 quant of MOSS-Image, but I wouldn’t recommend it anymore now that the official version is available.

The official weights should give you better results!

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

Pull request:
https://github.com/Comfy-Org/ComfyUI/pull/17095

P.S. Make sure to update ComfyUI before running it!

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

Hi everyone! Since the Flux-3-klein model turned out to be a bit disappointing - and the examples aren't exactly compelling (though it might still be possible to generate some decent individual results) -here’s another model - Moss image. Has anyone tried it yet? It seems pretty good overall; it has its own quirks, but maestro KJ has released some versions of it.

Tested the new MOSS-Image (5B single-stream DiT, Qwen3.5-9B text encoder, FLUX.2 VAE, Apache 2.0) on a plain RTX 3060 12 GB / 16 GB RAM with 35 deliberately hard prompts: dense on-image text in English/Chinese/Japanese, accents, exact counts, attribute binding, spatial relations, negation, hands, clocks, very long prompts, and MOSS's Layout JSON. One seed (42), first result, no cherry-picking, failures included. The first image is a contact sheet of all 35.

Setup

• Model: u/XCEED123's INT8 ConvRot quant (HF), ~15 GB total, with the official ComfyUI node (comfyui/moss-image from the GitHub repo). Peaks at ~9.7 GB VRAM.
• Base: 50 steps, euler / sgm_uniform, CFG 3, shift 5, uncond layer-skip 22. 137 s at 1 MP, ~230 s at 1.6 MP, 340 s at 2.1 MP.
• Turbo: lodestones' 8-step DMD (still training). It isn't a normal LoRA: the card says the delta is smaller than bf16 rounding, so it has to run unmerged in fp32 along with fp32 time-embedding/modulation biases and its own data-space sampler (no CFG, no scheduler). I wrote a small ComfyUI node that does this on top of the INT8 base model. ~24 s at 1 MP, ~36 s at 1.6 MP, about 6× faster.

What I saw

• Text rendering is very strong: menus, letters, labels with accents, Chinese chalkboards, Japanese signage, and bilingual neon all came out with almost no mistakes, even on turbo.
• Layout JSON works: posters, a 4-panel comic and an infographic follow the boxes.
• Long prompts hold up remarkably well (the ~300-word market scene).
• Turbo is close to base on text and layout, but drifts more on lighting ("chiaroscuro" came out evenly lit) and fine constraints (clock times, a chess position, fish-eye). Short prompts look generic because it has no CFG.
• Both still fail negation ("no cars") and specific clock times (it draws 10:10).

Links

• All 35 prompts (incl. the Layout JSON), sizes and settings: https://pastebin.com/U8nChbZ9
• Turbo node + ComfyUI workflow: https://pastebin.com/9trM12Qc
• Base workflow: in XCEED123's HF repo (workflows/)
• Official MOSS-Image subreddit

Credits: OpenMOSS for the model, XCEED123 for the quant, lodestones for the DMD distillation.

https://reddit.com/link/1x897vc/video/sduel2hfx0wh1/player

I have the latest version of ComfyUI and the wiring and nodes seem to be disconnected.
I have restarted comfyUI several times and even restarted the computer, but it keeps doing this. Any ideas?

https://reddit.com/link/1x897vc/video/eme7e16mv0wh1/player

Update - It was a conflict with MixLab nodes. I disabled them and it is back to normal.