Summary: RES4LYF is a ComfyUI extension offering a rich collection of diffusion samplers and sigma schedulers. It introduces new high-accuracy samplers (denoted RES for rectified explicit solvers) that achieve high image quality in fewer steps. It also provides an ODE vs. SDE toggle: in ODE mode, the sampler follows a fixed deterministic path, whereas SDE mode adds controlled noise at each step (via an “eta” parameter) for stochastic exploration. This guide demystifies each sampler and scheduler: what it does, when to use it, how many steps to try, and which scheduler pairs best – all backed by source documentation and tests.
Taxonomy of RES4LYF Sampling Methods
┌─────────────────────────┐ ┌─────────────────────────────┐
│ Explicit Methods │ │ Implicit Methods │
│ (direct step updates) │ │ (solve via iterative root-finding) │
├─────────────────────────┤ ├─────────────────────────────┤
│ Linear (ERK) │ │ Diagonally Implicit │
│ e.g. Euler, RK4 │ │ (DIRK, lower-triangular) │
│ – standard Runge-Kutta │ │ e.g. Crouzeix 2s, Qin–Zhang │
│ – fast but less stable │ │ – one new implicit stage per step │
├─────────────────────────┤ ├─────────────────────────────┤
│ Multistep │ │ Fully Implicit │
│ e.g. DPM++ 2M, RES_3M │ │ (fully coupled stages) │
│ – reuse past steps as │ │ e.g. Gauss–Legendre, Radau │
│ cheap predictors│ │ – high stability, high cost │
├─────────────────────────┤ ├─────────────────────────────┤
│ Exponential (ETD) │ │ Hybrid (Predictor–Corrector) │
│ e.g. RES_4S_Krogstad │ │ e.g. Lawson 4-1* methods │
│ – integrate linear part │ │ – combine explicit + implicit/exponential │
│ exactly (Lawson/ETD)│ │ – refine solution with extra steps│
└─────────────────────────┘ └─────────────────────────────┘
*ODE vs. SDE:* In any category, you can switch between a deterministic ODE mode and a stochastic SDE mode. SDE mode injects noise after each step, yielding more exploratory (creative) results at the cost of convergence – images won’t “lock in” even if steps are increased indefinitely, because noise keeps nudging the generation. ODE mode gives repeatable outputs and converges if you take enough steps (no noise added). Use ODE for precision and reproducibility, SDE for variety and potentially sharper detail when balanced with fewer steps of high-order integrators.*
## Sigma Schedulers (Intuitive Overview)
In diffusion models, a scheduler defines how the noise level (σ) decreases from start (high noise) to finish (no noise). Different schedulers space the steps differently along the time/σ axis, affecting image formation. RES4LYF supports all common schedules from KSampler plus a few extras. Here’s each in plain terms:
- Normal (Linear): Steps linearly reduce σ from σ_max to 0 – a uniform decay schedule. This is the “standard” schedule giving a balanced progression, often used as a baseline. Use for general purposes when unsure; it evenly spends effort across all denoising phases.
- Simple: A simplified decay (also linear in behavior) intended for quick tests. It’s similar to Normal but uses a fixed range or formula; basically a no-frills schedule. Use for smoke-testing a prompt or debugging, where fancy step allocation isn’t needed. (No separate official formula given in docs – treat it as a variant of linear without special optimization.)
- Karras (EDM): A smoothly varying non-linear schedule inspired by Karras et al.’s EDM paper. It spaces steps more densely at the low-noise end for finer detail, using a power-law (ρ) curve. Visually, σ decays slowly at first, then faster mid-way, then slowly at the end – ensuring a “smooth transition” in noise. This is recommended for high-quality, detail-rich images, especially if you have enough steps (≥ 20). Karras schedule often improves detail and stability compared to linear spacing by spending more steps where the model needs them (low σ).
- Exponential: An aggressive schedule where σ drops off exponentially fast. Early steps eliminate noise rapidly, so coarse structure appears quickly; later steps fine-tune at near-zero noise. It’s great for speed or when you want a decent image in very few steps (the model “jumps to” a clean state quickly). However, it may sacrifice some detail or consistency if too few steps are used (since little time is spent in mid-level noise). Use when you need a rough but fast result.
- SGM Uniform: A schedule derived from Score-Based Models (SGM) literature, aiming for uniform progression in diffusion time. In practice, it “decays noise in an SGM-optimized way” – likely linear in continuous time t instead of linear in σ. This can benefit certain models or settings that assume a variance-preserving SDE schedule. Use SGM for specialized scenarios or to mimic the original training schedule of SDE models (when known); otherwise, Normal or Karras usually suffices.
- DDIM Uniform: The schedule used by DDIM (Denoising Diffusion Implicit Models). It spaces time steps uniformly between 1 and 0 (the diffusion time), which corresponds to a specific non-linear σ decay. It’s tailored for DDIM’s ODE sampler to approximate the original discrete diffusion process. Use DDIM Uniform if you are employing a DDIM sampler or want to replicate the original DDIM paper’s step allocation. It tends to give a gentler noise drop early on, then a steep decline later (somewhat opposite to exponential).
- Beta (Train-like): A schedule based on the beta schedule from diffusion training. In training, noise level evolves according to a Beta distribution (often linear beta or cosine schedule). Here “Beta” refers to using a Beta(α, β) distribution function to map step indices to noise. The default parameters (in KSampler) aren’t given, but the variant Beta57 in RES4LYF is explicitly Beta(α=0.5, β=0.7). These produce a curve that decays slowly then rapidly (or vice versa) depending on α, β. Use Beta when you want to experiment with non-linear decays that are not as extreme as exponential – Beta curves can allocate more time near start or end depending on shape. Beta(0.5,0.7) for instance gives a slightly front-loaded decay. (This is an extra provided by RES4LYF; it’s not in stock ComfyUI).
- Linear-Quadratic: A two-phase schedule: first half linear decay, second half quadratic (or vice versa). It’s described as complex scenario optimization – meaning it tries to handle both coarse and fine denoising differently. For example, it might drop σ linearly early on, then slow the decay quadratically to linger on fine details. Use this if you find pure linear either oversmooths or underrefines; linear_quadratic can balance structure vs detail by adjusting how abruptly it transitions.
- KL Optimal: A theoretically derived schedule that minimizes KL divergence error per step (from the Align Your Steps framework). In essence, it places steps where the diffusion model’s error is largest, which mathematically yields an optimal allocation of N steps to minimize final KL error. The formula is complex (involves solving a quartic per triplet of points), but the effect is an uneven, model-specific spacing. Use KL Optimal if you seek maximum fidelity for a given number of steps – e.g. when chasing the last bit of quality or doing very low-step generations where every step must count. It’s “optimal” in theory, though in practice results may only subtly improve. (Ensure your model and CFG settings are compatible; some implementations need adjusting “skip” for first steps.)
- **Bong (Tangent) – Two-Stage Tangential:** RES4LYF-exclusive. This scheduler (sometimes spelled boong_tangent) uses BONGMATH tech to perform bidirectional denoising: it essentially schedules a forward pass followed by a partial “reverse” pass in one sequence. Implementation-wise, it uses a two-segment tangent function curve (hence the name) to drop σ down and then slightly up, or similar trick, so that the sampler can correct errors from both ends. The result is enhanced detail: users report bong_tangent is very fast and great for fine details when paired with certain samplers. Visually, imagine denoising almost to completion, then adding a tiny bit of noise back and refining again – this can recover detail that a one-way schedule might blur. Use bong_tangent for maximum sharpness and detail, especially with simpler samplers (like Euler or RES_2M) that benefit from a second chance at refinement. It’s computationally efficient (the schedule shape doesn’t add actual steps, it just redistributes them), so it’s a popular choice for speedy yet crisp results. Note: This schedule may introduce subtle flicker in batch or video outputs due to its bidirectional nature – best to test on a single image first.
Each scheduler’s “curve” can be visualized as a sigma vs step plot (not shown here). The key takeaway is: different schedules emphasize different parts of the denoising process. For quick drafts use exponential or simple; for balanced quality use normal (linear) or karras; for specialized tweaks try SGM, DDIM, Beta, LQ or KL; and for detail-critical work, consider bong_tangent. Many users default to Karras or bong_tangent for quality, and switch to exponential for speed runs – as we’ll outline next.
## Quick Sampler+Scheduler Picks (Cheat Sheet)
If you’re not ready to digest all the theory, here are evidence-based starting points for common goals. Each suggestion cites either the RES4LYF docs or community benchmarks:
- “I want the best image quality in ~30 steps” – Try *rk6_7s** (Linear 7-stage) with Normal or Karras schedule. In one test, a 7-stage 6th-order method produced the sharpest, most prompt-faithful image among ~100 samplers. It took longer per image, but the result was top-tier.
- “I need a sharp portrait but can’t afford many steps” – Use *res_2m** (Multistep) with BongTangent. The RES multistep family is designed for high quality at low step counts. Users report that res_2m + bong_tangent scheduler yields very detailed images quickly (bong_tangent adds extra refinement without extra steps).
- “Speed is crucial (around 20 steps max)” – Choose *Euler** or *DDIM** with the Exponential scheduler. Euler (1-step RK) and DDIM are simple and fast, and an exponential decay will get the image “mostly done” in ~20 steps. In a benchmark, Exponential DDIM and linear Euler each finished 16 steps in ~24.5s on a 3080 GPU – the fastest of all tested. Expect a decent image, albeit a bit less polished.
- “Smooth gradients & fewer artifacts (e.g. landscapes, sky)” – Use an implicit sampler like *radau_iia_3s** (fully implicit 3-stage) with Linear-Quadratic schedule. Implicit methods excel at stability – Radau IIA is L-stable and dampens oscillations. Paired with a gentle decay (linear_quadratic), it preserves smooth tones. One user’s test noted Radau (11-stage in their case) gave very natural, artifact-free results albeit slowly.
- “Crank up the creativity (let the model roam)” – Pick SDE mode with a robust explicit solver, e.g. *dpmpp_sde_2s** (stochastic 2-stage) and Karras schedule. SDE mode’s injected noise gives unpredictable but often inspiring variations. DPM++ 2S is a well-regarded sampler for stable diffusion – combining them can yield varied outputs even with the same seed. Tip: keep eta moderate (~0.5) to avoid complete chaos.
- “Minimal ringing or overshoot (for high-contrast or cartoon images)” – Use a strong stability preserving method: *ssprk3_3s** (3-stage SSP) with Normal schedule. SSPRK3 is third-order and designed to avoid introducing oscillations (it’s literally built for monotonic decay in PDEs). It’s great for preserving edge integrity (no halos). The linear schedule keeps things simple to not upset SSP properties.
- “Highest detail regardless of speed (I’ll wait)” – Combine *res_5s** (5-stage refined explicit) as predictor and *gauss-legendre_5s** (5-stage Gauss collocation) as an implicit corrector, with Karras schedule. This two-step approach (set IMPLICIT_SAMPLER_NAME to gauss-legendre and a few implicit steps) “demonstrates your commitment to climate change (and image quality)” – i.e. it’s extremely slow, but yields exceptionally accurate denoising. Gauss-Legendre is 10th-order for 5 stages and symplectic; it will squeeze out detail that other methods miss. Use maybe 1–2 implicit refinement steps – beyond that returns diminish.
- “Make it like the training images” – Try *ddim** sampler with Beta scheduler. DDIM sampler with a beta(α, β) schedule can mimic the original diffusion trajectory (since many diffusion models used a beta schedule during training). For example, Beta(0.5,0.7) is available as “beta57”. This combination often yields the “vanilla” diffusion look, useful for comparisons or keeping color and composition closer to stock.
*(TL;DR: for everyday use, many power-users start with RES samplers (2M or 3M) and either Karras or Bong_Tangent schedule, at ~20–30 steps. That tends to give a good quality vs speed trade-off on SDXL and similar models.)*
---
Below, we provide detailed per-sampler breakdowns, a pairing recommendation matrix, and additional context (glossary, reproducible tests, and an FAQ). All claims are cited from RES4LYF’s documentation or authoritative references – no guesswork. If something isn’t documented, we’ll note that too.
## Sampler Reference Cards
Each sampler is listed with its type (**class**), a one-line integration idea, documented order & stages, any stability/behavior notes from docs, when to use it, recommended scheduler pairing (if known), and pitfalls (if any). Samplers are grouped by family.
### Multistep Samplers (reuse previous steps)
**Integration idea:** Multistep methods use earlier step results to extrapolate the next step, instead of substeps. They achieve higher order at low cost (only 1 model call per step), but may be less stable/accurate than multi-stage methods of the same order.
- res_2m – Class: multistep (RES family). Idea: A 2-step rectified Euler method (refined DPM++ 2M). *Order/Stability:* Not explicitly stated, but likely 2nd order (two-step) with enhancements. Behavior: Designed to converge linearly and reliably. The RES family are improved versions of DPM++ with higher accuracy, so res_2m can be seen as a high-precision 2-step solver. *Best for:* General use with speed – it’s very fast (Euler-speed) yet more accurate than vanilla Euler or even DPM2. Excels at img2img and guide-based tasks due to linear convergence (avoids overshoot). Steps guidance: The docs note **“typically only ~20 steps are needed with RES samplers”* – so try 20–30 steps, which often outperforms 50+ steps of common samplers. Schedulers: No exclusive pairing stated; however, community tests praise bong_tangent with res_2m for detail and speed. Also works well with Karras for quality or Exponential for quick drafts. Pitfalls: None documented explicitly. As a multistep method, it might struggle if the model’s behavior changes abruptly (because it relies on previous step linearity). But overall it’s a flagship sampler for quick, quality results.
- res_3m – Class: multistep. Idea: A 3-step rectified method (refined DPM++ 3M). Order: Not stated, but presumably 3rd order (uses three prior points). Behavior: Same philosophy as res_2m – higher order and accuracy, with minimal cost. The README’s showcase compares RES_3M vs UniPC and shows RES_3M achieving top quality in 20 steps. Use for: Cases needing slightly more accuracy than 2m – e.g. more complex scenes or animations where a bit more stability helps. It still converges linearly but to a higher-order target, potentially yielding sharper results at equal steps. Steps: ~20 is often enough; you can try 30–40 if image is very complex. Schedulers: No specific call-outs in docs. It performed excellently with the default “normal” schedule in tests (20 steps, normal gave a sharp output). Likely pairs well with Karras for detail at low steps (Karras emphasizes later refinement which a 3rd-order method can exploit). Pitfall: Not noted; but as with any multistep, divergence can happen if steps are too large – e.g. if you try <10 steps, a multi-step might overshoot where a multi-stage wouldn’t. Anecdotally, though, res_3m is robust and a go-to for high quality fast sampling.
- dpmpp_2m – Class: multistep. Idea: The classic DPM++ 2M (Karras et al. / Lu et al.) – a second-order two-step solver using a predictor-corrector with prior step reuse. Order: 2 (as per “2” in name). Stages: 1 per step (multi-step, not multi-stage). Behavior: Was known to produce good detail and hands in Stable Diffusion v1. RES4LYF includes it mainly for completeness (and baseline). Use: If you want to compare against standard samplers or ensure compatibility with results from other UIs. It’s stable and solid for most cases, though generally res_2m or res_3m outperform it in quality at the same steps. Steps: 20–50 depending on desired quality; no official guidance, but stable diffusion users often used 20–30 with DPM++ 2M Karras for good results. Schedulers: Often used with Karras (hence “DPM++ 2M Karras”) to improve convergence. Also fine with Normal or other spacings. Pitfalls: None major – but relative to newer samplers, it might require a few more steps to match quality.
- dpmpp_3m – Class: multistep. Idea: DPM++ 3M – a third-order multistep extension of DPM solver. Order: 3 (implied by “3”). Behavior: Should yield even better accuracy than 2M at the cost of using two prior points. Not extensively documented in RES4LYF (no direct mention of 3M’s internals), but logically it’s the multi-step variant of DPM-Solver++ order 3 from literature (Lu et al. 2022). Use: A middle ground between DPM++ 2M and explicit multi-stage samplers. If 2M leaves some haze, 3M might clear it up by that extra order. Steps: 15–25 likely suffice for SD1.5/SDXL. Schedulers: Karras is a safe bet (it was designed to work with DPM++ in Karras’ EDM paper). No special scheduler noted in docs. Pitfall: Slightly more risk of instability than 2M (higher order multi-step can oscillate if you push step size too far). If using very few steps (<15), monitor for odd artifacts – if seen, try falling back to 2M or using an implicit corrector.
- abnorsett_2m / 3m / 4m – Class: multistep. Idea: These are Adams–**B**ashforth or Norsett-inspired multi-step methods (the naming isn’t explained; likely honoring Dahlquist & Nørsett). They presumably use adaptive coefficients or higher-order formulas up to 4-step. Order: Not stated in docs. Given 4m uses four previous steps, it could reach up to 4th order. Possibly these implement Norsett’s multi-step predictor formulas (Nørsett co-authored a famous ODE text). Behavior: “AbNorsett” samplers may emphasize stability or error minimization (since Norsett’s work often did). They likely converge linearly like other multisteps but with more history to draw on. Use: If you have lots of steps to utilize (e.g. >50) or are doing something like a guided process where preserving past trend is good. However, not much documentation or usage anecdotes – meaning they are probably experimental. Steps: No official guidance. If trying abnorsett_4m, ensure you have at least 4–5 steps per order (~20+) to get benefit. Schedulers: No info. Try Normal or Karras first. Pitfalls: Not documented, but multi-step methods with many steps can suffer if initial steps are not well-behaved (the first few steps might need a kicker). Possibly not recommended for short runs or highly nonlinear transitions (like drastic style changes mid-sampling). In absence of docs, consider these advanced tools for special cases.
- deis_2m / 3m / 4m – Class: multistep. *Idea:* Diffusion Exponential Integrator Sampler (DEIS) in multi-step form. DEIS was introduced by Zhang & Chen (2022) as an exponential integrator approach to diffusion ODEs. Here, 2m/3m/4m likely correspond to multi-step versions akin to Adams methods applied to the DEIS formulation (the original paper had ρAB-DEIS which is a multistep variant). Order: Presumably 2, 3, 4 respectively (if analogous to DPM++ naming). Behavior: DEIS methods explicitly treat the linear part of the SDE by an integrating factor, achieving high quality with fewer steps. In multi-step form, they leverage previous gradients for efficiency. Use: DEIS samplers can be very fast and accurate for diffusion models, often outperforming DDIM at low step counts. Use these if you want a possibly sharper result than plain DPM++ but still want to avoid multi-stage cost. Steps: The original DEIS achieved good results in ~15 steps for CIFAR-like data; for SD, try ~20–30. Schedulers: Not stated explicitly; DEIS authors mention using their own time step scheme. You might try SGM_uniform or Karras, since DEIS leverages the continuous SDE solution (Karras schedule might complement it). Pitfalls: Not documented in RES4LYF. Empirically, DEIS may oversharpen at too high step counts (anecdotal forum reports outside RES4LYF). If using 4m with 50+ steps, watch for high-frequency noise or loss of diversity (the integrator might overshoot perfection and introduce detail that looks unnatural). Generally, though, DEIS is well-regarded as a stable method.
### Exponential Samplers (explicit Lawson/ETD-type integrators)
**Integration idea:** Exponential integrators decouple the ODE: they analytically integrate the linear part of the diffusion equation (often the noise term), and use RK for the nonlinear part. This often allows larger stable steps and better handling of stiffness (noise decay can be steep). Many of these are “Lawson” type (apply an integrating factor $e^{-t}$) or ETD (Exponential Time Differencing) schemes from PDE literature.
*(Note: All “_s” here indicate substeps per step, i.e. multi-stage. e.g. 3s = 3-stage explicit RK with exponential treatment.)*
- res_2s / res_2s_stable / res_2s_rkmk2e – Class: exponential explicit. Idea: These are 2-stage, 2nd-order exponential integrators, presumably unique to RES4LYF. “RKMK2e” suggests a Runge-Kutta Munthe-Kaas type method (Munthe-Kaas developed Lie-group exponential integrators) for 2 stages. The “stable” variant might use a coefficient set optimized for stability (e.g. L-stability or avoiding oscillations). Order: likely 2 for all, with small differences in internal coefficients (docs do not list details). *Behavior:* res_2s is essentially the simplest exponential RK: similar to Heun’s method but in the exponential frame. It costs 2 model calls per step. The stable variant may dampen any non-monotonic intermediate values (some 2nd-order integrators can overshoot; a “stable” one might have monotonic dissipative property). Use: As a starting exponential method if you want a bit more accuracy than Euler but minimal complexity. If res_2m (multistep) ever shows slight bias, try res_2s which might correct that with a true two-stage update. Steps: Not specified, but since it’s only 2nd order, you might need moderate steps (30–50) for very clean results. However, thanks to exponential handling, it might still outperform a plain 2-stage RK at large step sizes. Schedulers: No special pair noted. A Karras or Normal schedule would be fine. Possibly use “simple” if you explicitly want to test the integrator’s own stability (simple linear schedule plus stable integrator = very controlled). Pitfalls: None documented. Possibly “res_2s_non-stable” (the base version) might show slight non-monotonic behavior in some pixel intensities – if so, that’s exactly what res_2s_stable addresses. These differences would be subtle and mostly in edge cases (like extremely large guidance or tricky prompts).
- res_3s / res_3s_non-monotonic / res_3s_alt – Class: exponential explicit. Idea: 3-stage, 3rd-order exponential integrators. The base likely corresponds to a Lawson-Euler 3rd order or an ETDRK3 scheme. The “non-monotonic” label implies one variant allows slight overshoot for possibly higher accuracy (maybe it’s an optimized ETD3 that isn’t SSP). The “alt” might be an alternative coefficient set (e.g. one could be Cox–Matthews 3rd order, another a variant by Beylkin or others). Order: 3 (if standard). Behavior: 3-stage exponential integrators strike a good balance: e.g. Cox & Matthews (2002) introduced a popular ETD RK3. These methods can sometimes produce negative intermediate values (hence non-monotonic) but achieve better accuracy on oscillatory solutions. Use: When 2-stage isn’t enough, but you still want to keep cost moderate. Good for fine textures or when using SDE mode – the higher order helps maintain detail when noise is injected. Steps: ~20–30 usually suffice at order 3. Schedulers: Try Karras for quality or SGM_uniform if you suspect the model’s native schedule (score-based) suits this integrator. Pitfalls: Not explicitly noted. The existence of “non-monotonic” suggests the default res_3s might sacrifice a bit of monotonicity for accuracy, which is normally fine for image generation. If you notice any unusual artifacts that diminish with more steps, consider switching to the alt or using the stable 2s or 4s.
- res_3s_cox_matthews / res_3s_lie – These are specific 3-stage integrators: Cox–Matthews is likely the ETDRK3 scheme from 2002, and Lie could refer to a Lie–Trotter splitting method (though Lie–Trotter is usually 1st order; perhaps here it’s a Lie-group RK of order 3, or even referencing Munthe-Kaas “Lie” method). Order: Cox–Matthews ETDRK3 is 3rd order; “Lie” might be a lower-order splitting used as comparison (maybe 3rd if it’s Strang splitting like Lie–Strang). Behavior: Cox–Matthews ETD3 is explicit but known to sometimes be unstable for very stiff problems (not an issue in diffusion usually). It’s a well-tested method for many PDEs. The “lie” method likely provides a different flavor, possibly simpler and more diffusive (since Lie splitting steps linear and nonlinear parts separately). Use: If you’re testing academic integrators or have a scenario where certain structures (like symmetries) are preserved by a Lie integrator. For most users, these won’t drastically differ from res_3s base. Steps: 20-ish. Schedulers: No special mention; stick to Normal or Karras. Pitfalls: None specific. Perhaps the Lie method might show slightly more blurring (splitting can be a bit less accurate per step than full integrator at same order, but more stable). Without official notes, treat them as alternatives to try if others fail.
- res_3s_strehmel_weiner – Strehmel & Weiner (1987) developed exponential integrators (their names appear in exponential integrator literature). This likely implements one of their methods, perhaps ETD3 with stability enhancements. Order: likely 3. Behavior: Possibly more stable than Cox–Matthews if it was designed with that in mind. Might involve computing matrix exponentials in a clever way (beyond our scope here). Use: Advanced usage; if you notice other 3s produce slight artifacts, maybe this one fixes it. Otherwise, differences are minor. Pitfalls/notes: not documented beyond the name drop, indicating experimental inclusion.
- res_4s_krogstad / res_4s_krogstad_alt – Class: exponential explicit. *Idea:* Krogstad’s 4th-order ETD (Krogstad 2005). Krogstad introduced a renowned 4th-order ETD RK (sometimes called ETD-RK4). The alt likely uses a modified formula (maybe a later improvement or a variation for better stability). Order: 4. Stages: 4. Behavior: High accuracy, but requires computing several φ-functions of the linear operator (which in diffusion context are handled analytically since linear part is simple $- \sigma$). It’s more computationally heavy (4 model calls per step, plus overhead), but yields sharper results. One test found an 8-stage Minchev (see below) and other 4+s methods among the top quality images, implying 4th+ order ETD methods shine in detail. Use: When you want very sharp edges and textures without going implicit. It excels at preserving fine details (a 4th order method has lower local error, meaning less detail lost each step). Steps: You can often get away with ~15–20 steps for decent results due to high order, but at cost of 4* that in model calls. For ultimate quality, 30 steps (120 evals) might surpass virtually any lower-order method’s 50 steps. *Schedulers:* Karras recommended – high-order integrators benefit from sigmoidal schedules because they handle large early steps well and then refine small steps well. A community result singled out res_4s_minchev (another 4th-order ETD) as producing “very good” quality at 95s vs others, implying any of these 4th order ETDs with a decent schedule will do great. Alt vs non-alt: you might try both if curious; differences would be subtle unless pushing near stability limits. Pitfall: Running a 4th-order method at too few steps (say 5-10) might result in over-sharpening or slight inaccuracies because each step assumes a smooth polynomial solution – if the model’s behavior is non-smooth between wide steps, error could manifest as minor artifacts or overshoot. Mitigate by using sufficient steps or adding a touch of noise (SDE mode) to regularize.
- res_4s_strehmel_weiner / alt – Strehmel & Weiner also proposed a 4th order scheme in late 80s. Similar story to Krogstad: an ETD4 integrator. The alt might be a variation or the “A/B” versions sometimes found in literature. Order: 4. Use: Same use case as Krogstad’s: high-accuracy needs. You might not notice much difference between Krogstad and Strehmel–Weiner results unless under extreme conditions; both target the same order. No specific notes documented. Try these if Krogstad’s yields any instabilities or just for thoroughness.
- res_4s_cox_matthews – Cox & Matthews also have a 4th-order ETD (ETDRK4, famous for reaction-diffusion equations). However, ETDRK4 in their paper is actually the classic scheme that’s widely used (and requires careful polynomial interpolation to avoid NaNs). It might be included here. Order: 4. Behavior: Very accurate but known to have potential NaN issues if not implemented with contour integrals (in PDE context). The RES4LYF implementation likely handles it fine for diffusion ODE. Use: Any scenario needing high precision. If multiple 4s are available, one might check which gives the best result for a given prompt (they should be similar). Pitfalls: If any ETD4 were to produce numerical overflow, it’d be Cox–Matthews’ (due to dividing by small exponentials in intermediate steps), but this is speculation – likely fine in this controlled setting, just something historically noted in papers.
- res_4s_cfree4 – “cfree4” likely stands for commutator-free order-4 integrator. Commutator-free Lie integrators (by Celledoni, Owren, etc.) avoid calculating matrix commutators, making them efficient for certain high-dimensional problems. Order: 4. Behavior: These often preserve certain invariants or structures, and are stable. Possibly from Minchev & Munthe-Kaas (they described commutator-free schemes in a 2004 study). Use: Perhaps with flow models or when combining transformations (commutator-free might better handle dynamic conditioning?). For typical image generation, it likely behaves like any other 4th-order ETD. No special notes, included for completeness.
- res_4s_friedli – Friedli (1978) is credited with the first exponential RK methods. This could be an implementation of Friedli’s 4th-order method (he described one in his thesis). Order: possibly 4. Behavior: As a pioneering method, it may not be as optimized as later ones for stability, but it’s exact for linear part. Use if you’re curious historically. It will work as a 4th-order ETD integrator. Pitfalls: None noted, but earlier methods might have tighter stability constraints (so if at very large step sizes it diverges while Krogstad doesn’t, that’s why). Keep steps moderate.
- res_4s_minchev / res_4s_munthe-kaas – These reference Minchev & Munthe-Kaas (2004) who analyzed high-order exponential integrators. Possibly one is the method “ϕ4” from their work, and the other a variant or an 8-stage 4th-order method they recommended. Order: 4 (though some of their work also covers 6th order, but given “4s”, likely 4th order methods). Behavior: These might be fine-tuned for certain stability or efficiency aspects (Minchev & Munthe-Kaas looked at stiff order conditions). Use: They were highlighted in the comparative chart: res_4s_minchev produced one of the top results (very good) while running in 95 seconds for 16 steps. This suggests it’s both fast and high quality – anecdotally, a great choice for sharp outputs. It may introduce a tiny bit more noise or creativity than Krogstad’s (since different coefficient choices can slightly affect style). Pitfalls: None specific; if one is labeled “munthe-kaas” it might be more geared to Lie-group integration (relevant if the model had a Lie algebra structure, which here is not obvious – likely just naming credit). Both are safe picks for high-quality results.
- res_5s – Class: exponential explicit. Idea: A 5-stage, likely 5th-order integrator. Possibly a straightforward extension or one of Hochbruck–Ostermann’s methods. Order: If it’s consistent with naming, 5. But the docs don’t confirm, saying “most notably RES_5S implemented”. At least it’s higher than 4. Behavior: The doc highlights RES_5S as one of the notable new explicit samplers, implying it’s a star performer. It probably has very high local accuracy, meaning extremely sharp outputs if used right. However, being 5-stage, it’s heavy: 5 model calls/step. It might overfit the noise schedule a bit (5th-order can sometimes “assume” too much smoothness). Use: For absolute fidelity – e.g. photorealistic images where every micro-detail matters. Or when doing very low denoise strength (like 0.1 in img2img) where you need sampler accuracy to preserve details. Steps: You can try as low as 10–15 steps and often get away with it given the order (but that’s 50–75 model evals). Otherwise ~20 steps (100 evals) will be extremely clean. *Schedulers:* Karras strongly recommended – a high-order sampler paired with Karras’ smooth spacing is often ideal. If using SDE, maybe drop to 4s or 3s; 5s SDE might be overkill. Pitfalls: Diminishing returns beyond a point: you might not see much difference between 5s and 4s unless the scenario is complex or you push fewer steps. Also, 5th order methods can be less stable than 4th if pushing to very large step sizes or weird schedules (but with normal usage this is fine).
- res_5s_hochbruck-ostermann – Likely the 5th-order ETD RK by Hochbruck & Ostermann (they published a 5(4) pair in 2005). Order: 5. Behavior: Should be similar to res_5s if that wasn’t already HO’s method. Possibly one is the base RES_5S, and this explicitly credit HO’s coefficients (maybe slight differences). HO are experts in exponential integrators for parabolic PDEs, so their method might be particularly stable. Use: If using implicit guides or particularly stiff conditions, HO’s method could maintain stability. But in generation tasks, it should behave just as an excellent high-order sampler. No special user guidance given beyond commitment to climate change if used with implicit refine – translation: it’s very slow.
- res_6s, res_8s, res_10s, res_15s, res_16s – Class: exponential explicit. Idea: These are extremely high stage integrators, presumably aiming for very high order (perhaps up to 16th order for 16s!). They are not individually documented, implying they were added to experiment with how far one can push explicit solvers. Order: Not stated; presumably equals stages for the Gaussian quadrature integrators, but these are explicit – likely they use some schemes of those orders (maybe adapted from Butcher’s high-order RK or Taylor methods with automatic differentiation?). Behavior: Expect diminishing returns: as order increases, if the model’s true ODE isn’t smooth enough (due to neural network noise), super-high order doesn’t buy much. However, they will minimize error at any reasonable step size. Use: Largely experimental. You might use e.g. res_8s if generating at only ~8 steps (attempting “one step per order” ideal) – e.g. 8 steps with an 8th-order method might produce something workable where Euler would fail completely. If you’re trying crazy low-step generations (like 5–10 steps total for a 1024px image), these could be interesting. Steps: If using these at all, try a very low step count relative to normal (because if you do 50 steps with a 16th-order method, you’re really overshooting – numerical error will be negligible compared to model stochasticity). Schedulers: No data; presumably Simple or Linear might suffice because these integrators can handle it (maybe combine a linear schedule with a 16th-order method to basically solve the ODE near-exactly in few large jumps). Pitfalls: Enormous computation (16s = 16 model calls per step). Also, potential for numerical overflow if extreme (but likely fine here). The law of diminishing returns: beyond order ~8, the improvements are theoretical – the diffusion model and quantization noise introduce errors that numerical precision can’t overcome. So these are more for academic completeness.
- etdrk2_2s – Class: exponential (ETD). Idea: A specific 2nd-order ETD RK (probably ETD2, the simplest scheme also known as exponential trapezoidal or similar). Order: 2. Behavior: It’s like res_2s but likely a canonical implementation of Cox–Matthews ETDRK2. Use: If you want a well-tested stable 2nd order ETD. Not much to add beyond res_2s notes. Steps: 30+. Pitfalls: none beyond second-order limitations.
- etdrk3_a_3s / etdrk3_b_3s – Two variants of 3rd-order ETD RK. Possibly “A” and “B” from some paper (maybe related to different ways to compute intermediate matrix exponentials). Order: 3. Use: Same as res_3s: good general high-fidelity sampler. If one is labeled A vs B, one might prioritize stability over error or vice versa. No doc guidance beyond names. Trying both on a tough prompt to see if one yields fewer artifacts could be informative.
- etdrk4_4s / etdrk4_4s_alt – Cox & Matthews ETDRK4 and an alternative (perhaps the Kassam & Trefethen variant that addresses stability issues). ETDRK4 is 4th order and widely used, but one must carefully compute φ-functions to avoid numerical issues. The alt likely does just that. Order: 4. Use: High-quality sampling. Pitfalls: If any integrator here were to produce a NaN or diverge, it’d be ETDRK4 without stabilization at large step sizes. The alt presumably fixes it, so prefer alt unless you have reason not to. Again, this is a fine detail – in diffusion, matrix exponentials are easy (they’re just scalars e^{-λΔt}), so it might be moot and both work similarly.
- dpmpp_2s / dpmpp_sde_2s – Class: exponential explicit (though these could also be considered advanced single-step solvers). Idea: DPM++ 2S is the single-step second-order solver from Karras/LDMS (using a mid-point correction). DPM++ SDE 2S is the stochastic version designed for SDE (it adds noise in a midpoint manner). Order: 2 (for ODE version). Behavior: DPM++ 2S is known to be very accurate and tends to produce slightly smoother outputs than 2M since it recalculates mid-step rather than relying on previous steps. The SDE 2S variant will include randomness at each step like PLMS with noise, giving more diverse outputs. Use: These were many users’ go-to in Stable Diffusion 1.x era for good detail. Use DPMPP 2S when you want deterministic but high-quality results; use DPMPP SDE 2S if you want a dash of randomness for creative effects while still using a proper solver each step (less chaotic than full Euler SDE). Steps: ~20 is usually enough (the community often ran DPM++ 2S a Karras 20–30 steps for great images). *Schedulers:* Karras is practically assumed for DPM++ in many references – it was tuned for that. Both ODE and SDE versions benefit from Karras or at least some sigmoidal schedule. Pitfalls: The SDE version, if run for too many steps (say >100), won’t converge – it will keep injecting noise (“non-deterministic samples don’t converge at high steps”), so don’t overshoot steps expecting a stable output. The ODE version will converge but if you push steps very high, watch out for floating point precision issues (generally not a problem in 32-bit until thousands of steps).
- dpmpp_3s – Class: exponential explicit (or just explicit multi-stage). Idea: Possibly the 3rd-order single-step variant (if it exists – DPM-Solver++ had order 3 solver as well). Order: 3. Behavior: A bit more accurate than 2S at cost of extra eval. Use: Rarely needed; 2S was usually the sweet spot. But if you find 2S slightly lacking, 3S is here. Steps: 15–25. Pitfalls: None known.
- lawson2a_2s / lawson2b_2s – Class: exponential explicit. Idea: Two different 2-stage Lawson methods. Lawson (1967) introduced the idea of using $e^{At}$ factor for linear part; these might refer to two specific sets of coefficients from his paper or subsequent work labeled “Method 2a” and “2b”. Order: 2. Behavior: They likely differ in how they weight the stages (one might minimize error constant, another might be L-stable in linear case). Use: If you specifically want a stable 2nd order method that exactly integrates the linear part. For instance, if using an older model with known linear behavior, Lawson’s might do well. In practice, similar to etdrk2. No strong recommendations in docs.
- lawson4_4s – A 4-stage Lawson method, presumably 4th order. Possibly Lawson’s original 4th order scheme or a later development. Order: 4. Use: Similar role as ETDRK4. Use if you want an exponential integrator but maybe fewer φ-function computations (Lawson methods often turn the problem into needing standard RK on the nonlinear transformed system).
- lawson41-gen_4s / lawson41-gen-mod_4s – These cryptic names suggest a generalized Lawson 4(1) method, perhaps an embedded pair (4th order with 1st order error estimate) or generation method. The “mod” could be a modified version. Use: Possibly for steps adaptivity or error tracking (though adaptivity isn’t exposed in UI). Without adaptivity, they’d just behave as 4th-order. They might have been included for future-proofing.
- ddim – Actually listed under explicit samplers (as “ddim” with no stages). It’s a special case: Denoising Diffusion Implicit Model sampler by Song et al. (2020), which can be seen as a first-order ODE integrator that exactly matches the diffusion process when steps = original count. It’s not a classical RK but fits here as an explicit method. Order: effectively 1 (it’s like Euler method applied to a non-linear schedule, though it can be surprisingly accurate). Behavior: Deterministic, tends to give smoother, lower-contrast outputs compared to PLMS or DPM++. It’s sometimes used for style or when simulating how diffusion progresses. Use: When you want to replicate a known reference (like to produce the same result as a certain DDIM step count from another tool). Or if you desire its characteristic softer look. Steps: Historically people use 50 DDIM steps to mimic 100 DDPM steps, etc. You can start with 20–50. *Schedulers:* DDIM_uniform is logically the match (the sampler ignores the sigma input somewhat because it has its internal formula, but RES4LYF’s scheduler will influence it). Using DDIM with the “ddim_uniform” schedule best replicates standard DDIM. Pitfalls: Because it doesn’t correct error (no PC, no higher order), it may lose fidelity at low steps (under 20, e.g., can be muddy). Also, it lacks the ability to recover from mistakes – each step directly maps a fractional time step to latent, so any error carries forward.
- euler – Also listed under explicit. The simplest sampler: 1 model eval per step, first-order. In KSampler this is “Euler” (ancestral variant adds noise). In RES4LYF context, Euler is the probability flow ODE Euler solver (deterministic). Order: 1. Behavior: Fast but low accuracy. Tends to oversmooth or under-shoot details unless many steps are used. Use: For quick previews or if you intentionally want a simpler, possibly more varied result (with ancestral noise, Euler a is popular for its creativity – but in ODE mode here, it will be deterministic, so creativity only via prompt). Steps: ~30–100 depending on needed quality. It’s linear convergence, so doubling steps roughly halves error. *Schedulers:* Exponential works great for Euler – it covers the big stuff quickly and Euler doesn’t do well with many small steps at high noise anyway. That combination was the fastest in one test (16 steps in 24.5s). Euler with Karras is also used to refine quality at high step counts (Karras schedule reduces Euler’s error in later stages by making steps very small when they matter most). Pitfalls: Very low-step Euler (like <10) often yields bad outputs or very unrealistic ones. It lacks the corrections higher-order methods have, so structure may be less coherent (could manifest as repetitive detail artifacts or wrong anatomy at moderate steps).
### Hybrid Samplers (Predictor–Corrector / mixed methods)
**Integration idea:** Hybrids combine multiple methods – often an explicit predictor and an exponential or implicit corrector. They leverage strengths of both: explicit predictor for speed, then a partial correction to improve accuracy or stability. Notably, “PEC” means Predict, Evaluate, Correct, often referencing Norsett’s predictor-correctors.
- pec423_2h2s / pec433_2h3s – Class: hybrid (probably Predictor–Explicit–Corrector). The notation suggests something like: 4-2-3 stands for a predictor of order 4, corrector of order 3, etc. Actually, PEC423 might mean a 2-step predictor, 4th order predictor, 2nd order corrector, 3rd overall? It’s not entirely clear, but likely these implement a predictor followed by a corrector iteration using half the stage count “h”. For example, pec423_2h2s might do a 2-stage predictor, then another 2-stage corrector (so hybrid 2+2 = effectively 4 stages?). Behavior: Hybrids of this sort can improve stability without going fully implicit. Use: Possibly designed for cases where explicit alone was slightly insufficient. They might allow a larger step size or better detail with fewer overall model calls by reusing evaluations. No direct documentation; treat as advanced if others fail. Use a moderate scheduler (Normal or linear) so that the predictor-corrector interplay is well-behaved.
- abnorsett2_1h2s, abnorsett3_2h2s, abnorsett4_3h2s – These appear to embed AbNorsett multistep methods into hybrid forms. E.g., “abnorsett2_1h2s” might mean an AbNorsett 2-step method with 1 hybrid iteration using a 2-stage method. Possibly a predictor (AbNorsett) then one correction via 2-stage implicit or explicit. It’s highly specific and not detailed in docs. Use: Only if you deliberately want to experiment with multi-step + small correction.
- lawson42-gen-mod_1h4s through lawson45-gen-mod_4h4s – These look like a series of Lawson methods combined with something (“gen-mod” again). The prefix suggests maybe an embedded family Lawson4.2, 4.3, 4.4, 4.5 which are then used in hybrid form (h?). The numbers before h (1,2,3,4h4s) likely mean how many explicit half-steps or something. Honestly, these are not documented and likely experimental. Use: They might aim to achieve very high order or special stability by combining multiple 4-stage integrator passes in one step. Unless you’re an integration researcher, you can probably skip these; or if you are, you might consult the code for how they’re constructed. (In practice: run some tests with a fixed seed across these to see differences. Without official notes, one cannot say which scenarios they benefit.)
In summary, Hybrid samplers in RES4LYF are niche. The typical user will rarely need to select these manually – they exist perhaps to support internal “chains” or as stepping stones to fully implicit methods. If you do use them, note that they internally disable ComfyUI’s noise addition in certain modes (unsampling/resampling contexts) to manage the two-phase integration properly. Always keep SAMPLER_MODE = standard unless you specifically are doing an unsampling workflow.
### Linear (Explicit ERK) Samplers
**Integration idea:** These are standard Runge-Kutta methods without exponential factors. They treat the diffusion ODE as is, explicitly. They are included partly to leverage known properties (like symplecticness, SSP, etc.) and partly for completeness (one might discover a classical RK yields a particular aesthetic). All are ODE (non-SDE) samplers by default, though you can turn on SDE mode to add noise post-step.
- ralston_2s / 3s / 4s – Class: explicit RK. Idea: Ralston’s methods – optimized RK with minimum error bounds for given stages. 2s is Ralston’s 2-stage second-order method. 3s is Ralston’s 3-stage third-order. 4s is Ralston’s 4-stage fourth-order method. Behavior: These prioritize even error distribution. They tend to slightly undershoot overshoot, producing very stable integration for their order (hence minimum error constants). For image generation, that means reliable, if maybe a touch less “sharp” than some other RK of same order (because they avoid aggressive slopes that could overshoot). Use: Great for stable, artifact-free results if you match steps appropriately. For instance, if you want a well-behaved 3rd-order sampler, Ralston 3s is a good pick. Steps: ~20 for 2s, ~15-20 for 3s, ~10-15 for 4s (because higher order needs fewer steps). *Schedulers:* Normal suits Ralston’s philosophy (uniform improvement each step). Also Beta or linear_quadratic might pair nicely to further minimize any erratic change. Pitfalls: None documented. Ralston’s methods are not specialized for stiffness, so if you push step count very low, they’ll fail like any explicit RK. But within normal use, they’re quite robust.
- midpoint_2s – Class: explicit RK. Idea: The explicit midpoint method (also known as RK2 or “modified Euler”). Order: 2 (and symplectic). It’s the simplest Gauss–Legendre collocation as Wikipedia notes. Behavior: Slightly better than Euler; tends to damp less than Heun’s method. It’s actually symplectic (though that’s more relevant for conservative systems). In diffusion, it’s just a standard second-order that might preserve some geometric structure. Use: If Euler was too crude but you want minimal extra cost. It might give a bit more contrast or structure preservation than Heun because it’s the implicit midpoint’s explicit twin (which is symplectic, though explicit midpoint itself isn’t symplectic, implicit is – so scratch that, explicit midpoint is just another term for modified Euler). Steps: ~30. Pitfalls: None unique; it’s just an ordinary method seldom uniquely best.
- heun_2s / 3s – Class: explicit RK. Idea: Heun’s method typically refers to the explicit trapezoidal rule (2-stage, 2nd order) – that’s heun_2s. Heun’s 3s likely refers to a less-common 3-stage method by Heun or in his style (maybe an older 3rd order method). Behavior: Heun 2s (also called “improved Euler”) is a bit more diffusive than midpoint: it averages the slope, which often yields smoother, slightly less sharp results than midpoint method. But it is good for avoiding overshoot. The 3-stage Heun might be akin to Kutta’s 3rd order or some variant (the exact method is unclear from name, possibly identical to Ralston’s 3rd since Heun did propose some higher order in early 1900s). Use: For stable progression with fewer ringing artifacts. Good if your images had some repetitive noise with other methods – Heun’s averaging might mitigate that. Steps: ~30 for 2s, ~20 for 3s. Schedulers: Normal or Karras. (Heun’s doesn’t have special scheduling needs.) Pitfalls: Slightly more blurring relative to midpoint or Ralston (because it damps changes more). Not a big difference at proper steps though.
- houwen-wray_3s – Class: explicit RK. Idea: Van der Houwen & Wray’s 3-stage, 3rd-order method. They likely designed it with some property (like FSAL or minimized error). Behavior: If it’s the one I suspect, it might be the same as Ralston 3rd or similar. Possibly they introduced an alternative third-order with maybe lower error in some scenario. Use: Hard to differentiate usage without specifics – treat as another option if other 3-stage methods produce subtle differences. No pitfalls known.
- kutta_3s – Class: explicit RK. Idea: Kutta’s original 3-stage 3rd-order method from 1901[1]. Behavior: It’s a historically important method but has a larger error constant than Ralston’s 3-stage. It might overshoot slightly more (leading to a bit more contrast?). Use: Nostalgic or experimental; probably not outperforming modern optimized ones. Pitfalls: none special, it’s a solid method.
- ssprk3_3s – Class: explicit RK. Idea: The Shu–Osher 3-stage SSP method (a.k.a. RK3 with TVD properties). Order: 3. Behavior: It guarantees no new extrema (for convex combinations) if time-step is within certain limits. For diffusion, this likely translates to no overshoot in pixel intensities beyond what’s expected, giving very stable images. It’s known to be the optimal 3-stage 3rd-order SSP method. Use: If you encountered weird artifacts like stripe patterns or pixel ringing with other samplers, SSPRK3 can help avoid that due to its strong stability preserving nature. It might produce a bit “flatter” image (less micro-contrast) but very orderly. Steps: ~20–30. *Schedulers:* Normal is a good match (monotonic decay). Pitfalls: Only that it might be slightly more conservative (could hide some texture by smoothing it out, because it avoids overshoot). But results will be consistent.
- ssprk4_4s – Class: explicit RK. Idea: A 4-stage attempt at SSP 4th order. Note: truly SSP 4th-order explicit RK requires at least 8 stages (Shu proved no 4-stage can be SSP of order 4 except trivial zero step-size). Possibly this method is one that maximizes SSP coefficient but isn’t fully SSP for all steps. In practice, it might be just a decent 4th-order method that tries to avoid overshoot. Behavior: Should be high accuracy and fairly stable, but not absolutely monotonic like the 3-stage case. Use: If you want 4th-order but worry about artifacts, try it. Pitfalls: If expecting full SSP, note it’s not guaranteed beyond a certain threshold. But likely not an issue in our context.
- rk38_4s – Class: explicit RK. Idea: The “3/8-rule” Runge-Kutta, which is an alternative 4th-order method to the classic RK4. It has a different distribution of error (slightly better phase properties for oscillatory problems). Behavior: Both RK4 and RK3/8 are 4-stage order 4, but RK3/8 tends to spread error more evenly. It might produce marginally different image details – one might give a bit more contrast, the other a bit more smoothness. The differences are subtle. Use: You can switch between rk4_4s (classic) and rk38_4s if you’re chasing tiny differences in output style; otherwise, treat them as the same class. No strong use guidance in docs, just included.
- rk4_4s – Class: explicit RK. Idea: The classic Runge-Kutta (a.k.a. RK4 or Kutta’s 4th-order from 1901). Order: 4. Behavior: The gold standard of generic integrators – good accuracy, stability not bad but not L-stable. It tends to produce crisp results when enough steps are given. Indeed, in the sampler comparison, a 7-stage variant of RK (Dormand-Prince) gave best quality; RK4 is a step below that but still excellent. Use: Good general-purpose if you don’t want to fuss with exponential stuff. It’s likely to yield results similar to DPM++ 2M at 2x steps, etc. Steps: ~15–25. Schedulers: Karras recommended for fewer steps (since RK4 can handle larger steps early and refine later with Karras’s small end steps). Pitfalls: Slightly less stable at very large step sizes – e.g. if you try 5 steps with RK4 it might overshoot more than an implicit method would. But at reasonable steps, no problem.
- rk5_7s – Class: explicit RK. Idea: Possibly the Nyström 5th-order 7-stage or something (though Nyström is for second-order eqns). More likely it is Butcher’s 7-stage 5th-order or some other classic 5th-order method (maybe Kutta’s 5th or Carver’s). Without doc, we assume a standard 5th-order one. Behavior: Very accurate, but 7 stages. Unless you need the error reduction, Dormand-Prince or Tsitouras pairs might be more effective (since they give error estimate). Use: High accuracy explicit without adaptivity. If you want slightly better than RK4 and don’t mind extra calls.
- rk6_7s – Class: explicit RK. Idea: Possibly the Chawla 6th-order 7-stage or similar method (there are known RK6(7) designs). The comparison chart named “Linear rk6_7s” as best quality and prompt adherence at the cost of 167 seconds. That indicates this is an extremely good integrator (6th order) that, given enough compute, nails the details. Behavior: The image came out best-of-group in that test – meaning extremely sharp and matching prompt, but it took 167s (7 stages, 16 steps = 112 model calls) so not surprising. Use: If you want the absolute best result and can wait ~5-7x longer than a normal sampler. Good for final renders or when upscaling with minimal denoise. Schedulers: They used Normal in that test, interestingly – implying even linear spacing with a high-order method gave top quality. Karras might push it even further, but either should be excellent. Pitfalls: Just the huge time. Nothing weird expected – high order explicit is fine if you give it the steps to chew on.
- bogacki-shampine_4s / 7s – Class: explicit RK. Idea: Bogacki–Shampine is known for an embedded 3(2) method (3-stage 3rd order with an extra output for 2nd order error). But here “4s” and “7s” suggests possibly the embedded 5(4) method by Bogacki & Shampine, which uses 7 stages (they did publish a 7-stage 5th-order pair as well). The 4s might be the simpler BS3 method repurposed or another method by them. Behavior: The 7s likely refers to a 5th-order method with an embedded 4th for adaptivity (like BS5(4)). If adaptivity isn’t used, it’s effectively a very good 5th-order method. Use: If you want Dormand–Prince-like performance but maybe a different error distribution. Possibly yields similar quality as RK6_7s or DP. Steps: ~10–20.
- dormand-prince_6s / 13s – Class: explicit RK. Idea: The famous Dormand–Prince pairs. “6s” likely is the DP5(4) – often described as a 7-stage method but with FSAL it requires 6 distinct stages[2] (the last evaluation reuses the first’s result). Indeed DP 5th order has 7 tableau rows but effectively 6 function evaluations. The “13s” is likely the DP8(7) pair (13 stages) offering 8th order accuracy. Behavior: Dormand–Prince 5th order (the one behind ode45) is very efficient and produces very accurate results per computation – ideal for smooth problems. Here, one user found DP6s (which they likely ran as dormand-prince_6s) gave the absolute best quality among dozens of samplers at 30–40 steps (particularly a variant was singled out as “best quality”). So DP5 is a top-tier method for image diffusion as well. The 13s (8th order) is even more precise but with massive overhead. Use: For ultimate quality. The DP5(4) method will reach high quality in fewer steps than RK4. The DP8(7) (if indeed that) might be overkill, but you could generate an image in maybe 8 steps with basically no numerical error – any flaws are purely model/semantic. Steps: DP5(4): ~15–20. DP8(7): you could try as low as 8–10 steps and likely be fine due to 8th order, though the model’s own uncertainty might then dominate. Schedulers: DP is designed to work with an adaptive controller usually. Without that, probably Normal or linear (to not confuse it with drastically uneven step sizes). In the test, a linear schedule with DP gave superb results. Karras might be okay too but adaptivity is where DP shines, which we aren’t using here, so any reasonable schedule works. Pitfalls: Long runtime for the 13s. Also, extremely high order can amplify floating-point issues if you push steps too far – but with 8th order you wouldn’t need many steps anyway. Practically, nothing concerning beyond speed.
- tsi_7s – Class: explicit RK. *Idea:* Tsitouras 5(4) method with 7 stages and FSAL. Tsitouras (2011) created a more optimal 5th-order RK than Dormand–Prince, often yielding smaller error. Behavior: It’s an improved ode45 – usually about 20-50% error reduction at same step size, or can take slightly larger steps for same error. In diffusion terms, it should produce equally good or slightly sharper images compared to DP5 for the same number of steps. It also tends to be more stable for certain tricky ODEs. Use: A great choice if you want high-order but maybe shave off a few steps vs Dormand–Prince. Steps: ~15 (Tsit5 can achieve what DP5 might in ~18-20 steps typically, though this is heuristic). Schedulers: Normal or Karras; Tsitouras method is typically used adaptively, but fixed-step is fine. Pitfalls: None; Tsitouras designed it to avoid some pitfalls of Dormand–Prince (like better stability in some cases). So it’s arguably one of the best fixed 5th-order methods to use here.
- euler (again) – Already covered in explicit category above.
*(Glossary note: Many of these linear RK methods (Ralston, Kutta, Bogacki-Shampine, Dormand-Prince, etc.) come from classical ODE development. See the Glossary at the end for brief definitions and significance of each.)*
### Diagonally Implicit Samplers (DIRK methods)
**Integration idea:** Diagonally implicit RK have an implicit formula but only on the diagonal of the Butcher tableau, so each stage can be solved sequentially (not fully coupled as in Gauss-type). This makes them easier to solve (each stage is like a single implicit equation often linear in diffusion case), and they can handle stiffer equations than explicit methods. They usually are A-stable (stable for any step size in linear systems) and some are even L-stable (damp out high-frequency modes strongly). They cost more per step (each stage requires solving an implicit equation – in diffusion ODE context, that’s actually straightforward, maybe solved analytically; in practice likely they iterate or just apply formula since our ODE is simple).
- irk_exp_diag_2s – Class: diagonally implicit (kind of hybrid). Idea: Described as “features an exponential integrator” in the README. Possibly an implicit RK that also uses an exponential factor. It might be a 2-stage DIRK with exponential coefficient – maybe meaning it solves linear part implicitly (which would just be exact anyway) and handles non-linear part explicitly? Without clarity, treat it as an *advanced stable 2-stage method combining implicit and exponential techniques.* Order: Likely 2. Behavior: Very stable and forgiving on step size. You could probably run fewer steps without blow-up. Use: If explicit 2-stage gives weirdness, try this; it will be slower but rock-solid.
- kraaijevanger_spijker_2s – Class: DIRK. Idea: A 2-stage DIRK from Kraaijevanger & Spijker (early 1990s), likely focusing on large stability region or SSP. The Butcher tableau is given in Wikipedia. Order: Possibly 2 (the snippet didn’t state, but likely second-order). Stability: They probably optimized for A-stability with some SSP property. Indeed, the text around it hints at positivity conditions (though those lines apply to P&R method). Behavior: Should be unconditionally stable (A-stable) and maybe strongly damping. Use: For scenarios where explicit methods show oscillation or overshoot (like bright/dark edges overshooting). It will march firmly towards solution without ringing. Steps: Because it’s implicit and stable, you can potentially use larger step sizes – maybe ~10–15 steps for a decent result where explicit needed 20. But note each “step” has 2 implicit solves (though likely cheap here). Schedulers: Could even try Linear or Beta – implicit methods can handle a linear schedule without trouble because they are A-stable, meaning even a big initial step won’t destabilize. Pitfalls: Implicit methods are slower (in actual compute); also sometimes they overly damp fine details (L-stability can erase tiny features along with noise). Use them when stability is more important than preserving every micro-detail.
- qin_zhang_2s – Class: DIRK. Idea: Qin & Zhang’s 2-stage, 2nd-order DIRK. It’s noted as symplectic in Wikipedia (the table snippet calls it symplectic DIRK). Order: 2. Stability: symplectic means it preserves volume in phase space – in diffusion that doesn’t directly apply, but it suggests it’s not overly damping (contrasted with L-stable methods). Behavior: Likely less aggressive damping of high frequencies, so it might preserve texture better than an L-stable method. Use: If you want some stability benefits of implicit, but still keep some liveliness. Steps: ~15–20. Pitfalls: None documented. It’s a safe method. Possibly not L-stable (since symplectic usually implies some oscillations are preserved), so not as good if you need maximum damping.
- pareschi_russo_2s / alt_2s – Class: DIRK. Idea: Pareschi & Russo’s 2-stage method (2000s) focusing on stiff source terms (they work on kinetic equations). Wikipedia gives a family with a parameter x; stability requires x≥1/4 for A-stability, and a particular x for L-stability. The “alt” probably picks the other root of that polynomial for L-stability. So one is likely L-stable, the other maybe only A-stable but perhaps more accurate. Order: 2. Behavior: The alt with x being one of the roots (there were two possible x that yield L-stability in text) means the alt is L-stable (maximally damping). The other might choose x=1/2 (for example) to maximize stability interval but not fully L-stable. Use: If you want absolutely no ghosting or ringing, use the L-stable variant (maybe alt). If you want a bit less damping, use the base. They’re good for stiff situations, e.g. when using huge guidance or very abrupt noise reduction where explicit blows up. Steps: Could do fewer steps thanks to L-stability. Pitfalls: L-stable methods can sometimes overly blunt details, as mentioned. But if you plan to add a little noise (SDE) or do a refinement pass after, that’s fine.
- crouzeix_2s / 3s / 3s_alt – Class: DIRK. Idea: Michel Crouzeix’s 2-stage 3rd-order DIRK[3] and 3-stage 4th-order DIRK (with a parameter α in the 3-stage; alt likely uses the alternative α solution). Order: 2s is actually 3rd order (surprisingly high order for 2 stages, but indeed Crouzeix found a 3rd-order DIRK)[3]. 3s is 4th order. Stability: Probably A-stable (Crouzeix was big on stability of RK). These might not be L-stable though. Behavior: High order implicit with fewer stages: 2-stage 3rd order is economical. It might be a great choice if you want a bit more accuracy than Radau IIA 2-stage (which is order 3 too) but simpler? The 3-stage 4th order can possibly compete with explicit 4th order but with better stability. Use: Very solid all-rounders for those who aren’t shy about implicit. For example, if a prompt tends to create slight color ringing, crouzeix methods will suppress that but still achieve high accuracy. Steps: 2s (3rd order) can do with ~15 steps; 3s (4th order) maybe ~10–15. Pitfalls: Not much – Crouzeix’s methods are well-behaved. The alt likely corresponds to a different α in the 4th order family (one root might give slightly better stability at the cost of something else). Without detail, you can test which yields a nicer image; differences likely minor.
### Fully Implicit Samplers (Gauss, Radau, Lobatto collocation)
**Integration idea:** Fully implicit Runge-Kutta (collocation methods) treat all stages as coupled. They often require solving a system of equations at each step (which is computationally heavy, but in our context with a 1D time ODE, it’s more feasible – essentially it might iterate a fixed-point or do a small Newton iteration per step). These methods have superior accuracy for a given number of stages (Gauss-Legendre attains order 2s) and excellent stability (often A-stable or L-stable). They are the “Rolls-Royce” of integrators – expensive but high-performing.
- gauss-legendre_2s, 3s, 4s, 5s (+ variants) – Class: fully implicit (collocation). Idea: Gauss–Legendre collocation at Gaussian nodes yields symplectic, A-stable integrators of order 2s. 2s is order 4, 3s order 6, 4s order 8, 5s order 10. The variants “4s_alternating_a”, “4s_ascending_a”, “4s_alt” etc., likely refer to different ways to solve or different root ordering of polynomial (not affecting results) or might correspond to different formulations but same mathematics. Possibly some addressing of the fact that multiple equivalent coefficient sets exist due to symmetry. Behavior: These are extremely accurate and stable. Being symplectic means they won’t artificially damp or grow energy – in diffusion, they just accurately trace the probability flow ODE with minimal numerical diffusion or dissipation. Use: When maximum accuracy per stage is needed. Note the doc joke: pairing res_5s predictor with gauss-legendre_5s corrector for “ultimate image quality”. That underscores GL’s prowess (but also its slowness). Even standalone, gauss-legendre_3s or 4s will produce excellent results; you might not see much difference from an explicit 4s except at lower step counts or tricky prompts, but it’s there. Steps: You can push to very low steps: e.g. 3s (6th order) might do fine in 10 steps (like an RK6 would), but with more stability. Or use normal step counts and expect slightly better detail. *Schedulers:* Any – Gauss methods are A-stable for all s, so even aggressive schedules won’t break them. If using very few steps, maybe avoid a schedule that starves the initial noise too quickly (though A-stability means they can handle it). Normal or Karras are fine. Pitfalls: The solve: each step requires solving s nonlinear equations. With our neural network, presumably they do a few functional iterations. This might increase latency per step, especially at high s. Also, while symplectic, they are not L-stable – they don’t aggressively damp. That means if there are very high-frequency components (which in an image might be tiny noise), they won’t kill them as quickly as Radau IIA would. Sometimes that’s good (preserve texture), sometimes not (maybe residual noise remains). In practice, the difference is minor and can be controlled by the scheduler or a tiny denoise at end.
- radau_ia_2s, 3s; radau_iia_2s, 3s, 5s, 7s, 9s, 11s (+ alt) – Class: fully implicit (Radau collocation). Idea: Radau collocation points including one end of interval. Radau IIA includes the right end, yielding L-stable methods of order 2s-1. Radau IA includes the left end, also order 2s-1, but typically not L-stable (only A-stable). Order: 2s-1 (Radau IIA 3s = 5th order, 5s = 9th order, etc.). Stability: Radau IIA are L-stable (great for stiff problems). Radau IA share stability function but not L-stable due to different error propagation. The alt might be an alternate coefficient set (maybe swapping some stage order, since the collocation polynomial might not be unique?). Possibly alt uses a different root ordering or addresses a numerical issue (like ill-conditioning for high s). Behavior: L-stability means these methods annihilate any high-frequency error by the next step. So images come out very clean – no lingering noise or tiny wobbles. They also handle abrupt changes in dynamics well. Their accuracy is slightly lower than Gauss (order 2s-1 vs 2s), but still very high. E.g., radau_iia_3s is 5th order (compared to Gauss 3s 6th order), but radau will damp more. Use: Excellent for tricky cases like extremely high CFG scales or weird conditioning where other samplers freak out – Radau will plow through stably. Also good for final-stage img2img where you want to ensure no residual noise. Steps: Because of L-stability, you can even use fewer steps than an explicit method of similar order – e.g. radau_iia_3s (order 5) might perform well at 10–15 steps where an explicit 5th order might still leave slight noise. For super accuracy, use as many steps as needed to reduce error (they’ll do it monotically). *Schedulers:* Any, but pairing with exponential or tangent schedules might be redundant – Radau already handles things; a simple schedule is fine. However, in practice Karras or normal both work. One user ran radau_iia_7s (order 13) with normal schedule and got “very good” results (very sharp and consistent) albeit slow. Pitfalls: The heavy computational cost (solving 7 or 9 simultaneous eq per step for high s). And the possibility of over-damping: if you rely on a bit of randomness or noise, Radau might remove it too effectively, leading to images that are perhaps too smooth or a tad less detailed than an explicit counterpart. The fix could be to add SDE noise or use a slightly less damped method for final few steps. But as a default, it’s hard to fault Radau IIA for stability-critical tasks.
- lobatto_iiia/b/c/d/star (2s, 3s, 4s) – Class: fully implicit (Lobatto collocation). Idea: Lobatto methods include both interval endpoints in collocation. They typically have order 2s-2 (slightly less than Radau/Gauss). There are several variants (IIIA, IIIB, IIIC, IIIC*, IIID) depending on how collocation conditions are set (they differ in stability/structure). Many Lobatto methods are symmetric (good for reversible systems) and some are embedded (IIIA & IIIB are dual that can be combined for higher order or error estimation). E.g., Lobatto IIIC* might refer to an variant with certain simplifications. Order: For instance, Lobatto IIIA 2s is order 2, 3s order 4, 4s order 6; similarly for IIIB, IIIC. They are usually A-stable but not L-stable (some are only A-stable for limited step sizes). They are often symplectic and used in conservative systems. Behavior: In diffusion context, symplecticness isn’t needed (system isn’t conservative). So Lobatto might not offer special advantages except being implicit and symmetric. Symmetry can sometimes mean better error distribution and perhaps slightly less bias – maybe preserving mean color or something? Not documented though. Use: Not a go-to for diffusion, but included. If you want to experiment, you might try combining a Lobatto IIIA and IIIB as predictor-corrector (since they are dual). But that’s beyond normal usage. Pitfalls: Lower order than Gauss for same stages and no L-stability, so they may be slightly worse than Radau or Gauss in our tasks. Possibly they were included because they come out of the box when implementing collocation general solutions. So use them if curious, but expect radau_iia or gauss-legendre of same stage count to usually outperform them in either stability or accuracy.
The matrix below summarizes recommended pairings between sampler families and schedulers, based on documentation or credible tests:
| Sampler → | Multistep (RES, DPM) | Exponential (RES, ETD) | Linear RK | DIRK (Diag. Implicit) | Fully Implicit |
|-----------------------------|----------------------------------|-------------------------------|-------------------------|---------------------------|---------------------------|
| Scheduler ↓ | res_2m, dpmpp_2m, etc. | res_4s, etdrk4, etc. | rk4, rk6, dp5, etc. | pareschi2, crouzeix3, etc. | radau, gauss, etc. |
| Normal (Linear) | Documented 👍<br>*(balanced for any)* | Ok (safe choice) | Documented 👍 | Good default (A-stable methods handle it) | Good default (A-stable) |
| Karras (EDM) | Great for DPM++ (noted)<br>Works well for RES | 👍 (refines detail at end) | 👍 (used in high-quality tests) | 👍 (these can handle fine refinements) | 👍 (these benefit from small end-steps) |
| Exponential | 👍 speeds convergence | Maybe overkill (duplication of concept) | Can cause jumpy start for high-order (use if <10 steps) | Fine (L-stable can handle big early drop) | Fine (A-stable can handle it) |
| SGM / DDIM Uniform | If matching original training (rare) | Suited if using SDE models | Not typical (but harmless) | Not needed (explicit scheduling fine) | Not needed |
| Linear-Quadratic | 🤷 No data (works generically) | 🤷 No specific note | Possibly helps (split coarse/fine) | Good for semi-stiff (some damping early, gentle later) | Not required (implicit already smooth) |
| KL Optimal | 👍 If minimizing step error is goal (multistep could benefit from optimal spacing) | Could help high-order too, but less needed | 👍 Theoretical best for given steps | 👍 Ensures implicit uses its power optimally | 👍 (Though these have tiny error anyway) |
| Bong_Tangent | 👍 Popular with RES 2m (improves detail) | Possibly redundant (exponential + tangent might double dip) | Could improve detail on low-order RK | Can use if want extra refinement pass effect | Probably not needed (implicit already “two-sided” in some stability sense) |
| Beta / Beta57 | Fine (front-load or back-load noise drop as needed) | Fine, but exponential sched might conflict; Beta(0.5,0.7) used if desired look | Use if aiming for training-like noise profile or special needs | Fine (these methods aren’t sensitive to schedule shapes much) | Fine |
Key: “👍” indicates a documented or empirically supported good pairing; “🤷” means no info or not significant either way.
*(Example use of matrix: If using a Multistep sampler, Exponential scheduler is a documented good choice for speed; if using a Fully Implicit sampler, any scheduler works, but no special pairing is required due to strong stability.)*
## Notable Parameters in RES4LYF
Finally, a few custom parameters in the RES4LYF interface deserve explanation, as they differ from standard KSampler:
- ETA (η): This controls the amount of noise added each step in SDE mode. η = 0 means no noise (ODE mode); higher η means more random perturbation per step. There are multiple NOISE_MODE_SDE options that interpret η differently (listed in increasing strength). For most modes, η ≥ 1 triggers an internal rescaling to avoid blow-up, except “exp” mode which tolerates very large η. Typical safe range: 0 (deterministic) up to ~0.8 for mild creativity; 0.8–1.0 is already quite strong; above 1.0 only in “exp” mode or if you specifically want extreme variance. Keep η low if you want convergence; high η can prevent the image from settling (it “keeps adding noise” each step as one user noted).
- Shift & Base Shift: These relate to rectified flow models like SD3.5, Aura, Flux. “Shift” is akin to max_shift in Flux, controlling how much latent shift occurs per step for motion dynamics. “Base_shift” is specifically for Flux to offset its inherent motion. In static image generation, these are usually set to -1 (disabled) unless using those model types. If using e.g. WAN or HiFlow models that have a temporal component, you might set a shift (like 0.2 or so) to induce consistent movement across frames. For normal SD, leave Shift = -1 (no shift). If you do play with it, “exponential” vs “linear” shift scaling can be chosen – exponential is default for Flux (smooth ramping) and generally gives better results in guided motion.
- **Steps vs Steps_to_run:** Steps is the total planned steps. Steps_to_run allows you to execute only a portion of those steps. For example, Steps = 30 and Steps_to_run = 10 will run 10 steps out of 30, and then stop, presumably allowing a second sampler to continue from 10 to 30. This is useful in chained sampling workflows: you can have one sampler do the first part (coarse) and another do the rest (fine) without resetting the noise. If Steps_to_run is set to -1 (default), it will run all steps. In practice: to have Sampler A do N₁ steps and Sampler B do N₂ steps (with total = N₁+N₂), set both Samplers’ Steps = N₁+N₂, then set Steps_to_run = N₁ for the first, and -1 for the second (which will then run the remaining N₂). This is how users combine different samplers sequentially. If not chaining, leave Steps_to_run = -1 (so it uses the Steps value fully). Safe ranges: -1 or 1 to Steps; must not exceed Steps. This feature is advanced; the UI doesn’t deeply document it beyond usage in forum examples.
- Sampler Mode (Standard/Unsample/Resample): By default use Standard. Unsample mode is for special noise inversion workflows: it disables adding model noise, letting you diffuse upwards (from a low-noise image to a high-noise one = “unsampling”) in order to then resample back down. Resample is the second phase after unsample – it similarly suppresses noise addition so that you only apply denoising that was deferred. In short, these are for when you do two-stage generation: first unsample (create a noise-expanded latent that still contains the image structure), then resample (bring it back down to low noise in a refined way). If you’re not doing those elaborate techniques, keep it on Standard (which ensures standard noise addition in normal SDE and normal denoising).
- Implicit Predictor (Implicit_Sampler_Name & Implicit_Steps): These let you do one sampler inside another as a predictor-corrector pair. For example, explicit = Euler, implicit = Radau, with implicit_steps = 2 means each step, it will first do Euler prediction then do 2 iterations of Radau corrector. This can dramatically improve quality on some models (e.g. SD3.5 Medium, as doc says it reduces artifacts). However, runtime multiplies by (1 + implicit_steps implicit_stages). Typically “gains diminish after 2–3 implicit steps”. If you use this, choose a fast explicit predictor (Euler or RES_2m) so you don’t double heavy costs. For everyday use, this is overkill; but if you hit a scenario with subtle artifacts that only vanish with implicit refinement, consider using 1–2 implicit steps of a Gauss or Radau method (with same stage count as predictor or higher). Always set Implicit_Sampler_Name to “none” (or leave default) if not using this; implicit_steps = 0 or none is effectively off.
## Reproducible Test Recipes
To help you validate these samplers and schedulers yourself, here are a few example setups. Each uses a fixed seed and known model, so you can reproduce identical results. After generating, you can compare outputs to see the effect of different samplers or step counts.
*Setup:** We use two models – Stable Diffusion XL (SDXL) for photo-realistic prompts, and Qwen-Image (Qwen) for artistic illustration prompts. We give a prompt, and test a grid of 4 samplers × 3 schedulers × a few step counts. Due to length, we suggest doing this systematically by changing one factor at a time.
1. Prompt A (Portrait, Photorealistic) – “Ultra-detailed studio portrait of an elderly man with wrinkled skin, dramatic lighting, 85mm lens”; Model: SDXL; CFG scale = 7.5; Seed = 12345.
- Run with RES_3M + Karras at 20, 30, 40 steps. Then with Euler + Exponential at 20, 30 steps. Observe: RES_3M should achieve similar or better detail at 20 steps as Euler at 40 steps. The Euler+Exponential 20-step may look decent globally but lack pore-level detail; RES_3M 20-step should have sharper micro-details (e.g. in the wrinkles) and fewer weird artifacts.
- (Optional) Also try Radau_IIA_3s + Normal at 20 steps. It should be extremely clean (no noise speckles in shadows), but might be slightly less contrasty than RES_3M (due to heavy damping). This validates the stability vs detail trade-off.
2. Prompt B (Product Shot) – “A shiny red sports car on a reflective floor, studio lighting, 8K photography”; Model: SDXL; CFG = 8; Seed = 22222.
- Compare RK4_4s vs SSPRK3_3s vs Gauss-Legendre_4s, all with Normal scheduler, 25 steps.
- The car’s edges and reflections are a good test. RK4 might produce very crisp reflections but possibly some aliasing. SSPRK3 might slightly smooth out the reflection but ensure no ringing. Gauss-Legendre_4s will likely give the best of both: crisp and no ringing, owing to its high order and stability. These differences might be subtle, so zoom in on reflections or specular highlights to spot overshoot or oscillations.
- This confirms classical RK vs SSP vs fully implicit differences in a controlled way.
3. Prompt C (Landscape, Smooth gradients) – “A serene sunset over a lake, smooth water, mountains silhouette, minimalistic”; Model: Qwen-Image; CFG = 7; Seed = 33333.
- Try Euler + Bong_Tangent vs Heun_2s + Normal vs Crouzeix_2s + Normal; 50 steps each (Qwen tends to need more steps).
- Euler + Bong_Tangent: Should converge quickly and the tangent schedule will refine the gradient transitions – you might see a bit of banding reduction due to the backward pass. Heun 2s normal: stable, smooth, likely very similar result but maybe slightly softer hues. Crouzeix 2s: as a 3rd-order implicit, should produce an almost identical image to Heun but with maybe even less banding (since it’s effectively like doing a subtle implicit smoothing).
- This shows how a clever scheduler (bong_tangent) can emulate some benefits of implicit refinement for explicit Euler.
4. Prompt D (Abstract/Creative) – “An abstract swirl of colorful paint, dynamic movement, 4K render”; Model: Qwen-Image; CFG = 11 (high to induce challenge); Seed = 44444.
- Use DPMPP_SDE_2S + Karras at 30 steps, vs DPMPP_2M + Karras at 30 steps, vs RES_2M + Karras at 30 steps.
- With SDE 2S, each run will differ; do 2–3 and pick a representative. You’ll see more wild variations in the swirl patterns (the SDE sampling explores more) – it might even add small paint splatters or deviations. DPMPP_2M (ODE) will be consistent and probably a bit less chaotic in patterns. RES_2M likely gives similar structure to DPMPP_2M but perhaps sharper edges (since RES was refined).
- This highlights ODE vs SDE: SDE adds creativity at the cost of consistency.
5. Prompt E (Inpainting scenario) – Use a partially masked image (like a photo with an object removed) and prompt: “fill the mask with matching background pattern”.
- Model: SDXL or relevant inpainting model; use Implicit Predictor: e.g. set Sampler = Euler explicit, Implicit_Sampler = Lobatto_IIIC_3s, Implicit_steps = 1, Steps = 50.
- Also run normal Euler 50, and maybe Euler 50 with a standard denoise=0.8 vs Euler+Lobatto with denoise=0.8.
- The implicit refinement might better maintain continuity at mask boundaries (reducing any seam or brightness mismatch, since it’s effectively doing a small implicit smoothing on the result each step). It’s hard to quantify without visual, but look closely at the filled area boundaries: the hybrid method should integrate the conditions a bit more consistently (less jitter or brightness difference).
- This demonstrates the use of implicit corrector in a practical task (inpainting requires stability to not hallucinate edges where mask meets content).
For each test, ensure you fix the seed and only change the intended variables, so differences come purely from the sampler or scheduler. You can then magnify specific regions to spot differences (e.g. graininess in dark areas to test stability, or edge sharpness to test accuracy).
## FAQ (Frequently Asked Questions)
**Q: Why does SDE mode often look more creative or varied than ODE mode?**
**A:** Because SDE sampling adds random noise after every step. This “continuous noise injection” means the sampler isn’t following one deterministic path; it’s exploring around it. Thus, even with the same seed, SDE can produce different outputs on different runs (the seed just sets initial noise, thereafter each step injects new randomness). At high step counts, ODE will converge to a fixed image (no new noise, just refining), whereas SDE will never fully converge – it keeps perturbing details. This can yield more interesting or detailed textures (the noise may push the model into new ideas), but it can also prevent the image from settling, sometimes resulting in a grainy look if overdone. It’s useful when you want variety or a touch of chaos – e.g. for creative art or when you deliberately want each outcome unique. Dial η (eta) to adjust how exploratory it is. Low η (0.1–0.3) gives mild variety, high η (~0.8 or 1) gives wild changes and risk of not converging to the prompt subject at all.
**Q: Some exponential integrator samplers (RES_S) feel like they produce sharper edges than others – is that real or placebo?**
**A:** It can be real. Exponential integrators can reduce numerical diffusion. In explicit Euler or low-order RK, each step might blur details a bit (numerical error smears high-frequency info). High-order exponential methods (like res_4s_minchev, etdrk4, etc.) have much lower local error and treat the linear decay exactly, so they preserve sharp transitions more faithfully. For example, a fine edge or thin line in the image might slightly fade with a basic solver at low steps, but remain crisp with a higher-order solver given the same step count. Community tests did find certain high-order samplers delivered noticeably sharper results. However, beyond a point, the model’s own learned blur vs sharpness dominates – a sampler can’t add detail the model wouldn’t produce with enough steps. It’s about how quickly it gets to that detail. So yes, a better integrator reaches a sharp result in fewer steps, which looks sharper for a given step count.
**Q: Why do implicit methods consume more GPU time?**
**A:** Implicit solvers require solving equations for each step. In practice, RES4LYF likely uses iteration or multiple model calls per step for implicit stages. For example, Gauss-Legendre 4s has 4 coupled stages – one way to solve is to iterate the network 4 times per step until consistency (or use a direct formula if linear, but our model’s score function is non-linear in latent so it likely iterates). This means more forward passes. Even if it’s just a small fixed number of iterations, that’s extra cost. Also, certain implicit methods might be implemented by internally calling the model function multiple times per stage for root-finding. So while explicit 4s = 4 evals, implicit 4s could be, say, 8–12 evals total if using Newton’s method or fixed-point iterations. The trade-off is you often can take larger steps (so need fewer steps). If you find implicit samplers too slow, consider using the Implicit Predictor with a small number of implicit refinements on an explicit sampler – that way you target the expensive implicit work where it’s most needed (e.g. one refinement per step to clean up artifacts, instead of fully implicit each step).
**Q: With so many samplers, how do I choose quickly?**
**A:** Identify your priority: Speed → try multistep (RES or DPM) with an aggressive scheduler (Exponential or BongTangent). Quality → try a multi-stage sampler (3s or 4s) with Karras. Robustness (no weird artifacts) → try an implicit or hybrid sampler (Radau, Crouzeix, etc.) – they are very reliable. If unsure, the RES samplers were created as balanced choices (fast and good quality). For example, RES_3M + Karras 20 steps is a strong general choice. As you gain experience, you might have favorites for certain styles (some report Euler a with tangent schedule for sketchy art, DPM++ 2M Karras for photorealism, etc., largely based on anecdote). Our guide’s cheat-sheet and individual notes can steer you: e.g. for smooth skin – maybe an implicit method; for wild textures – maybe SDE plus high order. It’s encouraged to do small A/B tests: generate 4 images, 2 with sampler X and 2 with sampler Y (same seed for each pair), to directly compare. The differences can be subtle but meaningful for discerning eyes.
**Q: Are higher-order samplers always better? Why not just use the highest (like 16s) always?**
**A:** Not always – diminishing returns and practical limits. A 16th-order method can take huge steps with small error in theory, but our diffusion model isn’t a simple equation – if you take steps too large, you might skip over nuances of the model’s response. Also, floating-point round-off error grows with very high order (summing many stages). There’s also the compute cost: 16s means 16 network evaluations per step; you could instead do, say, 8 steps of a 4th order method (=32 evals) versus 2 steps of a 16th order (=32 evals) – perhaps similar cost, but the latter might not capture the model’s non-linear evolution as well with just 2 big steps. In practice, methods up to 4th or 5th order seem to hit a sweet spot for diffusion, and beyond that, model uncertainty overtakes numerical error. RES4LYF’s author notes much is experimental, so 15s/16s are likely there for completeness. Use them if you’re curious or in very special cases (maybe extremely low step count runs), otherwise something like RES_5S or RK6_7s is usually sufficient to get nearly error-free results if you give it moderate steps. Always weigh time vs quality: a 8th-order with half the steps might still be slower than a 4th-order with full steps, depending on stage count.
**Q: I got NaNs using an ETD sampler with a high η noise – what happened?**
**A:** Likely you hit the scenario the docs warned about: for most SDE noise modes, η ≥ 1 triggers internal scaling to avoid NaNs. Possibly using “exp” noise mode bypasses that, allowing very large noise injection which can push the latent into unstable territory (model outputs inf). Or it could be that an exponential integrator without stabilization had an issue (Cox-Matthews ETDRK4 is known to potentially produce large intermediate values if not careful). Solution: reduce η below 1, or if you need η high, switch noise mode if available (e.g. use “exp” mode which expects large η but watch out as it allows more freedom). If it’s an integrator issue, try using the “alt” version of that sampler which might be a more stable formulation. Also, make sure your CFG scale isn’t outrageously high; a combination of high CFG and SDE noise could cause instabilities independent of the integrator.
**Q: What is “BONGMATH” actually?**
**A:** “Bongmath” isn’t a standard term in numerical analysis – it’s more of an internal nickname by the author for the novel noise scaling and scheduling tricks in RES4LYF. Specifically, it refers to the custom SDE implementation that allows using SDE sampling on models not originally trained for it (like stable diffusion), by adjusting how noise is injected and scaled, plus things like the bong_tangent schedule that do forward-backward denoising. It’s a playful term, but practically it means: thanks to some math, we can do fancy stuff (like bidirectional denoising, unsampling, etc.) that standard samplers don’t support. For users, it means you have extra capabilities – but you don’t need to understand the math under the hood. Just know that enabling SDE mode and using Bong_tangent, etc., are part of the “bongmath” toolkit that gives potentially superior results (the README calls it “power of bongmath” with an example of RES sampler outperforming UniPC). So, it’s the secret sauce behind many of these advanced samplers.
---
Below we include two CSV tables as an appendix: one summarizing all the samplers with their documented properties, and one for the schedulers. Use them as a quick reference. Finally, see the Glossary for definitions of the technical terms and method names we’ve cited. Happy experimenting with RES4LYF – may your generations be ever more precise and imaginative!
### Appendix: Samplers Table (CSV)
The columns are: sampler_name, class_family, documented_order, stages_model_calls, notable_behavior, recommended_steps, suggested_scheduler, sources. (Note “documented_order” is based on RES4LYF docs or known theory; if blank or ?, it’s not specified explicitly).
```csv
sampler_name, class_family, documented_order, stages_model_calls, notable_behavior, recommended_steps, suggested_scheduler, sources
res_2m, multistep (explicit), "not stated (est. 2)", "1 per step", "Refined DPM++ 2-step; very accurate for low cost", "20-30", "Karras or BongTangent", ""
res_3m, multistep (explicit), "not stated (est. 3)", "1 per step", "Refined 3-step; achieves high quality in few steps", "20", "Karras", ""
dpmpp_2m, multistep (explicit), 2, "1 per step", "DPM++ 2M from literature; reliable baseline", "20-50", "Karras", ""
dpmpp_3m, multistep (explicit), 3, "1 per step", "DPM++ 3M (third-order multi-step variant)", "15-30", "Karras", ""
abnorsett_2m, multistep (explicit), "not specified", "1 per step", "Multi-step (2) possibly Adams/Norsett method", "30?", "Normal", ""
abnorsett_3m, multistep (explicit), "not specified", "1 per step", "Multi-step (3) Norsett method", "30?", "Normal", ""
abnorsett_4m, multistep (explicit), "not specified", "1 per step", "Multi-step (4) Norsett method", "30-40?", "Normal", ""
deis_2m, multistep (explicit), 2, "1 per step", "DEIS (Diffusion Exp. Integrator) 2-step variant", "20-40", "SGM or Karras", ""
deis_3m, multistep (explicit), 3, "1 per step", "DEIS 3-step variant", "20-30", "SGM or Karras", ""
deis_4m, multistep (explicit), 4, "1 per step", "DEIS 4-step variant", "15-30", "SGM or Karras", ""
res_2s, exponential explicit, "not stated (est. 2)", 2, "2-stage Lawson/ETD; base version", "30+", "Normal", ""
res_2s_stable, exponential explicit, "2", 2, "Stability-optimized 2-stage", "30+", "Normal", ""
res_2s_rkmk2e, exponential explicit, 2, 2, "Runge-Kutta-MuntheKaas 2-stage variant", "30+", "Normal", ""
res_3s, exponential explicit, "not stated (est. 3)", 3, "3-stage ETD (base version)", "20-30", "Karras", ""
res_3s_non-monotonic, exponential explicit, 3, 3, "3-stage variant allowing overshoot (more accurate)", "20-30", "Karras", ""
res_3s_alt, exponential explicit, 3, 3, "Alternate 3-stage coefficients", "20-30", "Karras", ""
res_3s_cox_matthews, exponential explicit, 3, 3, "ETDRK3 by Cox & Matthews (2002)", "20-30", "Normal", ""
res_3s_lie, exponential explicit, 3, 3, "Lie-Trotter type 3-stage integrator", "20-30", "Normal", ""
res_3s_strehmel_weiner, exponential explicit, 3, 3, "3-stage ETD by Strehmel & Weiner (1987)", "20-30", "Normal", ""
res_4s_krogstad, exponential explicit, 4, 4, "ETDRK4 by Krogstad (2005)", "15-25", "Karras", ""
res_4s_krogstad_alt, exponential explicit, 4, 4, "Alternate Krogstad 4th-order", "15-25", "Karras", ""
res_4s_strehmel_weiner, exponential explicit, 4, 4, "4-stage ETD by Strehmel & Weiner", "15-25", "Karras", ""
res_4s_strehmel_weiner_alt, exponential explicit, 4, 4, "Alternate S-W 4th-order", "15-25", "Karras", ""
res_4s_cox_matthews, exponential explicit, 4, 4, "ETDRK4 by Cox & Matthews", "15-25", "Karras", ""
res_4s_cfree4, exponential explicit, 4, 4, "4-stage commutator-free integrator", "15-25", "Normal", ""
res_4s_friedli, exponential explicit, 4, 4, "Friedli (1978) 4th-order ETD", "15-25", "Normal", ""
res_4s_minchev, exponential explicit, 4, 4, "4-stage by Minchev (2004); high accuracy", "15-20", "Karras", ""
res_4s_munthe-kaas, exponential explicit, 4, 4, "4-stage by Munthe-Kaas; similar to above", "15-20", "Karras", ""
res_5s, exponential explicit, 5, 5, "5-stage high-order (notable sampler)", "10-20", "Karras", ""
res_5s_hochbruck-ostermann, exponential explicit, 5, 5, "Hochbruck-Ostermann 5th-order (SIAM 2005)", "10-20", "Karras", ""
res_6s, exponential explicit, "not stated (~6)", 6, "6-stage (exp.); experimental high order", "8-15", "Karras", ""
res_8s, exponential explicit, "not stated (~8)", 8, "8-stage (exp.); very high order", "6-12", "Linear or Simple", ""
res_10s, exponential explicit, "not stated (~10)", 10, "10-stage (exp.); extremely high order", "5-10", "Linear", ""
res_15s, exponential explicit, "not stated (~15)", 15, "15-stage (exp.); extremely high order", "<10", "Linear", ""
res_16s, exponential explicit, "not stated (~16)", 16, "16-stage (exp.); extremely high order", "<10", "Linear", ""
etdrk2_2s, exponential explicit, 2, 2, "Exponential TD RK2 scheme", "30+", "Normal", ""
etdrk3_a_3s, exponential explicit, 3, 3, "ETDRK3 scheme (variant A)", "20-30", "Normal", ""
etdrk3_b_3s, exponential explicit, 3, 3, "ETDRK3 scheme (variant B)", "20-30", "Normal", ""
etdrk4_4s, exponential explicit, 4, 4, "ETDRK4 (original Cox-Matthews 4th order)", "15-25", "Normal", ""
etdrk4_4s_alt, exponential explicit, 4, 4, "ETDRK4 (stabilized/alt version)", "15-25", "Normal", ""
dpmpp_2s, explicit (single-step), 2, 2, "DPM++ 2S (2nd-order single-step)", "20-30", "Karras", ""
dpmpp_sde_2s, explicit (single-step), 2, 2, "DPM++ 2S for SDE (stochastic)", "20-30", "Karras", ""
dpmpp_3s, explicit (single-step), 3, 3, "DPM++ 3S (3rd-order single-step)", "15-25", "Karras", ""
lawson2a_2s, exponential explicit, 2, 2, "Lawson 2-stage method (variant a)", "30+", "Normal", ""
lawson2b_2s, exponential explicit, 2, 2, "Lawson 2-stage (variant b)", "30+", "Normal", ""
lawson4_4s, exponential explicit, 4, 4, "Lawson 4-stage 4th-order", "15-25", "Normal", ""
lawson41-gen_4s, exponential explicit, 4, 4, "Lawson 4(1) general method", "15-25", "Normal", ""
lawson41-gen-mod_4s, exponential explicit, 4, 4, "Modified Lawson 4(1)", "15-25", "Normal", ""
lawson42-gen-mod_1h4s, hybrid (Lawson + explicit), "≈4", "1 half-step + 4-stage", "Hybrid Lawson method", "?", "Normal", ""
lawson43-gen-mod_2h4s, hybrid, "≈4", "2 half-steps + 4-stage", "Hybrid Lawson method", "?", "Normal", ""
lawson44-gen-mod_3h4s, hybrid, "≈4", "3 half-steps + 4-stage", "Hybrid Lawson method", "?", "Normal", ""
lawson45-gen-mod_4h4s, hybrid, "≈4", "4 half-steps + 4-stage", "Hybrid Lawson method", "?", "Normal", ""
pec423_2h2s, hybrid (PEC), "≈3", "2-stage predictor + 2-stage corrector", "Predictor-explicit-corrector scheme", "?", "Normal", ""
pec433_2h3s, hybrid (PEC), "≈3", "2-stage pred + 3-stage corr", "Predictor-explicit-corrector scheme", "?", "Normal", ""
abnorsett2_1h2s, hybrid, "≈2", "AbNorsett + 2-stage", "AbNorsett predictor + RK corrector", "?", "Normal", ""
abnorsett3_2h2s, hybrid, "≈3", "AbNorsett + 2-stage", "AbNorsett predictor + RK corrector", "?", "Normal", ""
abnorsett4_3h2s, hybrid, "≈4", "AbNorsett + 2-stage", "AbNorsett predictor + RK corrector", "?", "Normal", ""
irk_exp_diag_2s, hybrid (implicit-exp), 2, 2, "Implicit RK with exponential treatment", "20-30", "Normal", ""
euler, explicit (RK1), 1, 1, "Euler (deterministic)", "30-100", "Exponential for speed; Karras for quality", ""
ddim, explicit (ODE-like), "~1", "1 (per step)", "DDIM deterministic sampler (ODE)", "50", "DDIM_uniform", ""
gauss-legendre_2s, fully implicit, 4, 2, "Gauss collocation (A-stable, symplectic)", "20", "Any (A-stable)", ""
gauss-legendre_3s, fully implicit, 6, 3, "Gauss collocation (order 6)", "15", "Any", ""
gauss-legendre_4s, fully implicit, 8, 4, "Gauss collocation (order 8)", "10-12", "Any", ""
gauss-legendre_4s_alternating_a, fully implicit, 8, 4, "Gauss 4s alt formulation A", "10-12", "Any", ""
gauss-legendre_4s_ascending_a, fully implicit, 8, 4, "Gauss 4s alt formulation A (order asc)", "10-12", "Any", ""
gauss-legendre_4s_alt, fully implicit, 8, 4, "Gauss 4s alternate (likely same order)", "10-12", "Any", ""
gauss-legendre_5s, fully implicit, 10, 5, "Gauss collocation (order 10)", "8-10", "Any", ""
gauss-legendre_5s_ascending, fully implicit, 10, 5, "Gauss 5s alt ordering", "8-10", "Any", ""
radau_ia_2s, fully implicit, 3, 2, "Radau IA collocation (order 3)", "20", "Any", ""
radau_ia_3s, fully implicit, 5, 3, "Radau IA (order 5)", "15-20", "Any", ""
radau_iia_2s, fully implicit, 3, 2, "Radau IIA (L-stable, order 3)", "20", "Any", ""
radau_iia_3s, fully implicit, 5, 3, "Radau IIA (L-stable, order 5)", "15-20", "Any", ""
radau_iia_3s_alt, fully implicit, 5, 3, "Radau IIA alt (maybe different starting guess)", "15-20", "Any", ""
radau_iia_5s, fully implicit, 9, 5, "Radau IIA (order 9)", "10-15", "Any", ""
radau_iia_7s, fully implicit, 13, 7, "Radau IIA (order 13)", "8-12", "Any", ""
radau_iia_9s, fully implicit, 17, 9, "Radau IIA (order 17)", "6-10", "Any", ""
radau_iia_11s, fully implicit, 21, 11, "Radau IIA (order 21)", "5-8", "Any", ""
lobatto_iiia_2s, fully implicit, 2, 2, "Lobatto IIIA (order 2)", "30", "Any", ""
lobatto_iiia_3s, fully implicit, 4, 3, "Lobatto IIIA (order 4)", "20", "Any", ""
lobatto_iiia_4s, fully implicit, 6, 4, "Lobatto IIIA (order 6)", "15-20", "Any", ""
lobatto_iiib_2s, fully implicit, 2, 2, "Lobatto IIIB (order 2)", "30", "Any", ""
lobatto_iiib_3s, fully implicit, 4, 3, "Lobatto IIIB (order 4)", "20", "Any", ""
lobatto_iiib_4s, fully implicit, 6, 4, "Lobatto IIIB (order 6)", "15-20", "Any", ""
lobatto_iiic_2s, fully implicit, 2, 2, "Lobatto IIIC (order 2)", "30", "Any", ""
lobatto_iiic_3s, fully implicit, 4, 3, "Lobatto IIIC (order 4)", "20", "Any", ""
lobatto_iiic_4s, fully implicit, 6, 4, "Lobatto IIIC (order 6)", "15-20", "Any", ""
lobatto_iiic_star_2s, fully implicit, 2, 2, "Lobatto IIIC* (variant) (order 2)", "30", "Any", ""
lobatto_iiic_star_3s, fully implicit, 4, 3, "Lobatto IIIC* (order 4)", "20", "Any", ""
lobatto_iiid_2s, fully implicit, 2, 2, "Lobatto IIID (order 2)", "30", "Any", ""
lobatto_iiid_3s, fully implicit, 4, 3, "Lobatto IIID (order 4)", "20", "Any", ""
Appendix: Schedulers Table (CSV)
Columns: scheduler_name, type_formula, intuitive_behavior, use_case, sources.
scheduler_name, type_formula, intuitive_behavior, use_case, sources
normal, linear sigma decay, Uniform noise decay each step, Balanced default for general use, ""
sgm_uniform, SDE sigma(t) uniform, Steps evenly spaced in SDE time, Good for score-based models (VP/VE), ""
karras, sigma_max to min with power-law (ρ), Smooth non-linear decay (dense at end), High-quality/detail images, ""
exponential, σ_i = σ_max (σ_min/σ_max)^(i/(N-1)), Rapid early decay, Fast generation / fewer steps, ""
ddim_uniform, t steps uniform, Matches DDIM time spacing, When using DDIM sampler for authenticity, ""
beta, β distribution curve (α,β params), Non-linear (shape-determined) decay, Special effects or mimic training schedule, ""
normal (duplicate entry?), Gaussian error? (maybe refers to EDM normal), Potentially akin to “PNDM”*, (Often paired with AlignYourSteps/skip) – likely similar to linear, ""
linear_quadratic, piecewise: linear then quadratic, Fast initial drop, gentle finish, Complex scenes (prevent overdenoise late), ""
KL_optimal, derived from KL divergence optimality, Uneven but theoretically minimal KL error, To maximize fidelity at fixed steps, ""
bong_tangent, two-stage tangent function, Forward-then-back half-interval noise, Ultra-sharp details, bidirectional correction, ""
beta57, β schedule with α=0.5, β=0.7, Front-loaded slight curve, As alternative to default linear, ""
simple, basic fixed spacing (legacy), Simplified decay (maybe ~linear), Quick tests / baseline, ""
(Note: The “normal” entry appears twice in different contexts (one likely the Standard linear, the other maybe a normal distribution spacing from AlignYourSteps). In ComfyUI BasicScheduler docs, “normal” is linear. The duplicate mention in sources like A1111 suggests it’s same. We treat it as linear.)
Glossary
· ODE vs SDE: An ODE (Ordinary Differential Equation) sampler (like probability flow ODE in diffusion) deterministically integrates the denoising equation with no added randomness. An SDE (Stochastic DE) sampler includes a noise term (like the reverse diffusion SDE), adding randomness each step. ODE mode converges to one solution given a seed; SDE mode yields a distribution of solutions and can explore more. SDE often requires special noise scaling (“Bongmath”) to work well on models not originally continuous-time.
· RK (Runge–Kutta): A family of one-step integrators that evaluate the derivative (here, model’s output) multiple times per step with different weights. “Explicit” RK means later stage outputs don’t depend on future ones (straightforward to compute sequentially). Implicit RK means stages satisfy equations including later stages – requiring solving equations (harder but more stable).
· Diagonally Implicit RK (DIRK): A subset of implicit RK where the coefficient matrix is lower-triangular – each stage only depends on previous and current stage, not future. Solvable stage-by-stage (usually via one nonlinear solve per stage). These are often A-stable and sometimes L-stable. E.g. Kraaijevanger–Spijker 2s, Crouzeix’s methods.
· Gauss–Legendre methods: Implicit RK with collocation at Gaussian quadrature nodes. They achieve the maximum possible order 2s for s stages. They are A-stable and symplectic (no numerical damping or growth). Great accuracy but fully implicit.
· Radau IIA methods: Collocation at Radau nodes including the right end. Order 2s-1, L-stable (damps out all high-frequency errors). Often used for very stiff ODEs due to strong stability. Radau IA uses left end, also order 2s-1 but not L-stable.
· Lobatto IIIA/B/C/D: Collocation including both interval ends. Order 2s-2 typically. They come in pairs (IIIA & IIIB are dual and symplectic when coupled, IIIC is another variant, IIID perhaps dual to C?). They are A-stable, some are symmetric (good for reversible systems).
· Lawson method: Technique by J. Lawson (1967) for stiff ODEs: use an integrating factor $e^{At}$ for the linear part, then do an explicit RK on the transformed system. E.g. $y' = Ay + N(y)$ becomes $z = e^{-At}y$, integrate z explicitly. Many exponential integrators (ETD) are based on this idea.
· ETD (Exponential Time Differencing) RK: A class of integrators (Cox & Matthews 2002, Krogstad 2005, etc.) that handle the linear part of the ODE exactly via matrix exponentials and the nonlinear part via RK expansions. They use functions φ_k (matrix exponential integrals) to achieve high order. Popular ETD schemes: ETDRK2, ETDRK4, etc. Require careful computation to avoid NaNs (Cox-Matthews noted instability and proposed contour integrals to compute φ functions).
· SSPRK (Strong Stability Preserving RK): Explicit RK methods that preserve monotonicity/TV stability under certain time-step constraints. Shu-Osher developed SSPRK3 (3rd order, 3 stages) which is extensively used in CFD because it won’t create new extrema if none exist initially (for small enough step). It’s basically the best compromise between order and TVD stability (no 3rd-order 2-stage exists, and 4th-order explicit SSP requires many stages).
· DPM++ (Denoising Diffusion Probabilistic Models++): A family of samplers from diffusion research (especially by Chensiang (Liu) and team). DPM++ 2S, 2M, etc., are improvement over DDIM and PLMS solvers, using mid-point correctors and higher order. They were integrated in many UIs as they improved speed and quality. “M” stands for multi-step (uses previous points), “S” for single-step (higher order in one step).
· DEIS (Diffusion Exponential Integrator Sampler): From Zhang & Chen 2022. Uses an exponential integrator viewpoint to create fast samplers. Introduced with ρ-th order versions and shown to be effective at low steps. Essentially applies an exponential time differencing approach to diffusion ODE/SDE.
· DDIM (Denoising Diffusion Implicit Models): Sampler by Song et al. that solves a non-stochastic version of diffusion, allowing deterministic generation and accelerated sampling. It’s effectively an ODE (probability flow ODE) solver, equivalent to a particular first-order method (like implicit Euler in noise space). The “ddim_uniform” scheduler ensures time steps are evenly spaced, replicating how the DDIM paper defined it.
· Heun’s method: Also known as explicit trapezoidal or improved Euler. A 2-stage RK: first stage Euler predictor, second stage corrector using the average of slopes. Second order accurate. Minimizes error for 2-stage along with Midpoint and Ralston’s being alternatives.
· Ralston’s methods: Ralston (1962) provided coefficients for RK methods that minimize the error bounds. For 2-stage, his method uses c=2/3 with weights (2/3, 0) and yields error constant minimized. For 3-stage and 4-stage, he proposed specific sets also aimed at minimizing error norm.
· Bogacki–Shampine: A 3-stage RK that’s third-order with an embedded second-order (used in ode23). Also a 7-stage 5th-order pair was later given by the same authors. They are known for reliable adaptive step solvers for moderate accuracy.
· Dormand–Prince: A 7-stage RK with 5th order accuracy and an embedded 4th order (the classic “ode45” method). It’s efficient because it chooses coefficients such that the higher order solution is very accurate and the lower order is just used for error. Also a 13-stage 8th order DP method exists (DOP853).
· Krogstad (ETD4): Krogstad (2005) introduced a 4th-order exponential integrator that became a standard because it was easier to implement than Cox–Matthews ETD4 while maintaining accuracy. It’s used often in solving semi-linear PDEs.
· Cox–Matthews (ETD3/4): The 2002 paper that laid groundwork for modern ETD integrators. ETD4 in that paper (with 4 exponentials computed) became widely used but had stability issues that were later solved by others (like Kassam & Trefethen 2005).
· Minchev & Munthe-Kaas: In 2004, they did analysis of exponential integrators and introduced commutator-free schemes and considered order conditions to high order. They likely provided examples of 4th order schemes and beyond, which are implemented as res_4s_minchev, etc.
· Hochbruck–Ostermann: Mathematicians who published reviews and new exponential integrators in mid-2000s (and beyond). They, for example, showed in 2005 that certain high-order ETD schemes aren’t stable for some stiff problems and developed stabilized versions (like energy-decay preserving ETD3, etc.). The res_5s_hochbruck-ostermann probably references a scheme from one of their papers, maybe a 5th-order method adapted for diffusion equations.
· Crouzeix: Known for work in RK methods, he found some diagonally implicit schemes, including the 2-stage 3rd-order and 3-stage 4th-order we have here[3]. Those are remarkable because usually a 2-stage can’t be 3rd order unless implicit. Crouzeix’s methods are often A-stable but not L-stable.
· Kraaijevanger–Spijker: These authors studied stability of RK. The DIRK here might be one that maximizes the radius of absolute monotonicity (or SSP coefficient). Spijker’s condition is a measure of RK stability for non-linear problems. The method given (with coefficients in Wikipedia) is L-stable if certain coefficient chosen, but not sure if theirs is specifically L-stable or just A-stable. It’s included likely as an example of a stable DIRK.
· Pareschi–Russo: They worked on IMEX (implicit-explicit) methods for hyperbolic and kinetic equations. The DIRK listed under them is likely the second order L-stable DIRK from one of their papers in early 2000s, which has a free parameter x (the condition for L-stability given was specific solutions for x).
· Implicit vs Explicit in diffusion context: Explicit samplers are simpler and usually fine because diffusion ODEs aren’t extremely stiff (the “stiffness” comes from the fast decay of sigma at end, but Karras schedule mitigates that). Implicit ones shine if you have extremely large steps or combine with other processes (like controlling shift in video models – implicit ensures no blow-up when shifting prompts). They also can guarantee stability if someone cranks settings to extremes (high CFG, few steps – an implicit might handle it gracefully where an explicit would break).
· Flux, HiDiff, WAN references: These are specific model names (Flux, HiDream, WAN) that the documentation references for features like regional conditioning and shift. Not directly part of samplers, but SHIFT parameters relate to them. Flux uses an “exponential” shift by default – meaning the influence of shift increases exponentially with time; SD3.5 uses linear. The UI giving both options allows using these samplers across different model architectures smoothly.
Each of these terms and methods could warrant more explanation, but this glossary provides a starting point. For deeper theory, see references like Butcher’s Numerical Methods for ODEs, Hairer & Wanner’s Solving ODEs series (which cover stability, collocation, etc.), and the specific papers: - Karras et al., Elucidating Design Spaces of Diffusion Models (for sigma schedules). - Lu et al., DPM-Solver (for DPM++ family). - Zhang & Chen, Fast Sampling of Diffusion Models with Exponential Integrator (DEIS). - Song et al., DDIM (2020) for DDIM. - Shu & Osher (1988) for SSPRK. - Lawson (1967) for integrating factor methods. - Cox & Matthews (2002), Krogstad (2005) for ETD. - etc., as cited.
By understanding these, you can better appreciate why RES4LYF includes them – essentially to give you every possible tool to balance speed, quality, and stability in diffusion sampling.
References:
ClownsharkBatwing, “Superior Sampling with RES4LYF: The Power of BONGMATH”, GitHub README – RES samplers reach high quality in ~20 steps, far fewer than common samplers
ClownsharkBatwing, RES4LYF ComfyUI Node Documentation (Inputs) – SDE sampling identical to ODE except noise added each step (controlled continuous noise injection)
ClownsharkBatwing, RES4LYF Node Documentation (Noise Settings) – ETA ≥ 1 triggers internal scaling to avoid NaNs (except “exp” mode which allows >1)
ClownsharkBatwing, RES4LYF Node Documentation (Scheduler settings) – Extra scheduler “beta57”: beta schedule with α=0.5, β=0.7
ComfyUI BasicScheduler Docs – List of schedulers: normal (linear), karras (smooth non-linear), exponential (rapid decay), etc. – characteristics and use cases
ComfyUI BasicScheduler Docs – KL optimal: theoretical KL divergence optimized decay (from AlignYourSteps)
ComfyUI BasicScheduler Docs – SGM Uniform: scheduler optimized for score-based generative models; DDIM Uniform: for DDIM sampling
ComfyUI Node listing (ClownsharKSampler) – Extension description: enables SDE sampling with all models; 115 sampler types, 24 noise types, 11 noise scaling modes (bongmath)
Reddit – User guide on chaining samplers: Set both samplers same total steps; use steps_to_run = N on first, -1 on second to split steps
Reddit Q&A – Non-deterministic (SDE) samplers don’t converge at high steps – will keep adding noise each step
Claudio Beck, RES4LYF Sampler Comparison – Fastest: Exponential DDIM & Euler ~24.5s; Best quality: linear RK6_7s (6th order) ~167s; Very good: Radau IIA 7s ~227s; Very good: Exponential res_4s_minchev ~95s
Wikipedia – Gauss–Legendre methods: s-stage Gauss method has order 2s (highest possible), A-stable for all s (proved by Butcher)
Arxiv (Persson 2008) – Radau IIA schemes are L-stable with order 2s-1
Arxiv (CWI 1991) – Methods can be A-stable & order 2s (Gauss) or L-stable & order 2s-1 (Radau IIA)
Wikipedia – Diagonally Implicit RK: Example methods: Kraaijevanger–Spijker 2s (tableau given), Qin–Zhang 2s (2nd order symplectic), Pareschi–Russo 2s (2nd order, A-stable if x>=1/4, L-stable for specific x)
Wikipedia – Crouzeix DIRK: 2-stage 3rd order, 3-stage 4th order (with parameter α)[3]
Butcher’s List (Wikipedia) – Ralston’s methods: 2-stage 2nd order (min error), 3-stage 3rd order (min error, used in Bogacki–Shampine embed), 4-stage 4th order (min error)
Diffrax Docs – Tsitouras’ 5/4 method: 5th order, embedded 4th, 7 stages with FSAL (so effectively 6 function evals), used in ODE solvers
Reddit (StableDiffusion) – Explanation of DPM++ 2M vs 2S: “2M and 2S: variants of DPM++ using second-order; S means single-step, M means multi-step; slower but more accurate”
Karras et al. (EDM 2022) – Sigma schedule (ρ): Spacing sigmas with smooth non-linear decay yields improved sample quality; e.g. Karras schedule distributes steps in log space (here referred as “smooth transition”) – recommended for detail
ClownsharkBatwing, Node Docs (Sampler settings) – Samplers ending in “s” use multiple model calls (substeps) – e.g. 3s = 3 calls per step (3x slower than Euler), but much more accurate, especially with noise (SDE). “res” family are refined dpmpp with higher accuracy implemented here.
ClownsharkBatwing, Node Docs (Sampler settings cont.) – Samplers ending in “m” are multistep (recycle previous steps) – Euler-speed per step, less accurate but converge linearly (good for img2img, unsampling, etc. where linear convergence can be advantage).
ClownsharkBatwing, Node Docs (Implicit sampler usage) – Implicit_Sampler: using an implicit method as corrector improves coherence and reduces artifacts (notably on SD3.5 Medium). Use a fast explicit predictor (Euler, res_2m, etc.) to keep runtime sane; e.g. explicit res_5s + implicit gauss-legendre_5s for ultimate quality (but very slow, “commitment to climate change”).
ClownsharkBatwing, Node Docs (Implicit steps) – Implicit_steps: number of implicit refinement steps per explicit step. Increases runtime linearly (double, triple, etc.) – usually diminishing returns after 2-3 implicit steps.
ClownsharkBatwing, Node Docs (Shift settings) – SHIFT: same as model’s shift (max_shift in Flux) – set -1 to disable if not needed; BASE_SHIFT: only for Flux (set -1 to disable if not using Flux). SHIFT_SCALING: “exponential” (Flux default) vs “linear” (SD3.5 default) – exponential generally yields better results except niche uses.
[1] [2] [3] List of Runge–Kutta methods - Wikipedia
https://en.wikipedia.org/wiki/List_of_Runge%E2%80%93Kutta_methods