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

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 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 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, 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.

In my test, I used 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:

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

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!

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.

So after so many models have been released the past year, what are everyone's top models so far? And settings/loras? Since sometimes those can make the difference in results.

I am sure most people are wondering this, so I want to collect everyone's thoughts on this, mainly want to hear thoughts from people with 6gb of vram, to 24gb of vram, since people who run heavier models on servers or just by owning an expensive GPU are very rare so experiences would differ a lot from us commoners.

I would say to keep this organized, to divide it into different areas.

• Best Image to Video Model

• Best Video Editing Model

• Best T2I Model

• Best Image Edit Model

I would say those are the main ones most people are wondering about, or are curious about since I keep seeing people use Wan even tho Minimax is out, and LTX being out for a while too, and even more imsge models. I know there probably won't be an all rounder best one, since some have more features than others, or are more customizable since they have been out for a while, but still curious on peoples thoughts on this.

Other types of AI models people might want to share that I am personally interested on would be

• Best 3D Video Model

•Best Voice Cloner/TTS

• Best Transcription model (since last I saw there was Qwen 3 ASR, which a lot of people preferred over whisper AI, but maybe there are better ones out now, or better settings and stuff like that)

• Best Agentic LLM/translator, from all parameters, as long as its not one that needs multiple or more than 24gb of vram, although I personally have 16gb of vram but extra ram comes in clutch sometimes.

If you are trying out the new MOSS-Image GGUF models in ComfyUI (`ComfyUI-MOSS-GGUF` / `RebelMossGGUFV4` node) on an older GPU like the RTX 20xx series (Turing architecture, e.g.,) and getting painfully slow generation speeds, here is why and how to fix it.

### The Problem
Turing GPUs do not have native hardware acceleration for `bf16`. In the node UI, the only options available under `compute_precision` are `bf16` (default) and `fp32`, forcing older cards to emulate BF16 or choke on full FP32.

### The Discovery & The Fix
Digging into the source code, I found that **`runtime.py` actually already has built-in support for `fp16`!** It was simply omitted from the dropdown list in `__init__.py`.

You can fix this yourself in 10 seconds:

1. Open `ComfyUI/custom_nodes/ComfyUI-MOSS-GGUF/__init__.py`.
2. Find the line with `compute_precision` (around line 27).
3. Change it from:
   ```python
   "compute_precision": (["bf16", "fp32"], {"default": "bf16"}),

to:

codePython

"compute_precision": (["bf16", "fp16", "fp32"], {"default": "bf16"}),

1. Restart ComfyUI and select fp16 in the node.

It's all about priorities!

I've been experimenting with MOSS-Image's BBox layout feature and got frustrated with its absolute pixel coordinates. Changing resolutions or aspect ratios meant recalculating every bounding box, and mismatched coordinates sometimes seemed to cause unwanted white borders.

So I made a small ComfyUI node that converts a resolution-independent 0–1000 coordinate grid into MOSS-Image's native coordinate format, using the actual generation dimensions.

You can now reuse the same layout JSON at different resolutions without manually adjusting every coordinate, similar to Ideogram's approach.

It's lightweight, has no additional dependencies, and includes a basic system prompt for generating compatible JSON layouts.

I tested it across several aspect ratios, and the results look promising. It's not pixel-perfect because the model still has the final say on placement.

It's now available directly through ComfyUI Manager!

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

Feedback and testing are welcome!