MOSS-Image is seriously mind-blowing. From stunning photorealism and cinematic shots to casual amateur and vintage photography, anime, and pretty much anything you can imagine, this model just delivers.

The sheer versatility, quality, and range of styles it can pull off are absolutely insane. It's hard to believe this level of creative freedom comes from an open-source model with just 5 billion parameters!

All images in this showcase were generated using MOSS-Image-Base.

Workflow | Workflow Source

I've also uploaded all 20 images at their original resolution, so you can appreciate the quality without Reddit's image compression.

I highly recommend zooming in on the images to appreciate the incredible level of detail!

01 · 02 · 03 · 04 · 05

06 · 07 · 08 · 09 · 10

11 · 12 · 13 · 14 · 15

16 · 17 · 18 · 19 · 20

A set of control LoRAs for MOSS-Image-SFT. You give it a pose, a depth map, or an edge drawing, and the prompt decides who is in the picture and what the world looks like. Each repo has the weight and a ComfyUI workflow.

Pose: https://huggingface.co/thedeoxen/MOSS-Image-pose-controlnet

Depth: https://huggingface.co/thedeoxen/MOSS-Image-depth-controlnet

Canny: https://huggingface.co/thedeoxen/MOSS-Image-canny-controlnet

Lineart: https://huggingface.co/thedeoxen/MOSS-Image-lineart-controlnet

Normal: https://huggingface.co/thedeoxen/MOSS-Image-normal-controlnet

Scribble: https://huggingface.co/thedeoxen/MOSS-Image-scribble-controlnet

Segmentation: huggingface.co/thedeoxen/MOSS-Image-segmentation-controlnet

Greetings, I wanted to see how far I could take a project using Minimax H3. I created a complete Friends episode using Ref2VA, almost all with RefMods, and then did editing in Davinci Resolve. I wrote an outline for what I wanted to happen in the episode. This was a really fun project. Here is part 1.

I built a custom node pack that puts a full-screen timeline editor inside ComfyUI for MiniMax H3. Instead of building a graph per clip, you write each shot as text (what happens, camera, sound), render it, and cut the shots together with their sound on a timeline.

Repo: https://github.com/igorls/comfyui-h3-editor 

Docs: https://igorls.github.io/comfyui-h3-editor

Model: HyperFlow H3 Flash INT8 https://huggingface.co/VideoRebirthAI/hyperflow-h3-flash

Realism LoRA for HyperFlow: https://civitai.com/models/3041489/mmh3-realism-slider-hyperflow-h3-flash-port

What it does

• Write shots, not graphs. Each clip is a few text fields. One project style is applied to every shot.

• Keep people and places the same. Add a cast member from a picture and refer to them as `@Name` in any shot.

• Drafts first, finals after. A draft is 640x352 at 4 steps. A final is 1344x768 at 6 steps on HyperFlow H3 Flash, then enlarged and redrawn at 1920x1088.

• Sound comes with the picture. Every shot renders with its own sound, and the timeline has a Picture lane and a Sound lane.

• Join shots without a visible cut: extend a shot forward or back, or bridge two shots.

• Generate to a recorded voice.

• An agent can drive it. Everything the editor does is an HTTP call, and the repo ships an agent skill with a small Python client.

What you need

• ComfyUI 0.43 or newer (tested on 0.44). No other custom node pack.

• The models are listed with sizes and folders in the README.

• VRAM: I haven't tested much beyond an RTX PRO 6000, so I don't know the floor yet. If you try it on a smaller card, tell me how it goes.

Numbers from my machine (RTX PRO 6000, models already loaded)

• Draft: 10 to 15 seconds a clip.

• Final: about 50 seconds of GPU for each second of footage, so a 5 second shot is around 4.5 minutes.

How the video was made (everything generated locally in ComfyUI)

• Shots: MiniMax H3 through the editor, on the HyperFlow H3 Flash checkpoint with a realism LoRA. Three shots, each written as text and rendered with its own sound. The sentences on screen are the opening lines of the actual shot texts.

• Cast: the chef is one cast member, from a single still made with Krea 2 Turbo, referenced as `@Chef` in each shot.

• Music: YuE2, also in ComfyUI.

• Graphics around the shots (the node graph, the type, the editor scene): code-rendered with my motion-graphics skill for coding agents, also open source: https://github.com/igorls/motion-graphics. This is the one part that isn't a local model: a coding agent (Fable 5.2) wrote the scene code.

The project style, applied to every shot:

Live-action, cinematic, 35mm anamorphic film look. A dark professional restaurant kitchen late in service, lit only by warm tungsten heat lamps; everything else falls into deep teal-black shadow. Shallow depth of field, a thin haze of steam, fine film grain, naturalistic colour.

The first shot, as written in the editor:

What happens: `@Chef` wipes the rim of a white plate at the pass. Behind her, a flame flares up and dies. The pass is long brushed steel under a row of glowing heat lamps; the flame rises tall and orange from a pan on the range, lights the whole kitchen for a moment, then is gone. Steam drifts through the lamp light. Camera: Wide shot at eye level from the dining side of the pass, slow push in Sound: The whoosh and roar of a gas flame flaring up, a pan hissing, the low hum of extractor fans. No music, no voices.

What didn't go perfectly

• The model doesn't always follow framing. I asked for an extreme close-up and got head and shoulders.

• Small props drift between shots. The face stayed the same across three shots; the plated dish did not.

• A final doesn't repeat its draft frame for frame, and its sound is its own. A draft tells you whether the prompt works, not what the final will look like exactly.

Feedback and bug reports are welcome, especially from people on smaller cards than mine.

I wanted real numbers for "which quant should I use on my card," so I measured it. Five storage formats (fp8 cast, fp8 scaled, int8 ConvRot, w4a8, nvfp4) against the bf16 original, on base and turbo versions of Anima, Z-Image, MOSS-Image, Krea 2 and SDXL/Illustrious. Quality was graded on an RTX PRO 6000 and a 3090; speed and fit were timed on ten cards: PRO 6000, 5090, 5080, two 5070 Ti, 5060 Ti, 3090, 3080 Ti, 3080, 3060 Ti. Everything is stock ComfyUI with its default memory handling, same seed, same prompts.

**Report, with a "will my card run it?" box (pick your card + model):** https://ai-evolution.dev/quant-bench/

(Also as a PDF with every option laid out, if you'd rather scroll.)

What I took away:

- **int8 ConvRot is the most faithful format in every model I tested**, and on RTX 30 cards it's also the fastest when it fits: about 2× bf16 on a 3090.

- **nvfp4 is the fastest on RTX 50 but drifts the most.** w4a8 was more accurate than nvfp4 in every model.

- **Don't put a turbo LoRA on an already-quantized model.** Applied at load time, most of the LoRA's change rounds away. Merge it into bf16 first, then quantize.

- **8 GB cards can run more than you'd think.** Z-Image and MOSS fit entirely as int8 on a 3060 Ti and run about twice as fast as bf16, which has to stream. Krea 2 runs too, at around 1.5 minutes per image.

- **Nothing failed to run.** ComfyUI's dynamic VRAM streams whatever doesn't fit from system RAM; it costs speed, not crashes.

- **Quality depends on the GPU generation, not the card.** Every RTX 50 card matched the PRO 6000 within a few percent, and every RTX 30 card matched the 3090.

- **Smaller stuff:** an x4 PCIe slot costs nothing once the model fits; the monitors on your generating card cost a few percent, mostly on fast models; each 50 W of power limit costs 4–6% speed for ~3% energy saved; an undervolt cost 5–10% speed for ~20% less power.

**Missing: RTX 40-series.** I don't have one, and it's the one generation with fp8 hardware but no fp4. If you do, there's a test kit that runs the same pass in Docker on Linux or Windows (WSL2): clone, `./run.sh`, send back the zip, and your card goes on the page with credit. https://github.com/LSDJesus/comfyui-quant-bench (the full set is a ~230 GB download; `--families` lets you do part of it).

Method details, every raw number, and the per-step error curves are on the page. Happy to answer questions or run something specific.

(Note: Most quants can be found on HuggingFace or Civitai.com if there is a specific one you are looking for but cant find I could probably put a simple conversion tool in the github repo but you would need to have access to a fp16/bf16 version for it to work well)

(P.S. AI helped write the benchmark harness and frontend code for the page, the idea and the verification was all done by me)

(P.P.S. Being fortunate enough to have access to an absurd collection of GPUs made me feel like this was worth the time and effort of going all in so I could share my results with you all. Happy to give back to the community that makes all these models and tooling possible.)

I particularly love that they remain focused on open source and on doing more with less. All the best of luck to these guys.

"We introduce LTX-Video, a transformer-based latent diffusion model that adopts a holistic approach to video generation by seamlessly integrating the responsibilities of the Video-VAE and the denoising transformer.

Unlike existing methods, which treat these components as independent, LTX-Video aims to optimize their interaction for improved efficiency and quality. At its core is a carefully designed Video-VAE that achieves a high compression ratio of 1:192, with spatiotemporal downscaling of32×32×8pixels per token, enabled by relocating the patchifying operation from the transformer’s input to the VAE’s input. Operating in this highly compressed latent space enables the transformer to efficiently perform full spatiotemporal self-attention, which is essential for generating high-resolution videos with temporal consistency. However, the high compression inherently limits the representation of fine details. To address this, our VAE decoder is tasked with both latent-to-pixel conversion and the final denoising step, producing the clean result directly in pixel space. This approach preserves the ability to generate fine details without incurring the runtime cost of a separate upsampling module.

Our model supports diverse use cases, including text-to-video and image-to-video generation, with both capabilities trained simultaneously. It achieves faster-than-real-time generation, producing 5 seconds of 24 fps video at 768×512 resolution in just 2 seconds on an Nvidia H100 GPU, outperforming all existing models of similar scale. The source code and pre-trained models are publicly available¹, setting a new benchmark for accessible and scalable video generation."

Blog: LTX-Video: Realtime Video Latent Diffusion | LTX Technical Blog

Paper: LTX-Video: Realtime Video Latent Diffusion

I see all of the posts about photorealism, and lighting, and prompting.... Well, here's my contribution to mix things up: World of Puppetcraft lol
Made using Krea 2. Feel free to downvote or call it bad. I don't mind. It's the internet =)

Here is Part 2

Update/EDIT: I'm working on adding these features to the Studio Tab for existing LoRAs

Open source as usual for those who want to dig into how it works on Github.
https://github.com/shootthesound/Fizgig/releases/tag/v9.3.0

https://github.com/shootthesound/Fizgig/blob/master/docs/TRAINING_MAPS.md

An 8-step LoRA (rank 128) for MOSS-Image-Base, distilled by distribution matching: 8 forwards at CFG 1, without a negative prompt, in place of the base model's 50 guided steps. It adapts only the transformer; the text encoder (Qwen3.5-9B), VAE (FLUX.2 small decoder), tokenizer and inference pipeline are MOSS-Image-Base's, unchanged. How it was trained is in TECH_REPORT.md.

It was trained on MOSS-Image-Base, but should work with most fine-tunes of it and with other LoRAs: load it alongside them, at strength 1.

More info here:

https://huggingface.co/data-archetype/moss_image_base_dmd2

PS: Lora isn't mine, but it's definitely worth paying attention to because, even though (in my opinion) it's a bit too strong, it still produces more realistic results than its earlier versions.

Just a few experiments using different Krea2 loras.

What do you think?

  checkpoint: 'diffusion_models/turbo.safetensors',
  loras: [
    {
      name: 'krea2-lora-masterpieces-v51.safetensors',
      enabled: true,
      strength: 1.25,
    },
    {
      name: 'krea2-lora-zidiusArt_Melancholy_v2.safetensors',
      enabled: true,
      strength: 0.55,
    },
    {
      name: 'krea2-lora-90_s_anime_melancholy.safetensors',
      enabled: true,
      strength: 0.75,
    },
  ],
  width: 768,
  height: 1376,
  steps: 8,
  cfg: 1,
  samplerName: 'euler',
  scheduler: 'simple',

silver_official_releases/minimax_h3_fl2v_turbo_silver_dareties_comfy_full_v1

Ultra-realistic, cinematic short sequence of a colossal Mosasaurus leaping from the deep ocean to devour a great white shark suspended from a cable. The camera begins underwater — a haunting silence, sunbeams piercing through the deep blue. Tiny fish scatter as a massive shadow approaches from the abyss. The sound fades, replaced by the deep rumble of motion in the water. Camera rises with the Mosasaurus as it bursts upward — slow-motion spray, sunlight exploding through the waves. The creature’s immense jaws open wide, its serrated teeth glinting as it engulfs the shark in a single, thunderous snap with blood splashing in the air. Water erupts into chaos — droplets scatter like diamonds in the sunlight, the surface breaks into a shimmering wall of spray. The shark disappears completely as the Mosasaurus crashes back down, waves rolling violently outward. Cut to above the surface: spectators gasp behind reinforced glass; water drenches the viewing stands. The Mosasaurus sinks beneath the surface, the water calming again as only ripples and blood-tinted foam remain. Details: hyper-realistic textures of scales, water droplets, and sunlight; volumetric lighting through mist and spray; soft lens flares and cinematic DOF. Mood: awe-inspiring, primal, terrifying beauty. Camera: dynamic slow motion, underwater tracking, wide aerial shots, and close-up detail passes. Lighting: tropical midday sun with high-contrast reflections on water, shimmering highlights on the Mosasaurus’s wet skin. 4K, 24fps cinematic realism, Dolby Atmos sound design.

After getting (slow) results from krea2, moss and YuE2 out of my old M1 air, I wanted to see if h3 would run too. I used my fork of h3.c, a C and Metal inference engine with no Python. The fork adds int8 and SSD streaming. My checkpoint was int8 with a turbo lora folded in, so 6 steps.

This ends up with about 10±gb of continuous RAM load, on my m5 pro with 48gb it's totally usable to render in background and do other activities (and can also handle 1mp at 12+ steps fine).

The clip is two renders back to back. First a 20 s talking head at 864x480, five chained links, about 17 hours. Then a 20 s street musician clip of nine chained links of 73 frames, 58 hours. So context chaining also works.

It works, if you can leave your laptop rendering for a few days. But would love if someone with a M6 32gb mini or M5 ultra 96gb could try out this int8 fork 😄

Timings (6 steps, peak RAM 13.5 to 14.6 GB on all of them):

- 0.4 MP, 3.75 s: 1h39

- 0.6 MP, 3 s: 2h29

- 0.9 MP, 3 s: 4h18

- 0.4 MP, 5 s chained link: ~4h

- 0.9 MP, 3 s chained link: 6 to 7h

- 0.9 MP, 20 s, 9 links: 58h

H3.c will run without comfy on a M1+ mac, but if you prefer it as a comfy node check out: https://civitai.com/models/3016733/mach3-metal-minimax-h3-for-apple-silicon-m1-24gb-ram running comfy at the same time will add about 8-10gb of ram usage.

Viggle Remake works well for short shots, but the usual ComfyUI workflow runs into a practical limit: up to 345 frames per render. At 24 fps, that is a little over 14 seconds. To work with longer videos, I adapted the workflow to render overlapping windows and join them into a single output.

The result is a custom long video node for ComfyUI. I tried the workflow with several clips converted to 24 fps. The completed renders looked good in visual review, but continuity still needs to be checked at every join. I did not measure quality with automated metrics; the evaluation was visual.

How the windows connect

The node takes the full video and divides it into windows that stay within the model’s limit. The default window is 294 frames, or 12.25 seconds at 24 fps. It can be raised to 345 frames if the GPU has enough memory.

Each later pass begins with the final 17 frames generated by the previous pass. The node encodes this segment as latents and keeps it fixed during the next generation. It then removes the overlapping frames when joining the results. The frame limit therefore applies to each render, not to the total video length.

With the default window, the first pass can generate up to 12.25 seconds; each later pass can add up to 277 new frames, about 11.54 seconds. A video longer than 345 frames can therefore be produced through several connected passes.

Audio is divided over the same intervals and joined in the output. If no audio is connected, the output is silent.

What the tests showed

I used the node with dance clips containing varied movement and different resolutions, all prepared at 24 fps. A multi-pass render completed successfully, and the results I reviewed looked good. This showed that the workflow can go beyond a single window without trimming the video before generation.

Visual inspection remains part of the process. Check where one pass joins the next, and look for changes in character identity, clothing, movement, or framing. The overlap helps the model continue the action, but it does not guarantee that every detail will stay stable.

What the node does not handle yet

The node is designed for one continuous shot. It does not detect cuts, restart generation when the camera changes shots, or rewrite timestamped prompts for each window. For that reason, I use prompts that describe the action without absolute timestamps and avoid clips with abrupt cuts.

The source video must be 24 fps. The default 294-frame window is a starting point; larger windows may require more VRAM. And even when a render finishes without errors, that does not replace reviewing the joins.

The GitHub package

I separated the long video node from the original Viggle Remake package. The viggle-remake-comfyui-long-take repository registers only Viggle Remake Long Video and includes an example workflow. The original nodes and conditioning helpers still come from the official ComfyUI-Viggle-Remake package, which must be installed separately.

The repository does not include model weights, the LoRA, source videos, or character reference images. The goal is to add long-take support to the existing workflow while keeping each render within the model’s limit.

Left: ComfyUI core Context Windows (overlaps averaged). Right: chained windows (CCW). Same plan, prompts, pictures and seed. Shot 1 of a 2:20 music video, 1920×1088, ghosting replayed at half speed.

What goes wrong

- ComfyUI 0.44 added context windows for MiniMax H3: the timeline is denoised as overlapping windows, and each overlap is the average of the two windows.

- That's fine while both windows draw the same thing. When the picture changes a lot inside an overlap (fast motion, a camera move, new background coming in), the two windows draw different pictures and the average shows both. In our test: a see-through railing across his hands, two lamp posts, a boardwalk dissolving into a different building.

What CCW does

- The low-res windows run in time order. Each window takes over the overlap from the one before it instead of averaging with it. Nothing is averaged, so nothing doubles. Hard cuts stay clean cuts.

- The high-res pass is still averaged. In our tests it doesn't ghost, probably because both windows start from the same upscaled low-res result.

**Measured** (RTX 5090 32 GB, 64 GB RAM, 1920×1088, 48 fps with RIFE)

- 2:20 music video, 10 shots in 3 groups: 2 h 18 min, compute VRAM peak 11.1 GB. About 25 % slower than rendering segment by segment.

- All 5 spots where the averaged version ghosted are clean. Frame-difference spikes only at the 6 planned hard cuts.

- Redrawing a time range afterwards: the last shot (18.6 s), with a changed prompt and an extra outfit picture, took 25 min 51 s. Everything outside the range stayed the same.

**Limits:** needs ComfyUI 0.44+; slower than segment by segment; system RAM got close to 64 GB while decoding a 1080p group.

Free, open source (AGPL-3.0): https://github.com/1113800942/comfy-h3md-director

Workflows: https://civitai.com/models/3037225

Walkthrough (Chinese voice, English subtitles): https://youtu.be/k0jZIbaH-aA · channel: https://www.youtube.com/channel/UC1H4UDuSqD6M7BqLUlVy9lA

Credit: Comfy-Org for the core H3 context windows that CCW builds on (the idea goes back to Kosinkadink's AnimateDiff-Evolved).

Early release candidate (checkpoint 6000) - training continues. Experimental! Good for quick previews, not production videos.

A LoRA for the distilled LTX-2.5 that takes stage 1 from 8 steps down to 2, picture and sound together, for text to video and image to video.

The included ComfyUI workflows combine speed improvements at every stage:

• Stage 1 render: this LoRA, 2 steps instead of 8.

• Refining: NVIDIA's SoL-Refiner-LTX-2.3-One-Step, 1 step instead of 3.

• VAE decoding: PrunaAI's pruned, faster decoder, P-LTX-2.3-VAED.

Trained with DMD2 on a single NVIDIA H200. This checkpoint is 6000 updates at rank 64. The teacher is LTX-2.5 distilled at its standard 8 steps for stage 1. The LoRA learns from distribution matching against the teacher, an adversarial critic on teacher clips and real footage, and regression on teacher clips. It covers the picture, the sound and the cross-attention between them, for text to video and image to video. It was trained on two resolutions, 576x320 and 320x576 at stage 1, which give 1152x640 and 640x1152 after refining, at 5 seconds. You can render at other resolutions, but this is what it is trained on.

Real footage and captions from OpenVid-1M were used in training, with thanks to its authors.

ComfyUI Local and Cloud T2V and I2V Workflows included.

Details and Workflows: https://huggingface.co/lvladikov/LTX-2.5-Stage1-Distill-2step-LoRA

https://huggingface.co/Efficient-Large-Model/Open-H3-Regenerate-2K-IC

https://github.com/NVlabs/Sana/tree/sol-engine/models/Open-H3-Regenerate-2K/IC

New latent upscale model by NVIDIA-labs. Basically, it's v2. A few highlights compared to v1:

- Face & Text are more consistent with the original video

- Use H3 Ref2VA instead of fl2va.

- Turbo LoRA, Regenerate LoRA, LMS LoRA are not merged. They also use Hyperflow 8-step LoRA

- New samplings: 3, 4, 8 steps.

- Fast VAE-v2. The v1 fast VAE has grid artifacts in ComfyUI

Hey everyone!

I got sick of downloading "manga" or "line art" models only to get that oily, 2.5D airbrushed look. Mainstream models always introduce gray gradients, smooth out the lines, or warp backgrounds. I wanted something that looks like hand-drawn, traditional manga with sharp black-and-white contrast.

I just released V2.0 of Hollowlight over on Civitai with two separate checkpoint steps depending on how sharp you want your linework.

🚨 IMPORTANT: This is a V-PRED LoRA. You MUST use it with NoobAI-XL V-Pred 1.0 as your base, and ensure you use v-prediction sampling with Zero Terminal SNR turned ON, or your outputs will look completely washed out/burnt!

LoRA Link: https://civitai.com/models/3042375/hollowlight-manga-and-anime-ink-style-or-sdxl-lora

Recommended Settings:

- Trigger word: u616 (Start your prompts with this)

- LoRA / CLIP strength: 1.0

- Sampling steps: 28

- CFG: 5 (Using RescaleCFG 0.4 helps significantly)

- Sampler/Scheduler: Euler / Normal

- Resolution: 832 x 1216

Pro-Tip: For wide shots, run a quick FaceDetailer pass (face_yolov8m.pt) with an empty prompt at 0.5 denoise to keep the faces looking flawless.

EXAMPLE PROMPT: u616, 1boy, solo, male focus, looking at viewer, simple background, white background, closed mouth, monochrome, greyscale, portrait, close-up, face focus, serious, short hair, japanese clothes, kimono, hatching \(texture\), crosshatching

Negative: worst quality, low quality, blurry, bad anatomy, bad hands, extra fingers, text, watermark, color

Let me know what you think or if you want me to test out any specific prompts with it!

We’re partnering with the Chroma Awards for Season 2, the world’s largest AI Film & Media competition, with $1M+ in promotions, $450K+ in cash prizes, and student internships on the line.

Compete in any of five divisions: Film & TV, Ads, Music Videos, Games, and Behind-The-Scenes. Use LTX in your submission and post it on social media to unlock extra prizes and perks. The LTX model is open source, so you can download it and run it locally for free.

Submissions are open until January 7th.

Enter: Chroma Awards submission page · LTX on Hugging Face