acceptodds
Under review as a conference paper at ICLR 2027

SnapCache: Accelerating Flow Matching via Trajectory Pruning and Compensation

10 views

Abstract

Flow matching generates samples by numerically integrating a learned velocity field, requiring repeated velocity-field evaluations along the sampling trajectory. Step skipping reduces this cost by reusing cached velocities, but the resulting errors accumulate through the solver. Model compression addresses a related problem by compensating for removed parameters through retained ones. We apply this principle to sampling with \method, a solver-aware step-skipping method that retains the original integration grid. At the next retained sampling step, a velocity residual reveals information about the error accumulated during the skipped interval without an additional model evaluation. Optimal Brain Trajectory Compensation(OBTC) estimates this error and applies a minimum-change correction to the refreshed velocity or multistep history. A causal scheduler selects the next skipped interval by comparing its predicted residual error with the solver's truncation-error scale. The method supports Euler integration and UniPC with one dimensionless tolerance. We study the same compensation mechanism in image and video sampling and illustrate its use in action sampling. On FLUX.1-dev, Krea-2-Raw, and Wan2.2, \method improves sample-fidelity trade-offs over the compared caching baselines at approximately – fewer network forward passes. A qualitative LIBERO rollout complements these quantitative results by illustrating successful task completion under accelerated action sampling.

Primary area:
generative models
Keywords:
Flow Matching, Model Acceleration, Training-Free Acceleration, Caching

Reviews

Among:
Shape:
1234this paper, Top 17%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.75 over 4 reviews, above 83% of the others.
Reviewer_7EgbOpenReview ↗
Rating
3(+1)
Confidence
4
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes SnapCache, a training-free step-skipping framework for flow-matching inference. It reuses cached velocities over skipped sampling steps, estimates the accumulated error from the residual between cached and freshly computed velocities, and applies a minimum-norm correction called Optimal Brain Trajectory Compensation (OBTC). A causal scheduler selects the longest skip interval whose predicted error satisfies a solver-based error budget. Experiments are conducted on FLUX.1-dev, Krea-2-Raw, Wan2.2, and LingBot-VA.

Critical strengths
  1. The paper formulates step skipping as a solver-level error compensation problem rather than merely reusing stale velocities. The separation between solver-output perturbations and solver-specific propagation sensitivities provides a coherent engineering framework for implementing compensation in Euler and UniPC samplers.
  2. The evaluation spans image generation, video generation, and robot action generation, and includes ablations of compensation and scheduling. The cross-modal scope is useful for assessing whether the proposed controller transfers beyond a single image-generation backbone.
Critical weaknesses
  1. Unsupported linear-error assumption. SnapCache assumes that the hidden velocity error during a skipped interval changes linearly from zero to the residual observed at the next retained step. The paper neither explains why this assumption should hold for learned velocity fields nor validates it empirically across models and skip lengths.
  2. Limited technical novelty. The proposed method mainly combines cached-velocity reuse, residual correction, solver-sensitivity propagation, and adaptive skip scheduling. The paper does not clearly identify a new underlying principle beyond this combination, and the OBTC formulation currently appears closer to an engineering heuristic than a substantially new technical contribution.
  3. Incomplete experimental comparison. The paper does not compare SnapCache with several strong and relevant training-free acceleration methods, including VDE [1], LeMiCa [2], and MeanCache [3]. These comparisons are needed to assess the practical advantage of SnapCache.
Questions for authors
  1. What empirical or theoretical evidence supports the linear residual assumption? For several models and skip lengths, can the authors compare the actual hidden velocity-error trajectory with the proposed linear approximation and report the approximation error?
  2. Can the authors add comparisons with VDE, LeMiCa, and MeanCache on applicable common tasks and models using the same experimental protocol? Please also clarify how the gate tolerances are selected for each model and whether model-specific tuning is required.

[1] VDE: Training-Free Accelerating Rectified Flow Model via Velocity Decomposition and Estimation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), 37918–37928. [2] Gao, Huanlin, Ping Chen, Fuyuan Shi, Chao Tan, Zhaoxiang Liu, Fang Zhao, Kai Wang, and Shiguo Lian. 2025. LeMiCa: Lexicographic Minimax Path Caching for Efficient Diffusion-Based Video Generation. In Advances in Neural Information Processing Systems, volume 38 (Main Conference), 132388–132415. [3] Gao, Huanlin, Ping Chen, Fuyuan Shi, Ruijia Wu, Li YanTao, Qiang Hui, Youyuren, Ting Lu, Chao Tan, Shaoan Zhao, Zhaoxiang Liu, Fang Zhao, Kai Wang, and Shiguo Lian. 2026. MeanCache: From Instantaneous to Average Velocity for Accelerating Flow Matching Inference. In International Conference on Learning Representations (ICLR), volume 2026, 60466–60485.

6 comments
AuthorsOpenReview ↗

Why linear interpolation, and its measured accuracy

Thank you for highlighting the need to justify the linear reconstruction and validate its empirical accuracy. The ramp is the first-order interpolation determined by the two available anchors in Eq. (3), δ(ts)=0\delta(t_s)=0 and δ(tr)=ν\delta(t_r)=\nu. It uses physical time, ρ(t)=(t−ts)/(tr−ts)\rho(t)=(t-t_s)/(t_r-t_s), and Eq. (5) accounts for the reconstruction remainder under a twice-differentiable residual trajectory. The bound quantifies the curvature remainder of this first-order reconstruction.

The added diagnostics measure its empirical accuracy across FLUX and Wan. On 553 FLUX prompts, residual-interpolation relative L2L_2 error is 0.5348/0.6160 and cosine similarity is 0.8379/0.7694 at κ=2\kappa=2 and 88, respectively. At κ=8\kappa=8, this residual metric is 0.5216 for one skipped step (229 prompts) and 0.6550 for nine (360 prompts). The solver-propagated direct-error diagnostic shown in the FLUX figure gives relative L2L_2 errors of 0.4548/0.4942 at κ=2\kappa=2 and 88. On 100 Wan prompts, branchwise residual-interpolation relative L2L_2 error is 0.4872/0.4862 at κ=2.0\kappa=2.0, 0.4839/0.4843 at κ=2.5\kappa=2.5, and 0.5086/0.5130 at κ=7\kappa=7. Cosine similarity ranges from 0.8821 to 0.8899. The Wan diagnostic interpolates in physical time and covers skip lengths 1–9.

The plotted FLUX direct-error and Wan residual-interpolation relative errors increase moderately without a sharp jump across scheduler-selected skip intervals within each κ\kappa setting.

AuthorsOpenReview ↗

Technical contribution and comparison with prior methods

Thank you for asking us to clarify SnapCache's technical contribution and compare it with closely related methods. SnapCache uses the residual revealed at the next scheduled model evaluation to correct error accumulated during the preceding skip interval, without an extra network evaluation. Eq. (4) maps this residual through precomputable solver sensitivities to estimate the direct state error. Eq. (6) selects the minimum-norm correction whose first-order effect on the solver matches that estimate. Under the stated rank assumption, this correction is unique in the row space of AA (Appendix C). Appendix B specifies how the correction updates both the model state and UniPC's active history.

In concrete terms, prior training-free caching methods focus on the skipping decision itself and on predicting the velocity over the skipped interval: TeaCache, MagCache, and LeMiCa determine when to reuse cached outputs, while VDE and MeanCache estimate the skipped velocity from previously available information. ERTACache additionally rectifies cache-induced error, but its rectification is calibrated offline and applied at reuse time. In all of these methods, any correction is determined before or during the skipped interval. SnapCache addresses a complementary problem: it uses the residual revealed at the next scheduled refresh to correct, without offline calibration, the error that has already accumulated over the skipped interval, which allows the correction to be formulated as a minimum-norm compensation problem. We note that other reviewers also highlighted this aspect: Reviewer nCrB described the formulation as a "principled minimum-norm correction rather than heuristic caching," and Reviewer HPEQ identified "retrospective correction of accumulated sampling error" as its strongest idea. We have revised the introduction and Section 3 to state this contribution more explicitly.

We compared SnapCache with VDE, LeMiCa, and MeanCache on the same 553 FLUX prompts. We used the public FLUX implementations of VDE and LeMiCa with matched model, seeds, resolution, guidance, and sampling grid. We ported MeanCache's released JVP computation to FLUX and used its released B=10B=10 schedule (Appendix H). NFE counts full-stack evaluations. LeMiCa performs 10 full-stack evaluations across 50 partial or full forward passes.

At comparable full-evaluation budgets, SnapCache improves all four reference-fidelity metrics against each baseline. Against VDE, LPIPS decreases from 0.0924 to 0.0562 at 21.7161 versus 22 evaluations. Against LeMiCa and MeanCache, LPIPS decreases from 0.2944 and 0.3015, respectively, to 0.2591 at 9.2007 versus 10 evaluations.

Table R6. FLUX comparison with VDE.

MethodNFELPIPS ↓PSNR ↑SSIM ↑Ref-FID ↓
VDE22.00000.0924 ± 0.005326.222 ± 0.3970.8924 ± 0.005614.59
SnapCache (κ=2\kappa=2)21.71610.0562 ± 0.004729.571 ± 0.4950.9336 ± 0.00498.68

Table R7. FLUX comparison with LeMiCa and MeanCache.

MethodNFELPIPS ↓PSNR ↑SSIM ↑Ref-FID ↓
LeMiCa10.00000.2944 ± 0.010319.371 ± 0.2730.7436 ± 0.009332.82
MeanCache (B=10B=10)10.00000.3015 ± 0.010219.418 ± 0.2700.7401 ± 0.009235.35
SnapCache (κ=16\kappa=16)9.20070.2591 ± 0.010220.510 ± 0.3380.7636 ± 0.009229.78
SnapCache (κ=8\kappa=8)11.28750.1995 ± 0.008622.713 ± 0.3720.8087 ± 0.008224.53

LPIPS, PSNR, and SSIM are reported as mean ± 95% CI half-width over 553 prompts. Ref-FID is computed over the full set. Bold values in Table R7 highlight the comparison near 10 NFE.

Table R4 presents a separate experiment on a single prompt. For each method, we report the mean latency per NFE across three timed runs following 50 warmup runs. All four baselines were within 1% of SnapCache.

Table R4. FLUX latency per full model evaluation on A100.

MethodLatency per NFE (ms) ↓Relative to SnapCache
MagCache559.01+0.08%
SnapCache558.56Reference
VDE564.05+0.98%
LeMiCa563.95+0.96%
MeanCache558.31−0.04%
AuthorsOpenReview ↗

Tolerance selection and model-specific tuning

Thank you for asking how to choose the tolerance and whether SnapCache requires model-specific tuning. SnapCache requires no model-specific calibration or retraining. The user selects κ\kappa to trade off fidelity against the number of model evaluations. Appendix E explains how we selected FLUX operating points near the target compression ratios, and Appendix G lists the settings used in our experiments.

As discussed in our response to Reviewer nCrB, one example of how SnapCache could be deployed in practice is to expose κ\kappa as a sampler parameter in ComfyUI. Users could inspect intermediate results with ComfyUI's latent previews or assess final images with a reference-free metric such as ImageReward. They could then adjust κ\kappa between runs based on this feedback and their NFE budget.

Reviewer_HPEQOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

SnapCache skips network evaluations while retaining the sampling grid, estimates accumulated error using the next refreshed velocity, and applies a solver-dependent correction. A causal scheduler determines future skip intervals from previously available outputs.

Critical strengths

The strongest idea is retrospective correction of accumulated sampling error.

A scheduled refresh provides information about the skipped interval without requiring an additional network evaluation.

The evaluation spans images, video, and robot actions, including a few-step distilled model.

Critical weaknesses

the main weaknesses are a mismatch between the estimator and pseudocode, incomplete treatment of the UniPC correction, and missing measured latency

The estimator assumes a raw cached velocity with zero residual at the interval’s start, but Algorithm 1 stores the corrected velocity, making that residual generally nonzero. The authors should clarify which velocity is reused and either revise the interpolation anchors or correct the pseudocode.

The analysis bounds only the direct solver-error reconstruction and excludes state-feedback effects, while the scheduler relies on estimated derivatives rather than verified bounds.

The paper should isolate the benefit of its calibration-free retrospective correction and causal scheduling through matched-budget comparisons with these methods and simpler correction baselines.

Questions for authors

How is the zero residual anchor maintained after caching a corrected velocity?

What is the exact joint state-and-history update for UniPC?

How accurately does the estimator predict actual sampling-state error?

What advantage remains over close forecasting/calibration methods at matched latency?

4 comments
AuthorsOpenReview ↗

UniPC Correction, Error Estimation, and Empirical Validation

Thank you for identifying the inconsistency in Algorithm 1 and for suggesting experiments that separate the effects of compensation and scheduling.

1. Zero-residual anchor and cache definition

Line 10 of Algorithm 1 now assigns u~←ur\tilde{u} \leftarrow u_r. The cache stores the raw output uru_r, and the solver receives ur+cru_r + c_r separately. The residual at the anchor in Eq. (3) is zero because the cached velocity equals the raw output at its evaluation state.

2. Joint UniPC state and history correction

Appendix B specifies the joint update and its execution order. The cache stores the raw outputs of both CFG branches. At refresh, the solver uses the current output with the physical-time ramp correction. Stale x0x_0 history entries are repaired as Hj←Hj−σjj−sr−sνgH_j \leftarrow H_j - \sigma_j \frac{j-s}{r-s}\nu_g for j>sj>s, where νg\nu_g is the CFG-combined residual. After both branch evaluations, we repair the shared history once before the scheduler step. UniC then precedes history insertion and UniP.

3. Direct-error accuracy and the causal gate

The estimator targets the direct solver contribution in Eq. (2). Eq. (5) bounds its reconstruction error under the stated smoothness assumption. Across 553 FLUX prompts, the solver-propagated estimate has relative L2 errors of 0.4548 at κ = 2 and 0.4942 at κ = 8.

The gate estimates derivatives from available outputs, holds them fixed over each candidate interval, and compares the predicted reconstruction-error scale with the solver's truncation-error scale (Appendix A).

4. Separating compensation from adaptive scheduling

On Wan, OBTC reduces mean LPIPS by ≈10% at κ = 2.0 and ≈9% at κ = 2.5 relative to output-plus-history correction (Table R5).

On 553 FLUX prompts, we held compensation and the three-step warmup fixed. Compared with fixed intervals of 2 and 5, adaptive scheduling reduces LPIPS from 0.1338 to 0.0562 at κ = 2 and from 0.2952 to 0.1995 at κ = 8, while reducing mean NFE from 26 to 21.72 and from 12 to 11.29, respectively.

Under identical schedules and NFE on Wan, OBTC achieves the best correction performance in LPIPS and PSNR at all three tested κ values.

Table R5. Wan correction ablation at identical schedules and NFE within each κ group. Metrics are means ± 95% CI half-widths over 100 prompts. Mean NFE includes both CFG branches.

κNFECorrectionLPIPS ↓PSNR ↑SSIM ↑
2.042.76None0.0426 ± 0.004931.051 ± 0.9780.9443 ± 0.0068
2.042.76Output only0.0333 ± 0.003831.506 ± 1.0300.9452 ± 0.0071
2.042.76Output + history0.0305 ± 0.003731.777 ± 1.0540.9486 ± 0.0069
2.042.76OBTC0.0275 ± 0.003332.219 ± 1.0440.9552 ± 0.0055
2.536.72None0.0640 ± 0.006528.745 ± 0.9440.9173 ± 0.0103
2.536.72Output only0.0561 ± 0.005428.635 ± 0.9460.9082 ± 0.0113
2.536.72Output + history0.0517 ± 0.005028.822 ± 0.9500.9137 ± 0.0104
2.536.72OBTC0.0469 ± 0.004729.295 ± 0.9890.9223 ± 0.0098
7.023.68None0.1636 ± 0.013123.240 ± 0.6990.8143 ± 0.0194
7.023.68Output only0.1453 ± 0.012123.516 ± 0.7400.8195 ± 0.0185
7.023.68Output + history0.1411 ± 0.011823.426 ± 0.7330.8224 ± 0.0183
7.023.68OBTC0.1392 ± 0.011223.551 ± 0.7530.8166 ± 0.0184

5. Measured latency and baseline comparisons

On FLUX/A100, SnapCache takes 11.953 s versus 28.718 s for full 50-step generation (2.40× speedup). At matched per-prompt NFE, sampler time is 11.704 s versus 11.677 s for step skipping with a precomputed schedule (+0.23%). Timings cover 12 prompts, three measurements per prompt after 50 warmup runs (Table R1 in our response to Reviewer 15ux).

SnapCache achieves LPIPS 0.0562 at 21.7161 evaluations versus VDE's 0.0924 at 22. At 9.2007 evaluations, it achieves 0.2591 versus 0.2944 for LeMiCa and 0.3015 for MeanCache, both at 10 full evaluations. In the single-prompt timing, all methods are within 1% of SnapCache's latency per NFE (Table R4, Appendix H).

Table R4. FLUX latency per full model evaluation on A100. Single prompt; latency per NFE averaged over three timed runs per method after 50 warmup runs.

MethodLatency per NFE (ms)Relative to SnapCache
MagCache559.01+0.08%
SnapCache558.56Reference
VDE564.05+0.98%
LeMiCa563.95+0.96%
MeanCache558.31−0.04%

Thank you for your careful review and constructive feedback.

We sincerely appreciate your detailed and technically insightful review.

Your comments encouraged us to revisit several important aspects of our formulation and implementation. In particular, we corrected the cache definition in Algorithm 1, clarified the joint state and history correction for UniPC, and more explicitly distinguished the direct solver-error contribution estimated by our method from the broader effects of state feedback.

We also conducted additional experiments to quantify reconstruction accuracy and independently examine the contributions of compensation and adaptive scheduling under controlled settings.

We believe that a clear and consistent connection between theoretical formulation, algorithmic design, and empirical validation is essential for rigorous research. Your feedback helped us strengthen these connections and support our method with more comprehensive experimental evidence.

We are genuinely grateful for the technical care you brought to this review. Your feedback has made a meaningful difference to the rigor and quality of our work.

I thank the authors for their thorough rebuttal and the clarifications provided. My main concerns have been adequately addressed, and I am increasing my score to 3 accordingly.

Thank you again for following up. We’re glad the rebuttal addressed your concerns, and we appreciate you taking the time to revisit your assessment.

Reviewer_15uxOpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

SnapCache accelerates flow-matching sampling by reusing cached velocities and correcting the accumulated error when the model is next evaluated. It combines solver-specific compensation with an adaptive rule for choosing how many evaluations to skip. The method requires neither retraining nor offline calibration and is evaluated on image, video, and robotic action generation.

Critical strengths
  1. Using information from an already scheduled model evaluation to correct earlier caching errors is a practical idea. Combining this correction with adaptive skipping gives the method a clear numerical motivation.
  2. Results across several models and tasks support a useful trade-off between model calls and output fidelity. The few-step and robotic evaluations broaden the evidence, and the compensation ablations show benefits beyond skipping alone.
Critical weaknesses
  1. The algorithm and error estimator are not fully consistent as written. The estimator assumes zero residual at the start of a skipped interval, but Algorithm 1 reuses a corrected velocity, which generally violates that assumption. The combined state and history correction for UniPC also needs a complete update rule. These gaps make it difficult to assess whether the analysis matches the implementation.
  2. The efficiency results primarily measure reductions in model calls rather than runtime. Without representative latency measurements and a comparison with simply taking fewer solver steps, the practical acceleration benefit remains uncertain.
Questions for authors
  1. Does the implementation cache raw or corrected velocities, and how is the interval's initial residual handled? Please also specify the complete UniPC refresh update.
  2. What wall-clock gains remain after compensation and scheduling overhead, compared with caching baselines and a solver using fewer steps at a similar evaluation budget?
4 comments
AuthorsOpenReview ↗

Cache and UniPC Updates, Runtime, and Reduced-Step Baselines

Thank you for identifying the inconsistency in Algorithm 1 and for asking us to clarify the UniPC update and measure practical speedup.

1. Raw versus corrected cache

Line 10 of Algorithm 1 should assign u~←ur\tilde{u} \leftarrow u_r. The implementation already stores the raw model output uru_r in the reuse cache and applies compensation separately. For Euler, the current solver update uses ur+cru_r + c_r. The residual at the start of the skip interval is zero because the cached velocity equals the raw model output at its evaluation state. We have corrected Algorithm 1 accordingly.

2. UniPC state and history correction

Appendix B now specifies the joint state and history update and its execution order. The reuse cache stores the raw outputs of both branches. At refresh, the physical-time ramp correction is applied to the current output used in the solver update. Each stale x0x_0 history entry used by UniPC is repaired as Hj←Hj−σjj−sr−sνgH_j \leftarrow H_j - \sigma_j \frac{j-s}{r-s}\nu_g for j>sj>s, where νg\nu_g is the CFG-combined residual. After both branches are evaluated, the shared history is repaired once before the scheduler step. The scheduler then applies UniC, inserts the current history entry, and applies UniP. These updates correct both the model state and the solver history, as described in Section 4.7.

3. Measured runtime and reduced-step controls

On an A100 GPU, SnapCache reduces end-to-end FLUX generation time from 28.718 s to 11.953 s, a 2.40× speedup over full 50-step generation. At matched per-prompt NFE, the step-skipping baseline uses a skip schedule prepared before timing and runs without online scheduling or compensation. Both methods use the same solver. SnapCache adds 27 ms (+0.23%) to sampler time. Timings are averaged over the same 12 prompts, with three measurements per prompt after 50 warmup runs.

Table R1. FLUX latency on an A100 GPU.

MethodNFEGeneration (s)Sampler (s)Sampler overhead
Full generation (no skip)5028.71828.467—
Step skipping (precomputed schedule)2111.92511.677Reference
SnapCache2111.95311.704+0.23%

On the same 553 prompts, native 22-step and 11-step FLUX sampling yield LPIPS values of 0.3445 and 0.4890 against the 50-step reference. At comparable evaluation budgets, SnapCache yields 0.0562 and 0.1995 at mean full-evaluation counts of 21.7161 and 11.2875, respectively.

Table R4 reports a separate single-prompt measurement, with latency per NFE averaged over three timed runs per method after 50 warmup runs. All measured per-NFE latencies are within 1% of SnapCache's 558.56 ms.

Table R4. FLUX latency per full model evaluation.

MethodLatency per NFE (ms)Relative to SnapCache
MagCache559.01+0.08%
SnapCache558.56Reference
VDE564.05+0.98%
LeMiCa563.95+0.96%
MeanCache558.31−0.04%

We sincerely thank you for your careful and constructive review.

We particularly appreciate your observation regarding the inconsistency between Algorithm 1 and our error estimator. This was an important issue in the presentation of our method, and your comment prompted us to revisit the implementation and correct the pseudocode to accurately reflect the use of raw cached velocities.

Your questions also led us to specify the complete UniPC state and history correction procedure and to strengthen our evaluation with measured runtime, overhead analysis, and comparisons against native reduced-step sampling.

We believe that accurately connecting the mathematical formulation, algorithm description, and actual implementation is essential for reproducible research. Your review helped us improve precisely this aspect of our paper.

Thank you again for examining these details so carefully. We sincerely appreciate the opportunity to improve our work through your feedback.

Thanks for the detailed response which address my concerns, therefore I will maintain my positive score.

We appreciate you taking the time to read our response. Your question about the cached velocity helped us catch a mismatch in the pseudocode and explain the UniPC update more precisely.

Reviewer_nCrBOpenReview ↗
Rating
3
Confidence
4
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

This paper proposes SnapCache, a solver-agnostic step-skipping method for flow matching that views cached velocity reuse as trajectory pruning and compensates for the accumulated error. After a retained step reveals the velocity residual, SnapCache estimates the accumulated skip error without extra model evaluation and applies a minimum-norm correction through Optimal Brain Trajectory Compensation. A causal scheduler adaptively selects skip lengths by comparing predicted residual error against the solver's truncation-error scale. Experiments across images, video, and robot actions show the method improves fidelity over caching baselines at nearby budgets while remaining calibration-free.

Critical strengths
  1. Treating step skipping as a compensation problem borrowed from model compression is a genuinely novel framing. The analogy to Optimal Brain Surgeon is well-motivated and leads to a principled minimum-norm correction rather than heuristic caching.

  2. The framework is unified across Euler and UniPC solvers with the same error-estimation and scheduling principle, and demonstrates cross-modal applicability on images, videos, and robot actions. This breadth is uncommon for caching methods.

  3. The method is calibration-free and requires no training, making it directly deployable. The causal scheduler uses only past velocities, and the single tolerance parameter adjusts the quality-compute trade-off without additional pre-calibration.

  4. The ablation in Table 4 clearly isolates the effect of compensation, showing LPIPS reductions of 27.6% and 15.0% at matched budgets. The LIBERO-Long study provides task-level evaluation with McNemar tests, which is a stronger validation than fidelity metrics alone.

Critical weaknesses
  1. The paper explicitly states that reported compression "should not be read as measured latency.", while No wall-clock speedup is reported. The practical speedup is unclear, especially since the OBTC correction and causal scheduling introduce overhead that may offset the NFE savings.

  2. On FLUX at 11 kept steps, LPIPS jumps to 0.1995 from 0.0562 at 21 steps. The quality degradation at aggressive compression is significant and not adequately discussed. The method's useful operating range appears narrower than the reported compression ratios suggest.

  3. Image and video results report only mean scores without confidence intervals or significance tests. The LPIPS difference between SnapCache and MagCache on FLUX is within noise, yet the paper claims improvement. Statistical rigor is inconsistent — the LIBERO study uses McNemar tests but the image/video comparisons do not.

  4. The retrospective error estimator uses a linear ramp between two anchors, which misses curvature. The bound in Eq. 5 acknowledges this, but the paper does not report how much error the curvature term contributes in practice, especially for longer skip intervals where the linear assumption breaks down.

Questions for authors
  1. Could you report measured wall-clock speedup in addition to NFE compression? How much overhead do the OBTC correction and causal scheduling introduce?

  2. On FLUX, LPIPS jumps from 0.05 to 0.19 when going from 21 to 11 kept steps. Is there a quality cliff, and how should practitioners choose the operating point?

  3. The linear ramp reconstruction assumes first-order variation. For longer skip intervals, how much does the curvature term contribute to the remaining error?

  4. How does SnapCache interact with different guidance scales? All experiments use guidance 3.5–, but does the compensation mechanism behave differently under very high or very low guidance?

6 comments
AuthorsOpenReview ↗

Measured generation latency and overhead

Thank you for highlighting the importance of practical deployment. On an A100 GPU, full 50-step FLUX generation took 28.718 s, while SnapCache took 11.953 s, yielding a 2.40× end-to-end speedup.

To estimate the runtime overhead of SnapCache's online scheduling and compensation, we compared it with a step-skipping baseline at matched per-prompt NFE. The baseline used a skip schedule prepared before timing and ran without online scheduling or compensation. Both methods used the same solver. SnapCache increased sampler time from 11.677 s to 11.704 s, a difference of 27 ms (+0.23%) in this FLUX/A100 setting.

Table R1. FLUX latency on an A100 GPU. Timings are averaged over the same 12 prompts, with three measurements per prompt after 50 warmup runs.

MethodNFETotal (s)Sampler (s)Sampler overhead
Full generation (no skip)5028.71828.467—
Step skipping (precomputed schedule)2111.92511.677Reference
SnapCache2111.95311.704+0.23%
AuthorsOpenReview ↗

Final-image quality under aggressive compression

Thank you for pointing out the fidelity loss at higher compression. On FLUX, increasing NFE compression from 2.30× (κ = 2) to 4.43× (κ = 8) increases LPIPS from 0.0562 to 0.1995. Across the operating points in Table R2, LPIPS increases approximately linearly with the compression ratio, with no abrupt jump observed in the sweep. The last column, ΔLPIPS / ΔCompression, measures the increase in LPIPS per unit increase in the compression ratio between adjacent settings. The largest measured slope is 0.0754 between κ = 4 and κ = 8 (3.43× to 4.43× compression).

At comparable NFE budgets (Table 1), SnapCache achieves the lowest LPIPS among the evaluated methods: 0.1995 with 11.29 retained steps, compared with 0.3952 for TeaCache (12.97 steps), 0.4515 for ERTACache (12 steps), and 0.5686 for MagCache (11 steps).

In practice, a ComfyUI integration could expose κ as a sampler parameter. Users could inspect intermediate results with ComfyUI's latent previews or score the generated images with a reference-free metric such as ImageReward. They could then adjust κ between runs based on this feedback and their NFE budget.

Table R2. FLUX fidelity–compression trade-off across κ (553 prompts).

κNFE compression (×)LPIPS ↓ΔLPIPS / ΔCompression
11.410.0115—
22.300.05620.0500
2.42.630.07450.0564
43.430.12410.0618
84.430.19950.0754
165.430.25910.0593
AuthorsOpenReview ↗

Linear-reconstruction accuracy across skip lengths

Thank you for pointing out that linear interpolation can miss curvature between anchor evaluations. To assess the practical impact of this approximation, we report reconstruction error by skip length, with mean ± 95% confidence intervals across prompts.

On 553 FLUX prompts, the relative L2 error of the solver-propagated direct-error estimate is 0.4548 at κ = 2 and 0.4942 at κ = 8. The residual-interpolation diagnostic gives relative L2 errors of 0.5348 and 0.6160, with cosine similarities of 0.8379 and 0.7694, respectively. The two diagnostics measure the accuracy of the interpolated residual and of the accumulated direct error that OBTC targets.

On 100 Wan prompts, the branchwise residual-interpolation errors range from 0.4839 to 0.5130 across κ = 2.0, 2.5, and 7, with cosine similarities of 0.8821–0.8899.

Within each tested κ setting, relative errors remain broadly stable across scheduler-selected intervals with up to nine skipped steps. The plots quantify the overall reconstruction error, including any contribution from curvature. They show no sharp increase in relative error with skip length over the observed intervals.

Comments on the paper

1 comment

Thank you to all the reviewers for your feedback. We revised the manuscript and added experiments addressing the main questions raised during review.

  • Runtime and reduced-step sampling (nCrB, 15ux, HPEQ). On FLUX/A100, SnapCache reduced end-to-end generation time from 28.718 s to 11.953 s, a 2.40× speedup over full 50-step sampling. At matched per-prompt NFE, online scheduling and compensation added 0.23% to sampler time. SnapCache also achieved lower LPIPS than native 22- and 11-step sampling at comparable evaluation budgets.
  • Algorithm and UniPC update (15ux, HPEQ). We corrected Algorithm 1 to reflect that the implementation caches raw model outputs. Appendix B now specifies how UniPC updates the state and solver history, including the order of operations.
  • Reconstruction accuracy and fidelity (nCrB, HPEQ, 7Egb). We measured reconstruction error across skip lengths on FLUX and Wan and clarified that the estimator targets the direct solver-error contribution. We also measured the fidelity cost of more aggressive skipping, evaluated three FLUX guidance scales, and added 95% confidence intervals to the image and video fidelity tables.
  • Additional baselines and compensation ablations (HPEQ, 7Egb). On the same 553 FLUX prompts, SnapCache achieved lower LPIPS than VDE, LeMiCa, and MeanCache at comparable full-model evaluation budgets. On Wan, OBTC reduced LPIPS by about 9–10% relative to output-plus-history correction at two settings with identical schedules and NFE. We also clarified how SnapCache uses the residual from the next scheduled model evaluation to compensate for error accumulated during the preceding skip interval.

Your feedback helped us make the algorithm easier to reproduce and characterize its fidelity and runtime trade-offs more precisely. Thank you for taking the time to review our work.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.