DEV Community: AI-KSK

Qwen 2511 Masked Repaint: Crop the Masked Block, Edit with a Reference, Paste It Back Seamlessly

AI-KSK — Sun, 08 Nov 2026 16:29:37 +0000

Editing a small region of a large image with a diffusion model normally forces you to downscale the whole picture and lose the detail you cared about. This graph takes the opposite route: paint a mask, crop that region out with padding information, repaint only the crop - with a reference image if you want object transfer - then paste the result back at full resolution.

Evidence note: parameters below were parsed from the workflow JSON shipped with this episode (2 files); anything the video reports about results is attributed to the author.

When this is useful

You need to change one object in a high-resolution image without downscaling it.
You want to put an object from a reference image into a masked region ("everything transfer").
You want a reusable paste-back step rather than manual compositing.

The three-stage construction

Why the native nodes failed

When 2511 launched the author tried building masked repaint from ComfyUI's native nodes; he says the results failed completely.

This graph relies on Xiaozhi's node plugin (his name in the episode). The author swapped the models in the plugin's example workflow and confirmed it still runs stably - that is the version shipped here.

Stage 1: mask, then crop with padding info

Load an image, right-click into the mask editor, paint the region, then prompt. The graph crops a square around your mask and sends only that block onward.

The crop node carries padding info so stage 3 can put the block back exactly where it came from - that is the difference between a seamless paste-back and a visible patch.

Crop policy differs by role: the main image uses pad/fill because you do not want to lose content, while the reference image uses crop.

Stage 2: repaint, text-only or with a reference

Text-only guidance works: the author's example turns an astronaut into a woman.

For object transfer, add a second image as the reference input. This is the "everything transfer" mode.

The image feeding is done through a preparer node rather than wiring straight into the text encode, and it accepts a mask input natively.

The numbers that matter

Longest-edge limit 2048: this is an upper bound on the longest edge to avoid running out of VRAM or producing bad results, not a resize. The author finds 2048 rendering fine on 2511 - except a 2048x2048 square.

384 is the visual encoder's encoding size. It was the same on 2509, which the author reads as 2511 having no major architectural change.

Model: 2511 plus the 4-step accelerator - the configuration he has used since day one.

Want a bigger repaint block? Raise the initial image size at the start; the crop that follows grows with it.

How to run it

Open the repaint-and-paste-back graph and load the target image.
Right-click into the mask editor and paint the region you want to change.
Write the prompt; add a reference image if you are transferring an object.
Keep the longest-edge limit at 2048 as a VRAM guard rather than a resize.
Run: the graph crops a padded square, repaints it with 2511 + the 4-step accelerator, and pastes it back.
If the repainted block is too small, raise the initial image size rather than editing the crop settings.

Parameter basis

重绘贴回 2511局部重绘万物迁移 - 54 nodes

Item	Value (from JSON)
UNET loader	`qwen_image_edit_2511_fp8mixed.safetensors` / default
CLIP loader	`qwen_2.5_vl_7b_fp8_scaled.safetensors` / qwen_image
VAE	`qwen_image_vae.safetensors`
KSampler	steps 4 · cfg 1 · euler · sgm_uniform · denoise 1
LoRA	`Qwen-Edit-2511-Lightning-4steps-V1.0-bf16.safetensors` @ 1

重绘贴回 2511局部重绘 - 55 nodes

Item	Value (from JSON)
UNET loader	`qwen_image_edit_2511_bf16.safetensors` / default
CLIP loader	`qwen_2.5_vl_7b_fp8_scaled.safetensors` / qwen_image
VAE	`qwen_image_vae.safetensors`
KSampler	steps 4 · cfg 1 · euler · sgm_uniform · denoise 1
LoRA	`Qwen-Edit-2511-Lightning-4steps-V1.0-bf16.safetensors` @ 1; `Qwen-edit-2511-multiple-angles.safetensors` @ 1

Honest limits

Depends on a third-party node plugin; without it the native ComfyUI route does not work (per the author's own attempt).
A 2048x2048 square is called out as the case that does not hold up.
Paste-back seams depend on the padded crop; moving or resizing the block afterwards breaks the alignment.
The "strongest open-source edit model" framing is the author's opinion, not a measured comparison.

Episode resources

RunningHub - 重绘贴回 2511局部重绘万物迁移: https://www.runninghub.ai/post/2017885601479004162/?inviteCode=rh-v1111
RunningHub - 重绘贴回 2511局部重绘: https://www.runninghub.ai/post/2018213964676603905/?inviteCode=rh-v1111
YouTube tutorial: https://www.youtube.com/watch?v=nlkrfEaScM0
Bilibili original: https://www.bilibili.com/video/BV1SK68BwE33

InfiniteTalk Goes Native in ComfyUI: Single and Dual Lip-Sync Loops, Plus the LTX-2 Distilled Route

AI-KSK — Sun, 08 Nov 2026 16:29:33 +0000

InfiniteTalk is a Wan 2.1-based lip-sync method, and ComfyUI now supports it natively - the author says faster and better than the earlier KJ implementation, with only minor degradation for two-person shots. The interesting part is the loop: feed the rendered clip back as the next segment's first frame, compute the iteration count from the audio length, and you get near-infinite duration. The episode also updates the LTX-2 distilled talking-head graph.

Evidence note: parameters below were parsed from the workflow JSON shipped with this episode (4 files); anything the video reports about results is attributed to the author.

When this is useful

You need a talking clip longer than the ~3-second first window.
You have one portrait and one audio track and want a repeatable loop.
You want two characters alternating lines from a single image.

How the infinite loop is built

First segment, then extend

The first generation takes 81 frames, about 3.24 seconds at 25 fps - and the author says do not change that frame rate.

The loop is deliberately simple: the previous clip goes into Value 1, Value 1 feeds Talk-to-Video, the output goes to Batch Image, and the rendered clip is wired back into Value 1.

Each extension adds 72 frames (81 minus 9), i.e. about 2.8 seconds per loop.

The loop count is arithmetic, not guesswork

Detect the audio length in milliseconds, subtract 3240 ms (the first 81-frame segment), divide by 2880 ms (each 72-frame extension), and round up. That is the iteration count.

With that, the whole thing is close to automatic: you supply image, audio, start second and length, width and height.

480P, not 720P - and why

The model is the 480P image-to-video build. The author is explicit that the 720P model is unnecessary and gives worse results - on his non-human test character the mouth did not move at all.

SkyReels V3, a newer audio-to-video model, performs roughly on par with the 480P model, so either is fine here.

The graph follows the official example; the author does a vocal separation pass before feeding audio, to keep other noise from disturbing the lip-sync.

Two people: two audios, one image, two masks

The dual graph takes two audio tracks - character 1's lines, then character 2's - and two images that are actually the same image, differentiated by painting each speaker's region in the mask editor.

The author's honest read: two-person output is still mostly "one talks, then the other". True multi-turn dialogue is not there yet; he expects it eventually.

480P looks soft, so he runs FlashVSR upscale over the result - which he says cleans it up a lot.

The LTX-2 distilled talking head

The LTX-2 lip-sync graph is updated from an open-source Hugging Face project that released its workflow.

The first render uses the distilled model - you can see 8 steps in the sigma values. The Camera Control LoRA is critical for keeping the shot stable; bypassing it visibly hurts results, so leave it on.

You load an image and set width, height and frame count; frame rate and length are computed. His example renders 289 frames, and he says ComfyUI's LTX-2 optimisation now makes 500-600 frames per run feasible - effectively near-infinite duration in one pass.

LTX-2 prompts are sensitive, especially for non-human characters; that is also where LTX-2 has a natural edge over portrait-only pipelines.

How to run it

Open the single-person InfiniteTalk graph; load one image and one audio track.
Set the audio start second and the length to process, then width and height.
Run: the first segment is 81 frames at 25 fps (~3.24 s).
Extend by looping - previous clip into Value 1, back through Talk-to-Video and Batch Image.
Compute the loop count as ceil((audio_ms - 3240) / 2880) so the length matches the audio.
For two people, use the dual graph: two audios, the same image twice, two painted masks. Then run FlashVSR to sharpen.
For the LTX-2 route, load an image, set width/height/frames, and leave the Camera Control LoRA on.

Parameter basis

FlashVSR V1.1放大 - 4 nodes

No UNET/CLIP/VAE sampler chain in this graph - it is a processing or composite graph. Node inventory: FlashVSRNode, VHS_LoadVideo, VHS_VideoCombine, LayerUtility: ImageScaleByAspectRatio V2 (4 nodes).

Ltx 2蒸馏对口型 - 106 nodes

Item	Value (from JSON)
UNET loader	`LTXVideo\v2\ltx-2-19b-distilled-fp8_transformer_only.safetensors` / default
Dual CLIP	`gemma_3_12B_it_fp8_scaled.safetensors` + `ltx-2-19b-embeddings_connector_distill_bf16.safetensors`
VAE	`LTX2_video_vae_bf16.safetensors`
Latent size	768x512 · 241 frames · batch 1
LoRA	`LTX\v2\ltx-2-19b-distilled-lora_resized_dynamic_fro09_avg_rank_175_bf16.safetensors` @ 0.6; `ltx-2-19b-distilled-lora_resized_dynamic_fro09_avg_rank_175_bf16.safetensors` @ 0.6; `ltx-2-19b-lora-camera-control-static.safetensors` @ 1

单人InfiniteTalk无限时长原生循环 - 68 nodes

Item	Value (from JSON)
UNET loader	`SkyReelsV3-A2V_fp8_scaled_mixed.safetensors` / default
CLIP loader	`umt5_xxl_fp8_e4m3fn_scaled.safetensors` / wan
VAE	`Wan2.1_VAE.pth`
BasicScheduler	steps 4 · scheduler normal · denoise 1
BasicScheduler	steps 4 · scheduler normal · denoise 1
LoRA	`lightx2v_I2V_14B_480p_cfg_step_distill_rank64_bf16.safetensors` @ 1; `Wan_2_1_T2V_14B_720p_rCM_lora_average_rank_94_bf16.safetensors` @ 0.3

双人InfiniteTalk无限时长原生循环 - 65 nodes

Item	Value (from JSON)
UNET loader	`wan2.1_i2v_720p_scaled_fp8_e4m3_lightx2v_comfyui.safetensors` / default
CLIP loader	`umt5_xxl_fp8_e4m3fn_scaled.safetensors` / wan
VAE	`Wan2.1_VAE.pth`
BasicScheduler	steps 4 · scheduler normal · denoise 1
BasicScheduler	steps 4 · scheduler normal · denoise 1
LoRA	`Wan_2_1_T2V_14B_720p_rCM_lora_average_rank_94_bf16.safetensors` @ 0.3; `lightx2v_I2V_14B_480p_cfg_step_distill_rank64_bf16.safetensors` @ 1

Honest limits

The 25 fps is fixed by the 81-frame / 3.24 s arithmetic; changing it breaks the loop count.
Two-person output is still sequential, not true multi-turn dialogue - the author says so.
480P is soft; without an upscale pass the result looks unclear.
The loop extends duration, not expressiveness: drift accumulates over many iterations.
Frame counts of 500-600 per run are the author's report under ComfyUI's current optimisation, not a hard limit.

Episode resources

RunningHub - FlashVSR V1.1放大: https://www.runninghub.ai/post/2018310765513547778/?inviteCode=rh-v1111
RunningHub - Ltx 2蒸馏对口型: https://www.runninghub.ai/post/2018224320958439425/?inviteCode=rh-v1111
RunningHub - 单人InfiniteTalk无限时长原生循环: https://www.runninghub.ai/post/2018256491320451073/?inviteCode=rh-v1111
RunningHub - 双人InfiniteTalk无限时长原生循环: https://www.runninghub.ai/post/2018267797146570753/?inviteCode=rh-v1111
YouTube tutorial: https://www.youtube.com/watch?v=OjsHOyPtF0s
Bilibili original: https://www.bilibili.com/video/BV1mwFLzTELL

LTX-2 Adapter LoRA: Image-to-Video Consistency at 60fps, Distilled vs Full-Quality Graphs

AI-KSK — Sun, 08 Nov 2026 16:29:03 +0000

LTX-2 image-to-video had a known failure: when the described motion was not strong enough, the model produced a nearly static clip. This episode tests the Adapter LoRA update, which the author says fixes that and improves consistency, motion coherence and generalisation - and ships two graphs at 60 fps 1080p, one full-quality and one distilled.

Evidence note: parameters below were parsed from the workflow JSON shipped with this episode (2 files); anything the video reports about results is attributed to the author.

When this is useful

Your image-to-video clips come out too static when the prompt is modest.
You need 60 fps at 1080p from a single reference image.
You want a quality-first and a cost-first graph for the same model family.

Two graphs, one adapter

The adapter fixes the static-clip problem

The Adapter LoRA is trained on top of earlier LTX-2 video work. The concrete failure it addresses: when the text is not explicit enough about motion, the base model would simply not move.

The author reports improved character consistency (in his 10-second two-person example), better motion coherence, better style retention and stronger generalisation.

Non-distilled graph: 25 steps, then 2x upscale

The full-quality graph runs 25 steps in the first pass without an accelerator, then a second sampling pass that does a 2x upscale.

The second pass can use an accelerated model - the author always has. Because the accelerated path runs at CFG 1, the negative prompt is inert there, which is why he wires the LTX-2 negative-prompt enhancement node to make negatives count again.

The prompt side has an automation: paste the official system prompt, then write a short description and a language model polishes it into the final prompt.

Distilled graph: 8 steps, merged adapter, uncensored

The distilled graph swaps in the V6.2 merged model, which is uncensored-capable and has the Adapter LoRA merged in - so the LoRA slot stays empty on purpose.

It is designed to produce good results in 8 steps on the first pass. The author's sample deliberately uses large motion to stress it, and says the amplitude is a prompt choice, not a fixed property.

Audio generation is also improved in this build, per the author.

Negative keywords worth stealing

The distilled path uses the LTX-2 negative-prompt node; the three values control how strongly the negative applies.

Concrete use: put subtitle-related words in the negative keywords so the model does not burn Chinese subtitles into the frame - a small trick that solves a recurring annoyance.

How to run it

Open the graph you want: non-distilled for quality, V6.2 distilled for throughput.
Set width, height and length in seconds, then the frame rate - the author runs 60 fps without trouble.
Write positive and negative prompts; for the non-distilled graph the negative prompt is active.
Non-distilled: run the 25-step first pass, then the 2x upscale second pass.
Distilled: run 8 steps; the adapter is merged, so do not add the LoRA again. Use the negative-prompt node and put subtitle words in the negative keywords if the model keeps burning text into frames.

Parameter basis

ltx2_i2v去蒸馏图到视频一致性60帧1080p - 54 nodes

Item	Value (from JSON)
UNET loader	`ltx-2-19b-dev-fp8_transformer_only.safetensors` / default
Dual CLIP	`gemma_3_12B_it_fp8_e4m3fn.safetensors` + `ltx-2-19b-embeddings_connector_bf16.safetensors`
VAE	`LTX2_video_vae_bf16.safetensors`
Latent size	768x512 · 97 frames · batch 1
LoRA	`ltx-2-19b-distilled-lora_resized_dynamic_fro09_avg_rank_175_bf16.safetensors` @ 0.6; `LTX-2-Image2Vid-Adapter.safetensors` @ 1

ltx2_i2v蒸馏图到视频一致性60帧1080p - 54 nodes

Item	Value (from JSON)
UNET loader	`ltx2-phr00tmerge-nsfw-v62.safetensors` / default
Dual CLIP	`gemma_3_12B_it_fp8_e4m3fn.safetensors` + `ltx-2-19b-embeddings_connector_bf16.safetensors`
VAE	`LTX2_video_vae_bf16.safetensors`
BasicScheduler	steps 8 · scheduler simple · denoise 1
Latent size	768x512 · 97 frames · batch 1
LoRA	`LTX-2-Image2Vid-Adapter.safetensors` @ 1

Honest limits

Distilled + CFG 1 means the negative prompt is off unless the LTX-2 negative node is wired; that is a graph detail people miss.
The distilled build is uncensored-capable, which shifts responsibility to the user.
60 fps at 1080p is what the author ran, not a guaranteed ceiling on smaller cards.
Consistency improvement is described qualitatively; no numeric metric is given.
The 10-second two-person example is one sample, not a benchmark set.

Episode resources

RunningHub - ltx2_i2v去蒸馏图到视频一致性60帧1080p: https://www.runninghub.ai/post/2019396485409939457/?inviteCode=rh-v1111
RunningHub - ltx2_i2v蒸馏图到视频一致性60帧1080p: https://www.runninghub.ai/post/2019439198570287106/?inviteCode=rh-v1111
YouTube tutorial: https://www.youtube.com/watch?v=VYBoOk7pCJA
Bilibili original: https://www.bilibili.com/video/BV1wiFzzwEoR

LTX-2 Rapid Merge: Uncensored Merged Model, Updated Adapter LoRA, Four Workflows in One Image

AI-KSK — Sun, 08 Nov 2026 16:28:59 +0000

This is a merged LTX-2 checkpoint from the same author who did the Wan-era merges, now with the Adapter LoRA update folded in. The claim is better video quality as well as uncensored output, and the episode packages four graphs - text-to-video, image-to-video, first/last frame, and lip-sync - into one image. The notes are practical: what each widget does, which ones are inert in which mode, and how long a 1080p / 121-frame run takes.

Evidence note: this episode ships no workflow JSON. Every claim below comes from the episode subtitles/description and the published page; no node-level parameter is invented.

When this is useful

You want an LTX-2 merge that runs from one deployable image instead of hand-assembling nodes.
You need both an SFW and an uncensored checkpoint available without switching images.
You are deploying LTX-2 on a consumer GPU and want the author's known-good settings.

What is in the image

Four graphs, fully localised

The image ships four workflows: text-to-video, image-to-video, first/last-frame, and image-to-video lip-sync. The UI strings are translated to Chinese.

Two checkpoints are bundled - an SFW and an NSFW build - so you switch model rather than switching image.

The author recommends renting a consumer-grade GPU: ComfyUI's LTX-2 optimisation is good enough that a datacentre card is not required.

Settings that matter in text-to-video

Width, height, source frame rate, and output frame rate set to 48 - because the graph interpolates 2x afterwards. Then the frame count and the output directory (default is fine).

First-frame and last-frame strength are exposed; the last frame is what the first/last-frame mode uses. In pure text-to-video both strengths are inert.

Output frame range 0:-1 means no crop. The range exists so you can trim a strange head or tail frame when a run produces one.

Cost reference from the author: a 1080p, 121-frame generation takes a bit over 70 seconds.

Image-to-video and the compression-artifact dial

Image-to-video adds an image loader, and now the first-frame strength actually applies.

A compression-artifact setting becomes active: raise it for a blurry, noisy source, lower it for a clean one. ComfyUI's default is 33; this flow ships 28.

First/last frame is the same graph with a second image slot.

Lip-sync

The lip-sync graph is the earlier RunningHub distilled lip-sync flow adapted to this merged model.

You set width, height and frame rate; the frame count is computed from the audio. The author's example audio is 18 seconds - extract the vocals, trim to the section you want (his example uses 5 seconds), and the graph derives a sensible length from it.

How to run it

Register on the compute platform (the episode says registration grants some free hours), find the LTX2-Rapid-Merges image, and deploy an instance on a consumer GPU.
Copy the startup command from the image page, paste it into JupyterLab, and wait for ComfyUI.
Open the workflow panel and choose text-to-video, image-to-video, first/last frame or lip-sync.
Set width, height and source fps; set output fps to 48 because the graph interpolates 2x.
Set the frame count and keep the output range at 0:-1 unless a bad head or tail frame needs trimming.
For image-to-video, load the image and set the compression-artifact value - 28 in this flow, 33 is the ComfyUI default; raise it for noisy sources.

Parameter basis

No workflow JSON in this episode. No node-level parameters are claimed; the description is limited to what the video and the published page state.

No JSON ships with this episode, so no sampler values are quoted. The numbers above (output fps 48, frame range 0:-1, compression artifact 28 vs 33, 121 frames / 1080p / ~70 s) are the values the author states in the video.

Honest limits

No workflow JSON and no mirror URL were recorded for this episode - the deployment pointer lives only in the video description, so this write-up documents behaviour, not a redistributable file.
The 70-second figure is the author's observation for 1080p / 121 frames on his rented card, not a benchmark.
First/last-frame strengths are inert in text-to-video; setting them there does nothing.
The merge's quality claims are the author's; no side-by-side against the upstream LTX-2 build is shown.
Uncensored output shifts responsibility to the user - local rules and platform terms still apply.

Episode resources

YouTube tutorial: https://www.youtube.com/watch?v=bjdc30M_twg
Bilibili original: 无

Qwen-Image-Edit 2511 + VNCCS Pose Studio: Pose and Lighting Control Without Opening a 3D App

AI-KSK — Sun, 08 Nov 2026 16:28:30 +0000

Keeping one character consistent while changing the pose usually means a round trip through Blender or Poser. VNCCS Pose Studio puts the mannequin, the pose and the lighting inside ComfyUI, and the 2511 editing model takes three images from it - the pose render, your source image, and the detected skeleton. The author reports the pose control is very precise, and shows that the node also pushes a lighting prompt unless you switch that off.

Evidence note: parameters below were parsed from the workflow JSON shipped with this episode (1 file); anything the video reports about results is attributed to the author.

When this is useful

You need one character in a new pose without losing the face or costume.
You want to light the character without leaving ComfyUI.
You batch several poses from the same source image.

How the three-image encoding works

Three images into one text-encode node

The graph feeds three images into the Qwen-Image-Edit-Plus text-encode node: the pose render from Pose Studio, the source image you loaded, and the skeleton image the node detects from your target pose.

The node is not only a pose editor - it combines mannequin building, posing and lighting - which is why no external software is needed.

The author hand-built this graph because the RunningHub side had not yet picked up the project's example workflow; the project is open source and the example graphs ship with it.

The controls you actually touch

Body: gender, age, weight, muscle, height, head size - the author's description is simply "you are building a person here".

Rotation: chest size plus XYZ sliders that rotate the whole character rather than one bone.

Camera: the output width and height, the zoom and the orientation radar; the author recommends keeping the same aspect ratio as the source image, and reset re-centres the camera on the character.

Lighting, and the switch that matters

The node emits a lighting prompt, so results are affected by light even when you only wanted a pose change. There is a keep-light option: click it and the original lighting is preserved.

Background: you can load an image purely to align a pose to it. Lighting can be added, kept or removed individually.

Output modes

With several poses defined (pose 1, pose 2, ...) you can either output an image list or have the node concatenate them into one sheet, with a per-row count you set.

There is undo, redo, reset preview, copy/paste and import/export for the pose state - it is a small editor, not a one-shot node.

How to run it

Load one image - background or no background both work.
Pose the mannequin in the node; press reset if the camera drifts off the character.
Keep the output aspect ratio equal to the source image's ratio; the author scales by pixels.
Feed the three images into the Qwen-Image-Edit-Plus text encode (pose render, source, skeleton).
Choose whether to keep the original light, or let the node's lighting prompt apply.
Run; if you defined several poses, pick list output or a concatenated sheet.

Parameter basis

一致性姿态与光影控制VNCCS Pose Studio+2511 - 25 nodes

Item	Value (from JSON)
UNET loader	`qwen_image_edit_2511_bf16.safetensors` / default
CLIP loader	`qwen_2.5_vl_7b_fp8_scaled.safetensors` / qwen_image
VAE	`qwen_image_vae.safetensors`
KSampler	steps 4 · cfg 1 · euler · simple · denoise 1
LoRA	`VNCCS_PoseStudioQIE2511_V2.safetensors` @ 1; `Qwen-Image-Edit-2511-Lightning-4steps-V1.0-bf16.safetensors` @ 1

Honest limits

One character. The graph is built for single-character consistency, not crowds.
The lighting prompt is on by default; pose-only edits need the keep-light switch.
Aspect ratio has to follow the source image, so exotic output shapes are not the target.
The graph was hand-built against a project version RunningHub had not yet mirrored; upstream example graphs may differ.

Episode resources

RunningHub - 一致性姿态与光影控制VNCCS Pose Studio+2511: https://www.runninghub.ai/post/2020409094468800513/?inviteCode=rh-v1111
YouTube tutorial: https://www.youtube.com/watch?v=iTMudoGSbBA
Bilibili original: https://www.bilibili.com/video/BV1iTcwzJEtD

Seedance 2.0 Post-Production in ComfyUI: Watermark Removal, GIMM Frame Interpolation, FlashVSR Upscale

AI-KSK — Sun, 08 Nov 2026 16:28:26 +0000

Seedance 2.0 clips come out of Xiaoyunque with a corner watermark and a modest frame rate. This episode chains two ComfyUI graphs to fix both: a MiniMax remover built on the early Wan 2.1 work to take the watermark out by masking it, then a GIMM interpolation pass and a FlashVSR upscale. The author reports the watermark is "almost gone" and the upscaled result reaches roughly 2K after a 960-pixel constraint.

Evidence note: parameters below were parsed from the workflow JSON shipped with this episode (2 files); anything the video reports about results is attributed to the author.

When this is useful

You generate clips yourself and want them clean and high-frame-rate before editing.
Your delivery target wants 32 or 60 fps from a 16 fps source.
You need a repeatable post chain instead of a one-off manual fix.

Two graphs, two jobs

Watermark removal

Load the video. If your clip did not come from Xiaoyunque and the watermark is not in the bottom-right, run the graph once while keeping the first frame, then paint the mask on that frozen frame - the author also paints the top-left when the mark is there.

Constrain the size, then write a prompt describing what is under the mask. The graph masks the watermark area in grey and lets the model inpaint it.

The model is MiniMax's early video watermark remover built on Wan 2.1. It is self-accelerating; the author adds a LightX2V accelerator as insurance for better results.

Interpolation, then upscale

The second graph is a straight line: load the source, set the interpolation multiplier, set the upscale multiplier, run.

The author's settings: 2x interpolation with the source locked at 16 fps (so 32 fps out) and 3x upscale after a 960-pixel size constraint, which lands close to 2K.

Frame interpolation first, upscale second - the author does not reverse that order.

Where the clips come from

The source is Xiaoyunque's web app (a Jianying/CapCut platform), using Seedance 2.0 in "immersive short film" mode. You upload references with the plus button and can address them as @图1, @图2 in the prompt, which the author notes also sidesteps some input restrictions.

Daily login gives one free clip of up to 15 seconds; each invited friend brings 188 credits, capped at three. Face reference is flagged as not yet supported in this mode.

The 'ComfyUI is dying' argument

The episode closes on the community worry that hosted models make local workflows pointless. The author's answer is narrow and reasonable: open tooling runs offline, has no queue and no content ceiling, and stays useful as the component you use when you need a specific adjustment rather than a whole clip.

How to run it

Open the watermark-removal graph and load the clip.
If the watermark is not bottom-right, keep the first frame and paint the mask over the mark on that frame.
Constrain the output size and prompt what should appear where the watermark was.
Run; the MiniMax remover inpaints the masked region.
Open the interpolation + upscale graph, load the cleaned clip, set 2x interpolation and 3x upscale, with the size constraint at 960 px.
Render and check for interpolation artifacts on fast motion.

Parameter basis

minimax remover 视频去水印 - 26 nodes

No UNET/CLIP/VAE sampler chain in this graph - it is a processing or composite graph. Node inventory: MaskToImage, WanVideoEncode, PreviewImage, VHS_VideoCombine, WanVideoMiniMaxRemoverEmbeds, LoadWanVideoT5TextEncoder, GrowMaskWithBlur, WanVideoVAELoader (26 nodes).

视频补帧+放大 - 7 nodes

No UNET/CLIP/VAE sampler chain in this graph - it is a processing or composite graph. Node inventory: GIMMVFI_interpolate, LayerUtility: ImageScaleByAspectRatio V2, DownloadAndLoadGIMMVFIModel, FlashVSRNode, VHS_LoadVideo, PreviewImage, VHS_VideoCombine (7 nodes).

These are video-processing graphs: there is no UNET, CLIP, VAE or KSampler to quote. The only numeric settings are the ones in the node widgets (interpolation multiplier, upscale multiplier, 960-pixel constraint), which the video states and the JSON carries.

Honest limits

The remover needs a mask. It works when you tell it where the watermark is; it is not a blind detector.
The model is an early MiniMax/Wan 2.1 build, not a purpose-trained 2026 remover.
Interpolation cannot invent detail: very fast or occluded motion will smear.
Xiaoyunque's free quota (one clip per day, 15 s) and the missing face reference limit what you can source.
Removing watermarks is only appropriate on footage you own or are licensed to process - the tool has no rights model.

Episode resources

RunningHub - 视频补帧+放大: https://www.runninghub.ai/post/2021549838894108674/?inviteCode=rh-v1111
RunningHub - minimax remover 视频去水印: https://www.runninghub.ai/post/2021475821034151938/?inviteCode=rh-v1111
YouTube tutorial: https://www.youtube.com/watch?v=yp0dcysS4XY
Bilibili original: https://www.bilibili.com/video/BV1REcbzdEdn

Anima 2B: An Anime Model Trained Without a Single AI-Generated Image, From Text-to-Image to Tiled Upscale

AI-KSK — Sun, 08 Nov 2026 16:27:53 +0000

Anima is a 2-billion-parameter anime model built with Comfy Org, trained on millions of anime images and 800k non-anime artworks with no synthetic data - no AI-generated images were used to train it. This episode runs the whole path: text-to-image, image-to-image anime conversion driven by a Qwen3-VL caption pass, and tiled upscale. The model is a preview build, not an accelerated one, and it is small enough that the author reckons 6 GB of VRAM, possibly even 4 GB, can run it locally.

Evidence note: parameters below were parsed from the workflow JSON shipped with this episode (3 files); anything the video reports about results is attributed to the author.

When this is useful

You want an anime model that was not trained on AI-generated images.
You need to convert a photo or 3D render into anime style with denoise control.
Your target size exceeds what the model handles natively, so you need tiled upscale.

How the pipeline is built

The model itself

2B parameters, trained jointly with Comfy Org on millions of anime images plus 800k non-anime art images, zero synthetic data. In 2025 terms 2B is not large; the selling point is the data policy.

It is a preview build and explicitly not an accelerated model, so it needs a real step budget. The author expects a more stable release later.

The author reads it as NSFW-capable ("should support NSFW"), and frames it as worth trying for anime illustrators.

Text encoder and prompt language

The text encoder is Qwen3, and the author recommends English prompts for accuracy.

Native text-to-image size is limited, which is precisely why the upscale stage is part of the pipeline rather than an optional extra.

Image-to-image: denoise is the dial

For conversion the author lands on a denoise around 0.7 as the upper useful value: higher changes more, lower changes less.

A 1080p input fed straight in produces artifacts, so the image has to be passed through a pixel constraint before encoding. With that constraint the results are reasonable.

Captions come from a Qwen3-VL reverse-caption pass (the author calls it Tesser-style reverse prompting), which is what makes photo-to-anime conversion controllable without hand-written prompts.

Tiled upscale done carefully

The upscale is the usual tile pipeline: set the target size by pixels, split into roughly four tiles, and caption each tile from the reverse prompt.

The author raised the tile overlap to 0.35 specifically to stop seams appearing on this model.

Noise must stay low during the upscale pass or the tiles come out strange. After stitching, the author reports no obvious seams and a visible gain in detail.

Prompt style is flexible: natural language or tag-style both work, and the project page provides prompting guidance.

How to run it

Open the text-to-image graph; write the prompt in English and check the subject details against the output.
For conversion, open the image-to-image graph, load the source, and apply a pixel constraint before encoding.
Set denoise around 0.7 - higher for more change, lower for less.
Run a Qwen3-VL reverse-caption pass to get the prompt, then sample.
Open the tiled-upscale graph, set the target size in pixels, split into about four tiles, raise overlap to 0.35, and keep noise low.
Stitch and inspect the seams.

Parameter basis

Anima分块放大 - 26 nodes

Item	Value (from JSON)
UNET loader	`anima-preview.safetensors` / default
CLIP loader	`qwen_3_06b_base.safetensors` / stable_diffusion
VAE	`qwen_image_vae.safetensors`
KSampler	steps 31 · cfg 4 · er_sde · simple · denoise 0.25
LoRA	`Gundam_RX78_Flux.safetensors` @ 0.85

Anima图生图 - 13 nodes

Item	Value (from JSON)
UNET loader	`anima-preview.safetensors` / default
CLIP loader	`qwen_3_06b_base.safetensors` / stable_diffusion
VAE	`qwen_image_vae.safetensors`
KSampler	steps 31 · cfg 4 · er_sde · simple · denoise 0.7

Anima文生图 - 10 nodes

Item	Value (from JSON)
UNET loader	`anima-preview.safetensors` / default
CLIP loader	`qwen_3_06b_base.safetensors` / stable_diffusion
VAE	`qwen_image_vae.safetensors`
KSampler	steps 30 · cfg 4 · er_sde · simple · denoise 1
Latent size	1024x1024 · batch 1

Honest limits

Preview build, not an accelerated model: it needs a full step budget to look right.
Native resolution is small; upscaling is mandatory for production sizes.
Character/IP LoRAs carry their own licences - the graph shown uses a third-party Gundam LoRA as an example.
The 4-6 GB VRAM estimate is the author's inference from model and encoder file sizes, not a measured floor.

Episode resources

RunningHub - Anima分块放大: https://www.runninghub.ai/post/2021929692445544449/?inviteCode=rh-v1111
RunningHub - Anima图生图: https://www.runninghub.ai/post/2021929700087566337/?inviteCode=rh-v1111
RunningHub - Anima文生图: https://www.runninghub.ai/post/2021929707570208769/?inviteCode=rh-v1111
YouTube tutorial: https://www.youtube.com/watch?v=J2A8JWDCUhk
Bilibili original: https://www.bilibili.com/video/BV1FscqzREni

Z-Image Base + ControlNet 2.1 + Turbo: Two-Stage Repair, and Why the 8/4-Step Accelerators Are a Bad Trade

AI-KSK — Sun, 08 Nov 2026 16:27:47 +0000

Z-Image Base controls well and looks mediocre. This episode tests ControlNet 2.1 on Base, then repairs the aesthetics by splitting sampling: Base drives the high-noise half, Turbo takes the low-noise half and pulls quality back. It also tests the 8-step and 4-step Base accelerators and reaches a blunt conclusion - with Turbo available, the accelerators are not worth the loss of variety, and they cannot be combined with ControlNet at all.

Evidence note: parameters below were parsed from the workflow JSON shipped with this episode (3 files); anything the video reports about results is attributed to the author.

When this is useful

You need precise structural control and can accept a Base-quality first pass.
You want Base's control with Turbo's aesthetics instead of choosing one.
You are deciding whether a 4-step or 8-step Base accelerator is worth installing.

What this episode tests

The problem: Base controls, but it looks bad

The author's first conclusion: generating with Base plus ControlNet controls almost perfectly, but produces low-aesthetic, low-quality results. Control is not the problem - the base model's finish is.

The workaround is the same shape as the author's earlier Turbo workflows: a high/low-noise split where the ControlNet acts early and Turbo refines late.

ControlNet 2.1 wired as a model patch

The update is ControlNet 2.1, which the author notes had shipped 12 days before the video.

It is loaded through the Z-Image Fun node as a model patch, not as a separate conditioning branch: load an image, pass it through a preprocessor to get the control image, then feed the patch.

The author explicitly has not tested Base's local-repaint ability with this ControlNet yet.

Two-stage repair in numbers

The author reports a 16-step total: 8 high-noise on Base, then 8 low-noise on Turbo, then one more pass through Turbo to compose the final image.

The prompt has to match the control image. The author points out that if the prompt and the control content disagree, the result shows it - his phrasing is that you do not want a knife behind the scene.

Accelerators: 8-step and 4-step, measured

The 8-step and 4-step models are distilled LoRAs for Base. The author's test set is a text-to-image comparison, plus a difficulty case (a duel scene) where Base without acceleration shows some quality damage.

His conclusions: acceleration does raise speed and can even clean up that damage, but lower step counts force the model to keep high frequencies first and compress low frequencies, so output variety drops - the "gacha" feel of rerolling is reduced.

Between the two, 4-step is the best value if you accept the loss. But an accelerator cannot be combined with ControlNet, and combining them produces what he calls "utterly terrible" results.

How to run it

Open the Base + ControlNet graph; note that the CN is applied as a model patch, not a conditioning branch.
Load the control image and run it through the preprocessor; set the output size by pixels.
Write a prompt that matches the control content - mismatches show up in the result.
Run the high-noise half on Base, pass the latent to the Turbo half, and let it finish.
Optional final pass: run the composition through Turbo once more to place the result.
For the accelerator test, switch to the 8-step or 4-step distilled LoRA graph - and do not try to keep the ControlNet in that graph.

Parameter basis

Z Image Base +ControlNet - 14 nodes

Item	Value (from JSON)
UNET loader	`z_image_bf16.safetensors` / default
CLIP loader	`qwen_3_4b.safetensors` / qwen_image
VAE	`ae.safetensors`
KSampler	steps 30 · cfg 3 · euler · simple · denoise 1
Latent size	720x1280 · batch 1

Z Image Base 8步&4步加速 - 53 nodes

Item	Value (from JSON)
UNET loader	`z_image_bf16.safetensors` / default
CLIP loader	`qwen_3_4b.safetensors` / qwen_image
VAE	`ae.safetensors`
KSampler	steps 4 · cfg 1 · euler · simple · denoise 1
KSampler	steps 8 · cfg 1 · euler · simple · denoise 1
KSampler	steps 20 · cfg 3 · euler · simple · denoise 1
KSampler	steps 4 · cfg 1 · euler · simple · denoise 1
KSampler	steps 8 · cfg 1 · euler · simple · denoise 1
KSampler	steps 20 · cfg 3 · euler · simple · denoise 1
KSampler	steps 4 · cfg 1 · euler · simple · denoise 1
KSampler	steps 8 · cfg 1 · euler · simple · denoise 1
KSampler	steps 4 · cfg 1 · euler · simple · denoise 1
KSampler	steps 8 · cfg 1 · euler · simple · denoise 1
KSampler	steps 20 · cfg 3 · euler · simple · denoise 1
KSampler	steps 20 · cfg 3 · euler · simple · denoise 1
Latent size	1280x720 · batch 1
LoRA	`Z-Image-Fun-Lora-Distill-4-Steps-2602-ComfyUI.safetensors` @ 1; `Z-Image-Fun-Lora-Distill-8-Steps-2602-ComfyUI.safetensors` @ 1

Z Image Base+ControlNet+Turbo高低噪 - 44 nodes

Item	Value (from JSON)
UNET loader	`z_image_bf16.safetensors` / default
CLIP loader	`qwen_3_4b.safetensors` / lumina2
VAE	`ae.safetensors`
BasicScheduler	steps 10 · scheduler simple · denoise 1
BasicScheduler	steps 10 · scheduler simple · denoise 0.51
Latent size	512x472 · batch 1
LoRA	`Z-Image-Fun-Lora-Distill-4-Steps-2602-ComfyUI.safetensors` @ 1

Honest limits

Base + ControlNet is not usable as-is for finished work: control is excellent, aesthetics are not.
Accelerators and ControlNet do not combine, and the author rates the combination as extremely bad.
Variety drops with acceleration; 4-step keeps the most value but still costs diversity.
Base's local repaint with CN 2.1 is explicitly untested in this episode.

Episode resources

RunningHub - Z Image Base +ControlNet: https://www.runninghub.ai/post/2022640984902864898/?inviteCode=rh-v1111
RunningHub - Z Image Base+ControlNet+Turbo高低噪: https://www.runninghub.ai/post/2022635998764601346/?inviteCode=rh-v1111
RunningHub - Z Image Base 8步&4步加速: https://www.runninghub.ai/post/2022636633476046849/?inviteCode=rh-v1111
YouTube tutorial: https://www.youtube.com/watch?v=mYpdxdHGlQM
Bilibili original: https://www.bilibili.com/video/BV1quZ7BpEPE

Z-Image i2L in ComfyUI: A Reusable LoRA From 6 Images in Seconds, Then a ControlNet Pass

AI-KSK — Sun, 08 Nov 2026 16:27:17 +0000

Training a LoRA normally costs hours. Z-Image's Image-to-LoRA path claims to produce a reusable LoRA in the low tens of seconds, and this episode tests the updated Z-Image version of that path: 6 images in, a style LoRA out, then a text-to-image run, then the same LoRA inside a depth-ControlNet graph with high/low-noise splitting and tiled upscaling. The author reports the style is recognisably reproduced, while admitting that content from the training set leaks into the output.

Evidence note: parameters below were parsed from the workflow JSON shipped with this episode (3 files); anything the video reports about results is attributed to the author.

When this is useful

You want a style LoRA from a handful of reference images and cannot wait hours for a training run.
You need the LoRA to be reusable: download it once, then drop it into other ComfyUI graphs.
You want style transfer under control by combining the i2L LoRA with a depth ControlNet pass.

What changed in this version

Three graphs, one training node

The episode ships three workflows: training + test, training + ControlNet test, and training + ControlNet test + tiled upscale.

All three share the same primitive: a single RunningHub i2L node that takes a batch of images, trains, and hands back a LoRA file. On the online platform the LoRA is downloadable from the task list; running locally it is written to disk.

The previous version of this trick was built on Qwen-Image; the Z-Image version landed on 30 January. The graph is built on the Z-Image Base family, not Turbo.

Why Base and not Turbo

The author states plainly that this technique does not work with the Turbo model and only works with Base. That is why the ControlNet graph takes Base in the high-noise half and Base again in the low-noise half instead of handing over to Turbo.

CLIP is wired to the positive conditioning only. The author is explicit that the negative branch must not be fed from the CLIP loader; the official negative prompt is supplied in the graph instead.

High/low noise split, then tiled upscale

The point of splitting is not to switch models mid-run: it is to let the ControlNet act only in the high-noise phase, then let the low-noise phase finish the image, before a tiled upscale pass.

The author reports 50 steps in total, split 25 high-noise / 25 low-noise, and describes the upscale stage as almost fully automatic.

The ControlNet itself is depth-based: load an image, run it through a preprocessor to get the control image, and scale by pixels rather than by a fixed side length.

What the tests actually show

A pure text-to-image run driven by a 6-image training set keeps the style, but reference elements from the training set still show up. The author calls separating style from content "very difficult" and does not claim it is solved.

When the training set contains many faces, generated characters are affected; removing the faces from the training set lowers that influence noticeably.

The official guidance is 1-6 training images; the author uses 6, calling that "sufficient".

How to run it

Open the training + test graph on RunningHub (or install the open-source node locally, which the author says runs fully offline).
Load 6 training images; the official range is 1-6 and the author treats 6 as sufficient.
Run the i2L node. On the platform, download the LoRA from the task list; locally it is saved to disk.
Switch to the text-to-image graph, insert the LoRA, and keep the CLIP feed on the positive side only with the official negative prompt.
For the ControlNet variant: load a control image, run the preprocessor, set the pixel-based size, and let the graph split 50 steps into 25 high-noise and 25 low-noise.
Finish with the tiled upscale graph; the author describes that stage as almost automatic.

Parameter basis

Z Image i2L (Image to LoRA)快速lora训练+测试 - 23 nodes

Item	Value (from JSON)
UNET loader	`z_image_bf16.safetensors` / default
CLIP loader	`qwen_3_4b.safetensors` / lumina2
VAE	`ae.safetensors`
KSampler	steps 50 · cfg 4 · res_multistep · simple · denoise 1
Latent size	1024x1536 · batch 1
LoRA	(empty slot - the i2L node writes the trained LoRA here at run time) @ 1.1 / clip 1

Z Image i2L (Image to LoRA)快速lora训练+联合CN测试+放大 - 62 nodes

Item	Value (from JSON)
UNET loader	`z_image_bf16.safetensors` / default
CLIP loader	`qwen_3_4b.safetensors` / lumina2
VAE	`ae.safetensors`
BasicScheduler	steps 10 · scheduler simple · denoise 1
KSampler	steps 20 · cfg 3 · euler · simple · denoise 0.25
Latent size	512x472 · batch 1
LoRA	`Z-Image-Fun-Lora-Distill-4-Steps-2602-ComfyUI.safetensors` @ 1; (empty slot - the i2L node writes the trained LoRA here at run time) @ 1.1 / clip 1

Z Image i2L (Image to LoRA)快速lora训练+联合CN测试 - 43 nodes

Item	Value (from JSON)
UNET loader	`z_image_bf16.safetensors` / default
CLIP loader	`qwen_3_4b.safetensors` / lumina2
VAE	`ae.safetensors`
BasicScheduler	steps 10 · scheduler simple · denoise 1
Latent size	512x472 · batch 1
LoRA	`Z-Image-Fun-Lora-Distill-4-Steps-2602-ComfyUI.safetensors` @ 1; (empty slot - the i2L node writes the trained LoRA here at run time) @ 1.1 / clip 1

The 50-step setting, the 25/25 split and the CFG 4 / sigma shift 8 recommendation are stated in the video; the sampler wiring above is read from the JSON. In the ControlNet graph the KSampler shows 20 steps at cfg 3 with denoise 0.25, i.e. it is a partial-denoise refinement pass after the custom-sampler split.

Honest limits

Styles, not identities. The author positions i2L for style reference; content elements from the training set leak into results and that is not fixed.
Base only. The technique is stated not to work with Turbo, which rules out the fastest Z-Image route.
Face-heavy training sets bias the output. Fewer faces in the set, less leakage.
The "tens of seconds" figure is the author's report from the video, not an independent benchmark.

Episode resources

RunningHub - Z Image i2L (Image to LoRA)快速lora训练+测试: https://www.runninghub.ai/post/2023308170269036545/?inviteCode=rh-v1111
RunningHub - Z Image i2L (Image to LoRA)快速lora训练+联合CN测试: https://www.runninghub.ai/post/2023370355200495617/?inviteCode=rh-v1111
RunningHub - Z Image i2L (Image to LoRA)快速lora训练+联合CN测试+放大: https://www.runninghub.ai/post/2023308180264067074/?inviteCode=rh-v1111
YouTube tutorial: https://www.youtube.com/watch?v=wT9ob7rFONM
Bilibili original: https://www.bilibili.com/video/BV1qXZMBwEC7

The Last Step Nobody Automates: Batch Frame Interpolation and Upscaling to 4K120

AI-KSK — Sun, 08 Nov 2026 16:27:13 +0000

Every pipeline ends the same way and most people still do it by hand. This episode packages that last step into seven ComfyUI flows: four single-video tasks and three batch runs that chew through a folder overnight. The stack is GIMM for interpolation, plus FlashVSR, SeedVR2 and LTX-2 for upscaling.

Evidence note: this episode ships no workflow JSON - the graphs are inside the deployed image. All numbers below are the author's on-screen values from the recording, not graph reads.

When this is useful

You generate clips with Seedance 2.0 and need them to look finished rather than draft.
You have a folder of videos, not one, and you want the queue to run while you sleep.
You are deciding which of four upscalers fits a given clip.

The stack, and why each piece is there

Component	Role	Author's note
GIMM	frame interpolation	described as close to top-tier among open techniques
FlashVSR	upscale	built on Wan
SeedVR2	upscale	targets a longest-side value
LTX-2	upscale	no trained model for video upscaling yet; included because the author thinks it is promising

That last row is the interesting one: a component is shipped precisely because nobody has trained it properly yet, on the bet that video upscaling is where LTX-2 pays off.

Step by step

Deploy the mirror, pick a 48GB 4090, and wait for the instance to come up.
Open JupyterLab, start a terminal, paste the start command. If your card has more than 48GB, remove the low-VRAM flag first.
When the address appears, click through into ComfyUI and open the workflow panel.
Choose one of four single-video flows for a one-off, or one of three batch flows for a folder.
Set the one meaningful knob for that flow: interpolation multiple, upscale factor, or longest side.
Run. For batch flows, verify the folder path, the increment field and the batch count before starting.
Collect results from the ComfyUI output directory in JupyterLab.

Four single-video flows

GIMM interpolation. Load a video, run. The one knob is the interpolation multiple; 2 means double the frame count.
FlashVSR upscale. Load, run. Adjust the scale factor: 2x, 3x or 4x, with 4x the ceiling.
SeedVR2 upscale. Load, run. Adjust the longest-side value; the shipped value is 2560.
LTX-2 video-to-video. In practice another upscaler. Load, run, adjust the longest side.

Three batch flows

These exist for automation: point them at a folder, and they queue every video in it.

Create a folder (the author names his test1) and upload as many videos as you want.
Shorten the filenames. This is the failure mode the author calls out explicitly: clips produced by 小云雀 often carry very long names and will error. Rename them to something short, like 1352.
Open a terminal, copy the folder's path, paste it into the flow's folder field.
Set the increment value. It defaults to 0 and must be reset to 0 before a run.
Set the interpolation multiple and the upscale multiple.
On FlashVSR specifically, the flow pre-scales to 1024 before multiplying: a multiple of 2 yields 2048, a multiple of 4 yields 4096.
Set the batch count to the number of files. Ten videos means batch count 10, which queues ten tasks.
Run. It keeps going in the background, which is the point for overnight jobs.
Collect results from the output folder under the ComfyUI directory in JupyterLab.

The SeedVR2 batch caveat

Same structure, one extra trap. Seedance output is typically 30 fps, so no frame-rate change is needed. If you load other footage at 29.97 fps, normalise it to an integer in the video loader, because the flow multiplies the rate and a non-integer base produces errors.

Deployment notes

Rent a 48GB 4090 for the best value; 5090 and 4090 are cheaper overnight. The author used an A800 because he was stress-testing.
The start command includes a low-VRAM switch. If your card has more than 48GB (48 itself excluded), you can drop it.
Registration through the link adds platform credit after identity verification.

Parameter basis

No JSON exists for this episode, so this is a transcription of the on-screen values:

Item	Value
Interpolation multiple	2 (2x), adjustable
FlashVSR scale	2x / 3x / 4x, max 4x
FlashVSR pre-scale	1024, then multiply (2 → 2048, 4 → 4096)
SeedVR2 longest side	2560
Batch increment field	defaults to 0, must be 0
Batch count	number of files in the folder
Typical Seedance frame rate	30 fps
Non-integer frame rate case	29.97 fps, normalise before multiplying
Suggested GPU	48GB 4090 (author tested on A800)

Limits

No downloadable graphs. Seven flows live inside the image; the episode folder has no JSON.
Filename length is a real failure. Long names error out; this is a platform quirk, not a model limit.
LTX-2 upscaling is unproven. The author says nobody has trained it for this yet, so it is included on potential, not on results.
4K120 is the target, not a measured spec. The episode title states it; the recording documents the multipliers and pre-scale chain, not per-clip timings or quality scores.
Batch flows need integer frame rates. 29.97 fps inputs are a documented error source.

Episode resources

Mirror (with referral code): https://www.compshare.cn/images/7oKVc778yl8g?referral_code=A7fTQUYY9lCDFJwA6MMvoq
RunningHub workflow: none for this episode
YouTube: https://youtu.be/XIkd2Rq8Y8I
Bilibili: https://www.bilibili.com/video/BV1YTZ1BtEHK/

BitDance 14B: A 14-Billion-Parameter Autoregressive Image Model That Is Actually Fast

AI-KSK — Sun, 08 Nov 2026 16:26:44 +0000

Autoregressive image generation has always lost on speed, which is why models like it mostly went unused. BitDance's claim is that it fixes exactly that, and the author's test puts a number on it: about 25 seconds per image on a 48GB 4090, with generation quality that is genuinely different from the diffusion models he compares it against.

Evidence note: this episode ships no workflow JSON - the model runs behind a WebUI, not a ComfyUI graph. All numbers below are the author's on-camera observations, not graph values.

When this is useful

You want to try an autoregressive image model without installing anything locally.
You care about prompt adherence and final-image convergence more than fine texture detail.
You need direct English or Chinese text rendering inside the generated image.

What BitDance is

A 14-billion-parameter autoregressive image generator. Autoregressive means next-token prediction, applied here to image tokens, which historically makes generation slow: the author's reference point is that autoregressive models like the GLM-Image family are simply slower. BitDance's contribution is speed, not a new architecture.

Two weight variants ship:

64X, the distilled fast one, used by default after auto-start. Roughly 25 seconds per image in the author's test.
16X, slower, but able to generate smaller images such as 512-class and 1024-class sizes.

What the author found, task by task

Aspect	Reported result
Portraits	Reasonable; one sample had a broken hand
Detail rendering (64X)	Not especially good
English text in image	Works directly; no clear lead over the comparison models
Chinese text	Works
Stylisation	Good
Prompt adherence	Top tier, per the author
Complex scene	Handled a multi-subject prompt (elderly man on a plaza bench, pink-haired woman to one side, dog with a blue scarf to the other, clown juggling three specified colours behind, broken paper cup in a corner) with acceptable aesthetics
Aesthetics vs Qwen-Image	Slightly ahead
Very long prompts	Behind Qwen-Image
Convergence	Strong, which the author attributes to the autoregressive path
Identity vs other models	Clearly a different look; an RPG-style illustration separated it from the comparison set immediately

Step by step

Open the mirror and deploy an instance. The author follows the official recommendation and rents a 48GB 4090; overnight rates on 4090 and 5090 are cheaper.
Register through the link first if you are new; identity verification adds platform credit.
Wait while the model loads and the service auto-starts.
Click the BitDance button to open the WebUI.
Enter a prompt, pick a width and height from the presets, set step count, CFG and whether to randomise the seed.
The author keeps steps and CFG at their defaults and considers that sufficient.
Switch to the 1.0 variant if you want to compare the non-distilled behaviour.

Parameter basis

No JSON exists for this episode. What the material actually establishes:

Item	Value	Basis
Parameters	14B, autoregressive	spoken
Speed, 64X	~25 s per image	author's observation
Speed, 16X	slower	spoken, no figure
GPU	48GB 4090	platform recommendation quoted by the author
Startup	model auto-loads, service auto-starts	spoken
Controls exposed	prompt, width/height presets, steps, CFG, seed toggle	on screen

Nothing beyond that is claimed, because there is no graph file to read.

Limits

Hands break. The author shows one portrait with a collapsed hand, and calls the results "acceptable" rather than good.
Detail at 64X is soft. This is an explicit negative finding, not an oversight.
Long prompts lose. Against Qwen-Image on very long text, BitDance is behind.
The timing is one observation. 25 seconds on one card, one session, is not a throughput benchmark.
No ComfyUI graph yet. The author expects ComfyUI support soon; at the time of recording this is a WebUI-only route.
Transcript variance. The load-time figure is quoted as about five minutes in this episode's subtitle; a duplicate transcript of the same talk elsewhere in the source tree says 15. Treat startup time as "several minutes" rather than a precise number.

Episode resources

Mirror (with referral code): https://www.compshare.cn/images/TuPWGieO4ed8?referral_code=A7fTQUYY9lCDFJwA6MMvoq
RunningHub workflow: none for this episode
YouTube: https://www.youtube.com/watch?v=bfKBYjkFy3Y
Bilibili: https://www.bilibili.com/video/BV1VFZXBjEDG

FireRed Image Edit 1.0 vs Qwen 2511: Five Single-Image Edits, Two Graphs, One Honest Verdict

AI-KSK — Sun, 08 Nov 2026 16:26:40 +0000

FireRed Image Edit 1.0 looks like a Qwen 2511 derivative with a nudge, and the author's testing lands exactly there: not a class above 2511, but more reliable on single-image edits, and worse once you feed it multiple images. This episode runs five edit tasks across two graph variants to get to that answer.

Evidence note: this episode ships three workflow JSON files (28, 29 and 28 nodes). All graph values below are read from them; the comparison results are the author's on-camera tests, reported as such.

When this is useful

You edit one image at a time and need the untouched regions to stay untouched.
You rely on an 8-step Lightning accelerator and want to know whether an edit model still holds up with it.
You are deciding between FireRed and 2511 for a multi-image task and would rather not find out the hard way.

The two graphs, and when each one applies

Anti-drift (防偏移), with a reference latent. This is the safe variant. When you edit one region, the reference latent keeps the rest of the frame stable. Use it whenever "do not touch anything else" is the requirement.
Divergent (发散), looser. This allows larger changes. The trade-off is explicit in the recording: face similarity drops.
Dual-image (双图). A third graph for two input images. The author tested it and recommends sticking with 2511 for this case instead.

The three graphs are structurally close to the 2511 counterparts. In the author's words, you mostly swap the backbone.

What the graphs actually load

Backbone: FireRed-Image-Edit-1.0_fp8_e4m3fn.safetensors
Text encoder: qwen_2.5_vl_7b_fp8_scaled.safetensors, CLIPLoader type qwen_image
VAE: qwen_image_vae.safetensors
Accelerator: Qwen-Image-Lightning-8steps-V2.0 bf16.safetensors, strength 1.0 on the two single-image graphs and 0.66 on the dual-image graph
Sampler: 8 steps, CFG 1, euler, simple, denoise 1
Empty latent: 928x1664
Front-end scale: ImageScaleToTotalPixels at 1.0; two intermediate scalers at 3.0 are bypassed

That 8-step Lightning pairing is the practical core of the release: the model was not retrained for speed, the accelerator was bolted on, and the author says a 4-step accelerator made no visible difference on the anti-drift graph.

The five single-image tests

Test	Task	Result reported
1	Place a person into a city scene	FireRed integrated the subject with the scene lighting better; the 2511 result looked pasted
2	Night scene to dusk	FireRed again
3	Hand holding a cup	FireRed, with more natural hands
4	Remove a woman from the frame	FireRed clean; the 2511 result showed grid-like artifacts on the floor
5	Change a garment's colour	FireRed, with higher saturation and a stronger response to the prompt
Bonus	Glass cup to ceramic cup	FireRed, with a more convincing glossy surface

The author's read on why: FireRed seems to accept more of the prompt and act on it, which reads as a small win within single-image editing rather than a different tier of model.

Then the counter-example: for a four-way multi-image comparison the best result came from 2511, which is why he recommends 2511 there and says FireRed shows no clear advantage.

Step by step

Pick the graph by intent: anti-drift for surgical edits, divergent for larger changes, dual-image only if you must.
Load the source image. If you are doing a targeted edit, mask the region first.
Keep the front-end scaler at 1.0; the 3.0 scalers are bypassed in the shipped files and are not needed for these tests.
Leave the Lightning LoRA at 1.0 (0.66 on the dual-image graph) and the sampler at 8 steps / CFG 1 / euler / simple.
Write a short, direct instruction. The author notes his own prompts were very simple, and that FireRed still responded well.
Run the anti-drift graph first when fidelity to the original matters, then re-run in the divergent graph only if the edit is too timid.
For multi-image input, use the divergent graph and expect less face similarity; the author still prefers 2511 there.

Parameter basis

Read from the three JSON files in 工作流及封面(视频184):

Node	Anti-drift	Divergent	Dual-image
Nodes	29	28	28
`UNETLoader`	FireRed fp8_e4m3fn	same	same
`LoraLoaderModelOnly`	Lightning 8-steps, 1.0	1.0	0.66
`KSampler`	8 / 1 / euler / simple	same	same
`EmptySD3LatentImage`	928x1664	928x1664	928x1664
`ImageScaleToTotalPixels`	1.0 active, 3.0 x2 bypassed	same	1.0 x2 active, one 3.0 bypassed

Limits

Not a new tier. The author says outright that FireRed is close to 2511 and that scores do not separate them much.
Multi-image is the weak spot. Four-image comparison went to 2511.
Accelerator risk. Every test used the Lightning accelerator, and the author flags that acceleration may itself introduce instability in results.
Single-image only. All five comparisons are single-image edits; nothing here validates batch or sequential edits.
Visual judgement. Five tasks, no metric, and the author reads them himself.
Implementation caveat. He notes the multi-image gap might be a ComfyUI implementation detail rather than a model limitation.

Episode resources

Anti-drift graph: https://www.runninghub.ai/post/2024514356171509762/?inviteCode=rh-v1111
Divergent graph: https://www.runninghub.ai/post/2024514345513787393/?inviteCode=rh-v1111
Dual-image graph: https://www.runninghub.ai/post/2024517003498754050/?inviteCode=rh-v1111
Mirror: none for this episode
YouTube: https://www.youtube.com/watch?v=luvedSu-t_I
Bilibili: https://www.bilibili.com/video/BV1R3ZBBrEik

DEV Community: AI-KSK

Qwen 2511 Masked Repaint: Crop the Masked Block, Edit with a Reference, Paste It Back Seamlessly

When this is useful

The three-stage construction

Why the native nodes failed

Stage 1: mask, then crop with padding info

Stage 2: repaint, text-only or with a reference

The numbers that matter

How to run it

Parameter basis

重绘贴回 2511局部重绘 万物迁移 - 54 nodes

重绘贴回 2511局部重绘 - 55 nodes

Honest limits

Episode resources

InfiniteTalk Goes Native in ComfyUI: Single and Dual Lip-Sync Loops, Plus the LTX-2 Distilled Route

When this is useful

How the infinite loop is built

First segment, then extend

The loop count is arithmetic, not guesswork

480P, not 720P - and why

Two people: two audios, one image, two masks

The LTX-2 distilled talking head

How to run it

Parameter basis

FlashVSR V1.1放大 - 4 nodes

Ltx 2蒸馏对口型 - 106 nodes

单人InfiniteTalk无限时长原生循环 - 68 nodes

双人InfiniteTalk无限时长原生循环 - 65 nodes

Honest limits

Episode resources

LTX-2 Adapter LoRA: Image-to-Video Consistency at 60fps, Distilled vs Full-Quality Graphs

When this is useful

Two graphs, one adapter

The adapter fixes the static-clip problem

Non-distilled graph: 25 steps, then 2x upscale

Distilled graph: 8 steps, merged adapter, uncensored

Negative keywords worth stealing

How to run it

Parameter basis

ltx2_i2v去蒸馏图到视频一致性60帧1080p - 54 nodes

ltx2_i2v蒸馏图到视频一致性60帧1080p - 54 nodes

Honest limits

Episode resources

LTX-2 Rapid Merge: Uncensored Merged Model, Updated Adapter LoRA, Four Workflows in One Image

When this is useful

What is in the image

Four graphs, fully localised

Settings that matter in text-to-video

Image-to-video and the compression-artifact dial

Lip-sync

How to run it

Parameter basis

Honest limits

Episode resources

Qwen-Image-Edit 2511 + VNCCS Pose Studio: Pose and Lighting Control Without Opening a 3D App

When this is useful

How the three-image encoding works

Three images into one text-encode node

The controls you actually touch

Lighting, and the switch that matters

Output modes

How to run it

Parameter basis

一致性姿态与光影控制VNCCS Pose Studio+2511 - 25 nodes

Honest limits

Episode resources

Seedance 2.0 Post-Production in ComfyUI: Watermark Removal, GIMM Frame Interpolation, FlashVSR Upscale

When this is useful

Two graphs, two jobs

Watermark removal

Interpolation, then upscale

Where the clips come from

The 'ComfyUI is dying' argument

How to run it

Parameter basis

minimax remover 视频去水印 - 26 nodes

视频补帧+放大 - 7 nodes

Honest limits

Episode resources

Anima 2B: An Anime Model Trained Without a Single AI-Generated Image, From Text-to-Image to Tiled Upscale

重绘贴回 2511局部重绘万物迁移 - 54 nodes