TCD Model Sampling Discrete

Everyone who tried LCM in its 2024 heyday eventually said the same thing: fast, sure, but the images came out soft and washed out. TCD - Trajectory Consistency Distillation - was the answer to exactly that complaint, and TCDModelSamplingDiscrete is the ComfyUI node that makes your checkpoint speak TCD. It's the sampling-side half of the trick; the model-side half is a TCD LoRA (more on that below). Same few-step speed as LCM, noticeably better detail, and a genuinely useful knob the other techniques don't have: control over how much random noise each step carries.

Put simply, you reach for this when you want 4–8 step generation that looks closer to the 30-step version than LCM ever managed. In mid-2024 this was the hot new thing; it got overshadowed when Lightning and Hyper-SD landed, but TCD still holds up and remains a solid pick for SD1.5/SDXL seed farming and real-time previews.

How it works

TCD is a consistency-based distillation: the LoRA has compressed the model's long denoising trajectory into a few big jumps, and this node makes sure the sampler and noise schedule actually follow that compressed path. It clones your model, swaps in a distilled ModelSamplingDiscrete schedule, then builds a custom sampler object whose step logic implements the TCD trajectory. That's why it outputs three things instead of one:

• MODEL - your checkpoint, patched so the sampler knows about the distilled schedule.
• SAMPLER - a ready-made sampler object running the TCD step algorithm with your eta baked in.
• SIGMAS - the exact noise schedule this node computed from your steps/scheduler/denoise. Handy if your sampler node accepts explicit sigmas; you can ignore it otherwise.

You still set steps on a downstream sampler node, but the real controls live here: steps (1–50, default 4), scheduler (only simple or sgm_uniform - the two the author kept for a reason), denoise (default 1.0), and eta (default 0.3), the star of the show. Eta is the paper's gamma: the stochasticity injected each step. At eta = 0 you get deterministic, crisp, "safe" output; crank toward 1 and you get more varied detail - at the cost of some stability. The README's advice is right: fine-tune it when you bump steps up or swap LoRAs. Most people land between 0.2 and 0.5.

The trap: the node alone does nothing

TCDModelSamplingDiscrete patches your model, but your checkpoint isn't TCD-trained until you add a TCD LoRA. Load TCD-SD15-LoRA or TCD-SDXL-LoRA (from the TCD team) or a Hyper-SD unified LoRA alongside it, or you'll just get confused garbage from a model expecting a normal schedule. And keep CFG low - 1–2, same rule as LCM and Lightning, because the guidance is baked into the distilled model. Your muscle-memory CFG 7 will oversaturate everything. Community reports from when this shipped back the same pattern: low CFG, 4–8 steps, and TCD beating LCM on detail at equal steps.

Install

No model downloads, no Python dependencies - this whole pack is one self-contained Python file. Either search "ComfyUI-TCD" in ComfyUI Manager, or:

cd ComfyUI/custom_nodes
git clone https://github.com/JettHu/ComfyUI-TCD

Restart ComfyUI. That's it; the node shows up under advanced/model as "TCD Model Sampling Discrete". One real gotcha from the pack's changelog: an early bug produced wrong sampling when eta was exactly 0, fixed in June 2024 - so if you run an old checkout, update the pack or your crisp-at-eta-0 results will lie to you.

Is it still worth it?

Honestly, if you're already happy with Lightning or Hyper-SD, you don't need this. But it's the original community TCD implementation from JettHu (the same person behind ComfyUI_TGate and Tencent's ComfyUI-ELLA), it's tiny, dependency-free, and the eta knob gives you a level of detail control the others can't match. For SD1.5 at 4 steps on a weak GPU, it's still a legitimately good option - and the LoRAs are one download away.