FlashDLM: Accelerating Diffusion Language Model Inference via Efficient KV Caching and Guided Diffusion
Authors: Zhanqiu Hu
Jian Meng
Yash Akhauri
Mohamed S. Abdelfattah
Jae-sun Seo
Zhiru Zhang
Udit Gupta
Venue: ICLR 2026 Poster (2026)
Keywords: Diffusion Model
Diffusion Language Model
Inference Speed
Language Models
Efficient Inference
Primary area: generative models

Abstract: Diffusion language models offer parallel token generation and inherent bidirectionality, promising more efficient and powerful sequence modeling compared to autoregressive approaches. However, state-of-the-art diffusion models (e.g., Dream 7B, LLaDA 8B) suffer from slow inference. While they match the quality of similarly sized Autoregressive (AR) Models (e.g., Qwen2.5 7B, Llama3 8B), their iterative denoising requires multiple full-sequence forward passes, resulting in high computational costs and latency, particularly for long input prompts and long-context scenarios. Furthermore, parallel token generation introduces token incoherence problems, and current sampling heuristics suffer from significant quality drops with decreasing denoising steps. We address these limitations with two training-free techniques. First, we propose *FreeCache*, a Key-Value (KV) approximation caching technique that reuses stable KV projections across denoising steps, effectively reducing the computational cost of DLM inference. 
Second, we introduce *Guided Diffusion*, a training-free method that uses a lightweight pretrained autoregressive model to supervise token unmasking, dramatically reducing the total number of denoising iterations without sacrificing quality.
We conduct extensive evaluations on open-source reasoning benchmarks, and our combined methods deliver an average of 12.14$\times$ end-to-end speedup across various tasks with negligible accuracy degradation. For the first time, diffusion language models achieve a comparable and even faster latency as the widely adopted autoregressive models. Our work successfully paved the way for scaling up the diffusion language model to a broader scope of applications across different domains. Our code and implementation are available at 
https://github.com/ZhanqiuHu/flash-dlm-experimental.

FLASHDLM: ACCELERATING DIFFUSION LANGUAGE MODEL INFERENCE VIA EFFICIENT KV CACHING AND
GUIDED DIFFUSION
Zhanqiu Hut Jian Mengl.2*
Yash Akhauri
Mohamed S. Abdelfattah Jae-sun Seo
Zhiru Zhang
Udit Gupta
Cornell University Huawei
"Equal contribution
ABSTRACT
Diffusion language models offer parallel token generation and inherent bidirec- tionality, promising more efficient and powerful sequence modeling compared autoregressive approaches. However, state-of-the-art diffusion models (e.g., Dream 7B, LLaDA 8B) suffer from slow inference. While they match the quality of similarly sized Autoregressive (AR) Models (e.g.. Qwen2.5 7B, Llama3 8B), their iterative denoising requires multiple full-sequence forward passes, result- ing high computational costs and latency, particularly for long input prompts and long-context scenarios. Furthermore, parallel token generation introduces token incoherence problems, and current sampling heuristics suffer from signif- icant quality drops with decreasing denoising steps. We address these limita- tions with two training-fre techniques. First, we propose F FreeCache, a Key- Value (KV) approximation caching technique that reuses stable KV projections across denoising steps, effectively reducing the computational cost of DLM in- ference. Second, we introduce Gui ded Diffusi on, training-free method that uses a lightweight pretrained autoregressive model to supervise token un- masking, dramatically reducing the total number of denoising iterations without sacrificing quality. We conduct extensive evaluations on open-source reasoning benchmarks, and our combined methods deliver an average of 12.14x end-to-end speedup across various tasks with negligible accuracy degradation. For the first time, diffusion language models achieve a comparable and even faster latency the widely adopted autoregressive models. Our work successfully paved the way for scaling up the diffusion language model to a broader scope applica- tions across different domains. Our code and implementation available at hattp:://gtthnn com/ http://hannniuuuffaaa
wwm-mmpemm-iieeemmmmmmee experimental
INTRODUCTION
Large language model (LLM) Liu al. (2024a); Bai al. (2023); Touvron et al. (2023) have shown great success across multiple domains in human life with strong intelligence, In particular, most of the current state-of-the-art (SoTA) LLM models are autoregressive (AR) models with transformer-based architecture Vaswani et al. (2017). However, autoregressive models sequentially generate new tokens inference time for each decoding step, preserving the logic of semantics (e.g.. logic) with the cost of insufficient parallelism and the limitation of mono-direction generation. Diffusion Language Models (DLMs) Ye et al. [2025); Nie et al. (2025); Arriola et al. (2025) have emerged as an appealing alternative. By iteratively denoising masked sequence in parallel, DLM enables parallel token generation and bidirectional context, which allows all tokens to be generated simultancously at each
step, while keeping the coherence between past and future tokens.
However, DLMs exhibit fundamental challenges that remain under-explored. The comparable quality between the SoTA DLM and AR model comes with the cost of extensive computation latency and insufficient long- context ability. These drawbacks largely limit the scalability and practicality of diffusion models, which motivates this work investigate the following problem:

---

How effectively accelerate SoTA DLM while maintaining model performance?
Essentially, the efficiency bottleneck of DLM caused by the incompatibility with the caching strategy, which has been widely used in auto regressive models (ARM). Recently proposed Block Diffusion Arriola et al. 2025) have shown promising results on diffusion model with Key-Value caching strategy, whereas the overhead of additional fine-tuning and training hinder the fast deploy- ment of DLM. More importantly, the scalability of caching remains questionable against large-sized DLMs (e.g., Dream-7B- Ce-amm---Instruc//
Instruct Ye et al. (2025). LLaDA-8B BEADD--B-Innsii Ies-Innstrttttt et al. (2025)
To address the efficiency challenge the SoTA DLM models, this work proposes two novel methods: I FreeCa che, training-free caching strategy that enables diffusion acceleration; ② Gut ded Diffusion iffusion, ion,oon& a training-free technique that guides token unmasking in long-context diffusion gener- ation. Unlike the conventional compression algorithm (e.g.. quantization, pruning) that requires dedicated calibration run, the proposed method directly accelerate the model off the shelf. Specifi- cally, we reveal the fact that the impact of future tokens on earlier positions rapidly diminishes over denoising steps. Therefore, direct caching of the earlier unmasked clean tokens can be considered as a KV state approximation with the result of negligible impact on output quality.
In addition to FreeCache, we introduce guided unmasking assisted by lightweight autoregressive model. The proposed Guided Diffusion introduces the mechanism of "big diffusion model generation followed by small model unmasking guidance." Our guidance-onj, approach selects plausible tokens to unmask, minimizing this overhead and preserving the full reasoning power of the DLM. By doing so, the proposed method elegantly combines the advantages of both DLM and autoregressive models. The diffusion process can be easily parallelized, while the autoregressive model is exempt from repetitive and expensive speculative correction. Overall, the contributions of this work are:
Simplicity. The proposed method achieves an average of 12.14x and 13.29x speedup the Dream-7B-Instrrn and B.a.DA----Inntruee models with negligible accuracy drop, respectively. For the first time, the DLM based architecture achieves comparable (even better) generation speed compared the same-sized AR-based LLM models.
Versatility. The proposed method exhibits strong performance across multiple knowledge domains, including both simple and complex reasoning tasks.
Scalability. With the proposed training- free auto-regressive guidance, our work enables the long-context diffusion (> 1024 tokens) without hurting the model performance.
Together, these techniques make it feasible to deploy DLMs in long-context and high- high-throughput applications without compromising quality. Our method retains the desirable properties of parallel generation and bidirectional conditioning of DLMs while overcoming the challenge of key ineffi- ciencies. We demonstrate that ceffusion-based language models can achieve competitive inference performance with autoregressive LLM baselines, paving the way for their practical adoption in real-world scenarios.
2 RELATED WORK
2.1 DIFFUSION LANGUAGE MODELS
The emergence of the diffusion language model (DLM) opens up alternative path for language generation. Recent works like Dream Ye et al. (2025). LLaDA Nie et al. (2025), MDLM et al. (2024). and BD3-LM Arriola ing, these methods are compute-intensive because iterative denoising requires repeated full-sequence forward passes (see Section 3.1.I). leading to substantially higher latency compared to conventional bR-based language models despite the high scalability. With some preliminary trials, recent work imposes cached diffusion models Arriola et al. (2025) for accelerated diffusion and reinforcement learning-based reasoning enhancement Zhao et al. (2025), However, the fundamental latency issue still persists, which largely limits the practicality and scalability of DLM. More importantly, diffusion and autoregressive- baasedd language models are not orthogonal. The potential compatibility between DLM and Autoregressive Model is worth further exploration. Earlier foundations in discrete diffusion include D3PM Austin al. (2023). which introduced structured transition matrices for discrete state
(2255 adapt diffusion processes to text generation. While promis-
2

---

spaces, SEDD Lou al. (024)) which models ratios for discrete diffusion, and MD4 Shi et al. (2025) which simplifies and generalizes masked diffusion for discrete data.
Several recent methods have also been proposed to accelerate DLM inference. dKV-Cache Ma ct al. 2025) reuses intermediate KV states with heuristic scheduling decisions such as delay offsets, window sizes, and periodie refresh steps. Fast-dLLMM Wu et al. (2025) introduces confidence-drivee parallel decoding rules that require task-specific hyperparameter tuning. In contrast, our approach avoids heuristic scheduling and threshold tuning entirely: FreeCache freezes KV projections of finalized blocks without recomputation, and Guided Diffusion uses model agreement as the sole unmasking signal.
2.2 KV CACHING FOR AUTOREGRESSIVE LLM
The overhead of KV Cache has been one of the most critical memory and computation overheads throughout the long-context generation with autoregressive LLM decoding. Compressing the KV cache has been one of the major focuses of efficient LLM research. The emergence of FlashAtten tion Dao et al. )202)); Dao (2023); Shah et al. (2024) and PageAttention Kwon et al. (2023) aims to alleviate the challenge from the system perspective, leading a promising performance with high scalability across different L.M architectures. From the perspective of compression algorithms, KV cache eviction Yang et al. (024); ; Cai et (2024b), quantization Liu et al.) (2024c); Hooper et al.) (2024). structured pruning Lu et al. (2024); :: Xu et al. (025)) are proposed to save memory traffic. Due to the irregularity of the diffusion process, the diffusion language model (DLM) requires the full-sized Key and Values for attention computation, where the bottleneck of memory bound largely degrades the latency, limiting the practicality of DLM on larger scale. A recent study on block diffusion Arriola et al. (2025) proposes the sequential block with intra-block diffusion, whereas the cost of training overhead and under-verified scalability makes the diffusion model questionable for large-scale deployment.
2.3 SPECULATIVE DECODING
In addition to the conventional compression algorithms (e-g., pruning and quantization), speculative decoding Leviathan et al. (2023) provides alternative perspective accelerating autoregressive LLM decoding without hurting the performance (e.g., accuracy). The lightweight assistant model generates a multi-token "draft", followed by the speculation and correction of the target model. The reliability and acceleration of the speculative decoding system is determined by the matching ratio between the draft model output and target model speculation. In particular, the poor matching ratio between the draft and target model leads to frequent execution of the target model, which eventually deteriorates the system level latency. Recent studies on autoregressive models focus [Elhoushi (Elauushh al. (2024); Liu et al. (2024b), multi-head decoding Cai er al. (2024a), optimized token sampling Chen et al. (2024) and search strategy. Regardless the design of speculative decoding, the speculation and correction of the target model is actively required to ensure the lossless computation. In the meantime, the diffusion modell-ased big-small model collaboration largely under investigation. Recent work Christopher al. (202)) explores speculative decoding with small-scale diffusion models as the drafter, relying on a more competent AR model for output quality and generation, whereas cross-model methods for accelerating large, pre-trained diffusion language models remain under-explored.
on self-drafting
3 METHODOLOGY
3.1 PRELIMINARY OF DIFFUSION LANGUAGE MODEL
Diffusion language models (DLMs) generate sequences by iteratively unmasking an initially masked token sequence over T denoising steps. Mathematically. let xy E N be the fully masked input (all positions set to [MASK]] ), where the still masked position M, is represented as:
M, { xe[i]] = [MASK]]
(I)
At each iteration t = T, ....., ...,, the model fo produces logits
2 fo(x)) for E M,,
(2)
3

---

from which subset U/ S M, of positions is selected (e.g. by confidence scoring at random) and filled via:
X [ = ग (Softmax(z(i))), i E Us
(3)
where π denotes the token selection policy (e-g., greedy arg max, temperature sampling, top-k).
yielding the next mask set M,-1 = M2 \ U.. By repeating this denoising and unmasking process until Mg 0, the model produces the final fully unmasked sequence Xo.
Module Operation
Auto- RegteReeressive LM (decode)
Diffusion LM (length L)
Wo. Wx. Wy projections Query x Key (QK*)
Odd))
(Ld))
O(Pd/h)
O(12d/h)
MHA
Attention Score Value
(Id/h)
((Ld//h)
Output projection (Wau)
(d9)
((Ld)
Wi projection
(dddg)
O (Lddg) O ((dddg)
FFN
W2 projection
((ddg)
Table 1: Compute complexity of Transformer modules: AR decodes prefix of length per token vs. DLM processes full length L each denoising step.
3.1.1 BOTTLENECK DIFFUSION LANGUAGE MODEL INFERENCE
While diffusion models allow parallelized generation of tokens, this comes the expense of extra computation overhead per forward pass. Given the input žT with sequence length L, each forward pass of the diffusion model fe requires full-sized computation (both current and past tokens) through- out the multi-head attention (MHA) block and feed-forward network (FFN) of the transformer model. Unlike the autoregressive model where the past tokens are cached for the new token generation, diffusion model produces output without the consideration of causality. As shown in Table I DLM models introduce an additional computational complexity of (L) at each module based model architecture. As result, the latency overhead introduced by the DLM architecture is massive compared to the Auto- Regresssee Model, as shown in the comparison in Section 4 Based on the theoretical analysis above, the first challenge of the diffusion model is:
transformer-
Challenge D: How to alleviate the latency and computation overhead caused by the liability of full sized cache computation of DIM?
3.1.2 TOKEN INCOHERENCE IN PARALLEL GENERATION
As introduced in Section 3.1 DLM irregularly unmasks output token positions throughout diffusion process. As result, simultancously unmasking token positions without semantical correlation leads to insufficient semantical consistency, which can further degrades the model performance. Fundamentally, parallel diffusion decoding relies on a factorized distribution over masked positions, which limits its ability to model joint dependencies during parallel unmasking. While the desire of preserving the parallel diffusion persists. Figure Ia shows accuracy degradation with decreasing denoising steps for three diffusion sampling methods: MaskGIT Chang et al. (2022). entropy-based and Top-K- K Margin Kim et al. (2025). The challenge arises as follows:
Challenge 2 How enhance the semantic correlation of the diffusion process without introducing additional training and fine- tuein effort?
Motivated by the aforementioned challenges, we propose novel approach which directly accelerates the diffusion model in a simple, effective, and systematic manner. Our proposed Guided Diffusion mitigates this factorization limitation by requiring agreement between the DLM and AR model before committing multiple positions, effectively reducing incoherence from independent token predictions without altering the underlying diffusion process.
4

---

Evaluation on GSM8K 8-shot (Gen Len 256)
Baseline vs Optimized Cached (Log)
100%
Steps
32
64
128
256
80%
80%
70%
ExeLatency Improvements!
Accuracy (%6
Accuracy (96)
60%
Negligible Acc. Drop!
60%
50%
40%
40%
30%
20%
20%
Baseline
10%
Optimized Cached
0%
maskgit_plus entropy Look_margin Sampling Method
0%
Latency (s)
(a) Quality degradation from aggressive unmasking, Heuristic methods suffer from significant accuracy loss with decreasing denoising steps.
(b) Latency-accuracy tradeoff. Pareto front com- paring the standard autoregressive baseline with KV-cache optimized method. highlighting substantial latency reductions at equivalent accuracy levels.
Figure (a) Quality degradation under aggressive unmasking. (b) Pareto front of accuracy vs. latency (log-scale) for baseline and optimized cached methods.
3.2 PROPOSED METHOD
3.2.
FREECACHE: REDUCING WINDOW CACHING FOR DLM INFERENCE
key insight for optimizing the generation process in Diffusion Language Models is that the Key and Value (KV) projections for the clean portions of a sequence exhibit high temporal stability. Although these projections are not strictly unchanging, they quickly converge and undergo only negligible changes once token is finalized.
Figure shows a heatmap that validates the rationale behind our FreeCache method: the temporal stability of KV projections for clean tokens. The y-axis represents the denoising step and the x-axis represents the token position, while color intensity shows the cosine similarity of a token's 's value projection its previous step. Bright yellow indicates high similarity (minimal change), while dark blue signifies a large difference. We observed that the prompt region remains stable across denoising steps, and the generation region illustrates how tokens transition from low-similarity, unstable state (dark blue) to
stable state (bright yellow) as they become unmasked.
Value Projections
Key Projections
Denoising Step
1.000
1.000
200
0.929
Similan Similarit
200
0.979
Similarity
0.859
0.957
100
0.788
100
0.936
0.718
0.915
Prompt
0.647
Prompt
0.894
200
600
200
400
Token Position
Token Position
Figure 2: Rationale behind the proposed FreeCache: The variation of K and V projections clean tokens is small throughout the subsequent diffusion steps (measured via cosine similarity).
To exploit this, propose FreeCache, reducing window caching strategy where the set of actively computed tokens dynamically shrinks as blocks of the sequence are finalized. The algorithm proceeds follows: Initialization and Partitioning: The post-prompt generation sequence is
5

---

Table 2: Latency and accuracy of the proposed FreeCache with different Diffusion Language Models. The proposed method achieves x and 6.32 speedup on Pream-7B-Insteeen and LLaDA-8B- Instruct models.
Models
Method
GSM8K (8-shot) Accuracy (%) Raw Latency (s)
Speedup
Baseline
79.68
48.05
1.0
Dream 7a-u--B--uan B-Inntruel et. 2025
FreeCache (This work)
77.40
10.87
4.42x
LLaDA-8B-Instruc Nie et al.
2025
Baseline
79.30
56.89
1.0
FreeCache (This work)
77.18
9.02
6.32x
partitioned into fixed-size blocks (Bi,.., Br), and initial forward pass computes and saves the full KV projections for the entire sequence (prompt all blocks). Windowed Re-computation: To generate block B;, the active computation window is defined as B, and all subsequent blocks (B,-1...., Bv). KV projections are recomputed only for tokens within this window until B; is fully unmasked, using all prior frozen blocks and the prompt as context. Progressive Caching: Upon completion of block B;, its KV projections are frozen for subsequent steps. The active window then shrinks to exclude this block for subsequent generation steps.
This cascaded approach means that the computational cost per step progressively decreases throughout the inference process, as the active window shrinks with each completed block. This effectively reduces the overall computational overhead, especially for long sequences. While the current design uses a fixed block size for simplicity. FreeCache is compatible with dynamic block-size policies. Potential extensions include adapting the block size based on local KV stability, diffusion uncertainty, or the AR-agreement rate from Guided Diffusion. Longer-term directions include cache-aware or schedule-aware training that the model learns KV dynamics that better support caching.
We quantify the performance degradation caused by the FreeCache in Figure Tb with the 8-shot GSM8K dataset. The reducing window caching strategy introduces up 5 speedup compared the vanilla Dream-7B, while preserving the minimal accuracy drop. As shown Table 2 the proposed FreeCache achieves up to 4.42x speedup for (ream-7B-Instrrnee and 6.32x for LLaDA-8B-Inste while maintaining accuracy close to the baseline. We solidify the performance of the proposed method in Section with further analysis with benchmarks across different domains.
3.2.2 GUIDING DIFFUSION WITH LIGHTWEIGHT AUTOREGRESSINE MODEL
To address this token incoherence challenge (Challenge ② from Section 3.1.2 and fully exploit the parallelism of diffusion process, we propose Gui ded Diffusion.
Specifically, we leverage the diffusion model as the "drafter" model by first unmasking all the tokens with one step. The masked tokens predicted by the diffusion model are only unmasked when they are consistent with the predictions from the autoregressive LM model, as shown in Figure For the scenario when the matching ratio between the diffusion drafter and auto-regressive model zero, the guided diffusion will only accept the one free tokens from the AR model output.
This cross- moosel agreement serves as a lightweight coherence prior, enabling the model safely unmask multiple tokens in parallel, without requiring any additional training or fine-tuning.
Gui ded di f fusi on performs iterative unmasking by coordinating predictions from a diffusion language model (DLM) and frozen autoregressive model (ARM). At each denoising step. instead of relying on heuristic confidence thresholds, uses agreement between the two models to decide how many tokens to safely unmask.
Formally, let æ' E N2 be the current sequence containing masked and unmasked tokens. The diffusion model Se predicts logits over vocabulary tokens at all masked positions, from which tokens are selected via policy n:
DIM
=(Softtax((f(()).
These proposed tokens are fed to the ARM Jo. which produces a set of logits:
logits Softmax (LDL)))

---

Input Sequence X step
Overview of the proposed method: AR-guided Diffusion Process
Diffusive Drafting:
One-shot generation of all the unmasked tokens
Diffusion LM
ate
an
banana
<egs>
Feed for Guidance
Matched
Mismatoh
AR-Guider
ate
an
apple
Matched? Unmask!
Mismatched? Stay Silent!
Continue to the next step
Gulded Sequence: Only unmask the matched tokens for the next step of diffusion
Figure 3: AR-guided Diffusion Model. The diffusion model performs one-step diffusion process, followed by one-time forward pass of the AR guider. The matched tokens are unmasked for the next step of diffusion.
Let M = ....... im C (1....,I,, 1.} denote the current masked positions in æ. We compute the longest agreed prefix length i via matching policy M:
h (M logits<R).
If k > O, we unmask positions i1..... ds using the DLM proposals. If no agreement is found, we conservatively unmask only the first token i,. This process repeated until all tokens are unmasked.
This decoding strategy allows the model to adaptively control the amount of parallel unmasking based on model confidence and alignment, enabling efficient generation without compromising output quality. We present the details of the proposed method in Algorithm [ In this work, we support both exact match and relaxed variant that accepts near-ties via confidence threshold t (see Section C.4 for details). Other matching policies are also compatible with the framework.
We would like to highlight that the proposed Gu i ded Di ffusiiiio on properly combines the advan- tages of both diffusion model and auto-regressive model. For each guiding step. both one-time diffusion process from the drafter and the one-time forward pass of the auto-regressive model are fast, while the guidance from the auto-regressive model facilitates the coherence of the diffused output tokens with improved semantical logic.
Guided Diffusion Speculative Decoding. In Speculative Diffusion Decoding (SDD) Christopher et al. (2024), the AR model serves as the target and the diffusion model acts as drafter whose proposals may be corrected by the AR model. Unlike speculative decoding, Gui ded Di f fusi i does not require token-wiss correction from the auto-regressive model. In other words, the proposed method produces output sequence without introducing the repetitive correction process, which guarantees the latency benefits obtained from the fast diffusion process. Speculative decoding uses small AR model for autoregressive drafting, followed by the big model correction. On the contrary, the proposed guided diffusion flips the paradigm by maximizing the drafting efficiency of the big diffusion model. Because the AR guider only provides an agreement signal rather than generating or correcting tokens, small, lightweight AR model suffices for this role, minimizing the additional latency overhead. In addition, the reasoning power of the diffusion model is fully preserved regardless of the choice of the AR guider, supported empirically in Table 4.
4 EXPERIMENTS
We evaluated the proposed method against a wide range of benchmarks across different types of tasks. Due the limited option of DL. models with multi-billion parameters, choose Dream-
7

---

Algorithm 1: Guided Diffusion
Input: masked sequence 2, DLM fo. AR 9p. token selection policy х, matching policy M
Output: fully unmasked x
while 3i: x[1] mask
1/ loop until all unmasked do
lLM < (fftmax(fa(x))
1/ DLM predicts cts masked tokens
toKDLM f- т (logitSpLM)
// DIM predictions // AR processes DIM output
logits R softmax (tokLLM)
Let M = [i....., , 4m be masked indices
/1 remaining mask positions
k M (tokOLM. AR)
// find prefix matches // models agree then // accept matching run
if k > 0
Unmask iicég with NokDLM(i1sid
else
Unmask i with toKDLM[11]
// fallback: accept first
token selection policy (e.g., greedy, temperature, top-k).
M: matching policy that returns the length of the longest agreed prefix; e.g., exact match where tokpL equals the top-1 token of AR
Outstanding acceleration achieved by the proposed methods with negligible accuracy drop on Dream-7B- Instruct Ye et (2025). The latency value represents the end-to-end problem solving time per problem.
Table 3:
Vanilla DLM
Breann-Instruute with Guided Diffusion (This Work)
Baselline Insam-t
PreeCache Only
FreeCache QWen- 1.5B-lnstucct
FreeCache "Wes-7B-Instruue
46.92
18
46.64
48
Lotency
20.73
Specclup (s)
1x
3
12.48
7.48 x
(%)
79.68
GSMSK (8-chof)
Latency (s)
48.05
10.87
2.70
2.74
Speedup
1x
4.42%
17.80
17.53x
Asc. (%)
85.56
84.83
85.15
85.85
PIQA
Latency (5)
11.62
4.21
0.43
1.05
Speedup
1x
3.47x
34.1%
13.92x
Acc. (%6)
80.87
80.61
80.89
80.72
ARC-C
Latency (5)
10.64
4.25
3.12
4.58
Specdup
1x
2,50
3.41
2.32
Acc. (%)
87.53
86.24
87.50
87.44
ARC-E
Latency
10.59
5.54
3.25
5,03
Specdup
Ace. (%)
39.29
43.30
49.55
49.33
GPOA
Latency
21.50
12.02
15.26
Specdup
1x
the selected So'A model to validate the proposed method. To fully solidify the effectiveness of our work, both question-answer (QA) and reasoning tasks are solved via multi-sentence and multi-step text-based diffusion, instead of directly outputting the final answer. The detailed experimental setup and data pre-processing are summarized in the supplemantary.
instruct7BB Ye et al. (225))
Metrics and Baselines. The performance of the proposed method and other baselines are evaluated based on accuracy and wall clock latency for solving each problem. We first compare the performance of the proposed method against the vanilla Dream model Ye et al. (2025). On top of that, evaluate the proposed method with the comparison of the mainstream auto-regressee
models.
Experimental Setup.The models deployed The latency is measured directly via torch. cuda. Event across each benchmark dataset.
single NVIDIA RTX 6000 Ada GPU (48GB).
Long-context Diffusion. For all the tasks, we intentionally encourage the model to generate the complete reasoning process, followed by the indication of the final answer. We would like to highlight the long context response is critical for problem solving and question-answering due to the widely
8

---

adopted reasoning- based response in the SoTA LLM models. For all the selected reasoning, math problems, and cneestion-answenee we set the max.new.t okkns to 1024. The final answers are extracted after the dedicated prompt trigger.
4.1 COMPARISON WITH THE BASELINE DIFFUSION LANGUAGE MODEL
Compared to the vanilla Dream- - model, the proposed method achieves consistent and outstanding speedup across all the tasks from different domains. For the complex reasoning tasks (e.g.. MMLU-PRO, GPQA), the proposed FeeCache first induces 3.11 x speedup with minimal quality degradation. Rewarded by the guided diffusion method, the overall system can achieve an average of 12.48 x speedup with negligible accuracy degradation. For the tasks with long-context input prompt (e.g.. GSM8K with 8-shot), the proposed method accelerates the diffusion process with 34.1x end-to-end average speedup on all the math problems, as presented in Table 3
With guided unmasking, the diffusion model exhibits stronger reasoning power with recovered accuracy. More importantly, the existence of the lightweight autoregressive model recovers the accuracy degradation caused by the approximated cache, even with the long-context generation (e.g.. 1024 tokens). As introduced in Section [ the guided diffusion process exclude the "correction" step. As result, increasing the size of the guider model (c.g., from 1.5B to 7B) only leads to marginal accuracy improvements, with the cost of minimal latency overhead.
Empowered by Guided biffusion, diffusion model is compatible with different variants of the AR model guider in different domains of knowledge. By employing a dedicated auto-regressive LLM for math (e.g.. Qwen-2.5- 2ath- 1--Mah--155B), 1.5B), the performance of the Dream- Iosttm-nntttttt- 7B model can be further facilitated with better reasoning ability on the GSMSK dataset. In addition to the experimental we present the evaluation results with other benchmarks in the supplementary.
results in Table 3
4.2 COMPARISON WITH THE VANILLA AUTOREGRESSIVE LLM MODELS
The strong speedup achieved by the proposed method allows us compare the diffusion model against the conventional autoregressive LLM models.
Table shows the comparison between Guided Diffusion and vanilla Auto-regressive the GSM8K dataset with the standard 8-shot chain-of-thuuge prompt. Crucially, the quality of generation is governed by the DLM's reasoning capacity. This ensures that accuracy maintained regardless of guider competence, with latency remaining on par with autoregressive models. Admittedly, Dream-7B: Be-am-BB-Instuue and LLaDA-8B currently exhibit weaker reasoning ability compared some state-of-fe tf-the-art autoregressive models of similar size (c.g.. Qwen2.5-7B ---n..-----s Nevertheless, Guided Diffusion provides significant acceleration, and as future work continues to enhance the reasoning ability of diffusion models, its benefits are expected to become even more pronounced.
Table 4: Comprehensive performance comparison on the GSMSK dataset, showing both standard autoregressive (AR) and AR-guided results for various models.
Models/ / Guiders
Stand alone AR LLM
Guided Diffusion (wl Dream -ID- Insssructt
Guided Difftsion (w/ LLaDA --D-A- Enstruct)
Accuracy
Latency
Accuracy (%)
Latency
Accuracy
Latency [s)
1wee2:5.1.5B-Inttie
Qwen2.5 Math 1.58- Instruct
78.24
1.59
82.9
3.19
81.96 79.68
5.31 4.42
Qwen2.5 5-BB--BBBB Instract
91.13
3,23
82.3
3.43
4.3 MODEL GPU MEMORY USAGE
Table 9 and Table I0 show the GPU memory usage (in Gigabytes) of the proposed method with LLaDA-SB-Inss and Dream-7B- In-nnturct as diffusion models, respectively. The GPU memory is recorded directly via torch. cuda. mwx.mmmory..aa. www.m/emooyaaallocmm allocatedd (). As shown in the tables. the proposed guided unmasking scheme introduces minimal memory overhead compared to the combined memory consumption of the single auto-regressive and baseline diffusion models.

---

Table 5: LLaDA-8B-Instruc Guided Diffu-
Table Dream- Dream-Instruut-7B Guided Diffusion Memory Usage (GB).
sion Memory Usage (GB).
AR Guider
DLM (GB)
Guide (GB)
Total (GB)
AR Guider
DLM (GB)
Guide (GB)
Total
(GB)
Qwen2.5-1 1112255-1.BBIntttree
4.1
24.8
Qwen2. 1-1.0-1-1-BBBB Instrrccttt Qwen2.5-7B-Innse
4.1
18.7
20.7
14.6
Qwen2.5-7B-Insse
17.3
38.0
17.3
31.9
5 CONCLUSION AND DISCUSSION
This paper presents novel method designed for diffusion language models. The proposed FreeCache enables training-free caching with an off-the-shelf diffusion model. On top of that, Guided Diffusion facilitates the quality of diffusion by guiding the direct diffusion process with outstanding speedup. Different from prior works that relies on training or additional finetuning effort, the proposed method enables the end-to-end speedup by using the off- fff-the-shelf diffusion model only. Compared to the baseline diffusion language models, the proposed method achieves an average of 14x14x speedup More importantly, for the first time, our method enables diffusion model to achieve the comparable performance compared the autoregressive language models while maintaining the similar accuracy.
different reasoning tasks with negligible accuracy degradation.
Despite these advantages, certain trade-offs remain: FreeCache trades accuracy and memory for speed, as its KV approximation introduces small but unavoidable errors and higher memory use. Guided D f ffssion adds system complexity, requiring an extra AR guider, and the guider's alignment does impact the effectiveness of the method.
Additionally, our evaluation is based on limited set of available large-scale DLMs. While we demonstrate generality across both Dream-7B (adapted from an AR model) and LLaDA-8B (trained from scratch), the landscape of billion-parann parameter DLMs remains small. The effectiveness of our methods on future DLM architectures is an area for future work.
REFERENCES
Marianne Arriola, Subham Sekhar Sahoo, Aaron Gokaslan, Zhihan Yang, Zhixuan Qi, Jiaqi Han, Justin T Chiu, and Volodymyr Kuleshov. Block diffusion: Interpolating between autoregres- sive and diffusion language models. In The Thirteenth International Conference on Learning Representations (ICLR), 2025.
Jacob Austin, Daniel D. Johnson, Jonathan Ho, Daniel Tarlow, and Rianne den Berg. Structured denoising diffusion models in discrete state-spaces, 2023. URL
2107. 03006
Jinze Bai, Shuai Bai, Yunfei Chu, Zeyu Cui, Kai Dang, Xiaodong Deng, Yang Fan, Wenbin Ge, Yu Han, Fei Huang, et al. Qwen technical report. arXiv preprint arXiv:2309.166i0 2023.
Tianle Cai, Yuhong Li, Zhengyang Geng, Hongwu Peng, Jason D Lee, Deming Chen, and Tri Dao. Medusa: Simple I1m inference acceleration framework with multiple decoding heads. In International Conference Machine Learning (ICML). PMLR, 2024a.
Zefan Cai, Yichi Zhang, Bofei Gao, Yuliang Liu, Tianyu Liu, Keming Lu, Wayne Xiong, Yue Dong, Baobao Chang, Junjie Hu, et al. Pyramidkv: Dynamic kv cache compression based on pyramidal information funneling, arXiv preprint arXiv:2406.00 02069, 2024b.
Huiwen Chang, Han Zhang, Lu Jiang, Ce Liu, and William T. Freeman. Maskgit: Masked generative image transformer, 2022. URL htt::tts:://// / org/ htgg/bbs/2200
04200
Zhuoming Chen, Avner May, Ruslan Svirschevski, Yuhsun Huang, Max Ryabinin, Zhihao Jia, and Beidi Chen. Sequoia: Scalable, robust, and hardware-aware speculative decoding. CoRR, 2024.
Jacob K Christopher, Brian R Bartoldson, Tal Ben-Nun, Michael Cardei, Bhavya Kailkhura, and Ferdinando Fioretto. Speculative diffusion decoding: Accelerating language generation through diffusion. arXiv preprint 240.:24080000636 2024.
10

---

Tri Dao. Flashattention-2: Faster attention with better parallelism and work partitioning. arXiv preprint arXiv:2307.08691, 2023.
Tri Dao, Dan Fu, Stefano Ermon, Atri Rudra, and Christopher Ré. Flashattention: Fast and memory- efficient exact attention with io-awareness. Advances in neural information processing systems (NeurIPS), 2022.
Mostafa Elhoushi, Akshat Shrivastava, Diana Liskovich, Basil Hosmer, Bram Wasti, Liangzhen Lai, Anas Mahmoud, Bilge Acun, Saurabh Agarwal, Ahmed Roman, al. Layerskip: Enabling early exit inference and self-speculative decoding. arXiv preprint arXiv:2404.16711 2024.
Coleman Hooper, Schoon Kim, Hiva Mohammadzudeh, Michael W Mahoney, Sophia Shao, Kurt Keutzer, and Amir Gholami. Kvquant: Towards 10 million context length Ilm inference with kv cache quantization. Advances in Neural Information Processing Systems (NeurIPS), 2024.
Jaeyeon Kim, Kulin Shah, Vasilis Kontonis, Sham Kakade, and Sitan Chen. Train for the worst, plan for the best: Understanding token ordering in masked diffusions, 2025. URL https
//arxiv. wwwxiv..rrg/bbb/255222222 06766
Woosuk Kwon, Zhuohan Li, Siyuan Zhuang, Ying Sheng, Lianmin Zheng, Cody Hao Yu, Joseph Gonzalez, Hao Zhang. and Ion Stoica. Efficient memory management for large language model serving with pagedattention. In Proceedings of the 29th Symposium Operating Systems Principles, 2023.
Yaniv Leviathan, Matan Kalman, and Yossi Matias. Fast inference from transformers via speculative decoding. In International Conference on Machine Learning (ICML), 2023.
Aixin Liu, Bei Feng, Bing Xue, Bingxuan Wang, Bochao Wu, Chengda Lu, Chenggang Zhao, Chengqi Deng, Chenyu Zhang, Chong Ruan, et al. Deepseek-v3 technical report. arXiv preprint arXiv:2412.194377 2024a.
Fangcheng Liu, Yehui Tang, Zhenhua Liu, Yunsheng Ni, Duyu Tang, Kai Han, and Yunhe Wang. Kangaroo: Lossless self-speculative decoding for accelerating LLMs via double early exiting. In The Thirty-eighth Annual Conference on Neural Information Processing Systems (NeurIPS), 2024b.
Zirui Liu, Jiayi Yuan, Hongye Jin, Shaochen Zhong, Zhaozhuo Xu, Vladimir Braverman, Beidi Chen, and Xia Hu. Kivi: A tuning-free asymmetric 2bit quantization for kv cache. arXiv preprint arXiv:2402.02750, 2024c.
Aaron Lou, Chenlin Meng, and Stefano Ermon. Discrete diffusion modeling by estimating the ratios of the data distribution, 2024.
16834
Xudong Lu, Qi Liu, Yuhui Xu, Aojun Zhou, Siyuan Huang, Bo Zhang, Junchi Yan, and Hongsheng Li. Not all experts are equal: Efficient expert pruning and skipping for mixture-of -ffeeee-ff--xperts large language models. arXiv preprint arXiv:2402.14800 2024.
Xinyin Ma, Runpeng Yu, Gongfan Fang, and Xinchao Wang. dkv-cache; The cache for diffusion language models, 2025. URL
2505..///5.... 15781
Shen Nie, Fengqi Zhu, Zebin You, Xiaolu Zhang, Jingyang Ou, Jun Hu, JUN ZHOU, Yankai Lin, Ji-Rong Wen, and Chongxuan Li. Large language diffusion models. In ICLR 2025 Workshop Deep Generative Model Machine Learning: Theory, Principle and Efficacy, 2025.
Subham Sekhar Sahoo, Marianne Arriola, Aaron Gokaslan, Edgar Mariano Marroquin, Alexander M Rush, Yair Schiff, Justin T Chiu, and Volodymyr Kuleshov. Simple and effective masked diffusion language models. In The eiihth Annual Conference Neural Information Processing Systems, 2024. URL https: /ttp::///peeereee / http://wwweeeeeeeeeeeeeeeeeeeeee wtw.neeefooruutemme.o/oooomomm fum A=AaAAAAAAAAAAAaaaaaaa
Jay Shah, Ganesh Bikshandi, Ying Zhang, Vijay Thakkar, Pradeep Ramani, and Tri Dao. Flashattention-3: Fast and accurate attention with asynchrony and now-precision. Advances in Neural Information Processing Systems (NeurIPS), 2024.

---

Jiaxin Shi, Kehang Han, Zhe Wang, Amaud Doucet, and Michalis K. Titsias. Simplified and generalized masked diffusion for discrete data, 2025. URL bttpa://atxiv..rz org.
2406604323
Hugo Touvron, Thibaut Lavril, Gautier Izacard, Xavier Martinet, Marie-Anne Lachaux, Timothée Lacroix, Baptiste Rozière, Naman Goyal, Eric Hambro, Faisal Azhar, et al. Llama: Open and efficient foundation language models. arXiv preprint arXiv:2302.13971, 2023.
Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. Advances in neural information processing systems (NeurIPS), 2017.
Chengyue Wu, Hao Zhang, Shuchen Xue, Zhijian Liu, Shizhe Diao, Ligeng Zhu, Ping Luo, Song Han, and Enze Xie. Fast-dllm: Training-frree acceleration of diffusion Ilm by enabling kv cache and parallel decoding, 2025. htt.//ttss//aaaa.oorr//////abba
22618
Yuhui Xu, Zhanming Jic, Hanze Dong, Lei Wang, Xudong Lu, Aojun Zhou, Amrita Saha, Caiming Xiong, and Doyen Sahoo. Think: Thinner key cache by query-driven pruning. In The Thirteenth International Conference on Learning Representations (ICLR), 2025.
Dongjie Yang, XiaoDong Han, Yan Gao, Yao Hu, Shilin Zhang, and Hai Zhao. Pyramidinfer: Pyramid kv cache compression for high-throughput IIm inference. arXiv preprint arXiv:2405. 12532, 2024.
Jiacheng Ye, Zhihui Xie, Lin Zheng, Jiahui Gao, Zirui Wu, Xin Jiang, Zhenguo Li, and Lingpeng Kong. Dream 7b, 2025. htthst::::/ //hkun 1 p wi.gggttiiit thub tobbo
Siyan Zhao, Devaansh Gupta, Qinqing Zheng, and Aditya Grover. dI: Scaling reasoning in diffusion large language models via reinforcement learning. arXiv preprint 11Xi:2254.12211,, 2025.
12

---

A LLM USAGE
We used large language models, specifically ChatGPT (GPT-4, OpenAl) and Gemini (Google), in limited ways during this work. First, used them improve grammar, phrasing, and clarity of exposition, but not to generate substantive technical content. Second, we occasionally consulted them help identify potentially relevant related work, while ensuring that all citations were independently checked and verified by the authors. Third, we used them at early stages as brainstorming aids to generate alternative perspectives or potential problem framings. All research directions, methods, and experiments were conceived, designed, and validated by the authors. All outputs from large language models were critically evaluated before inclusion, and the intellectual contributions of the paper are entirely the authors' own.
B SUPPLEMENTARY MATERIAL
B.1 CODE & DATA RELEASE PLAN
The implementation of our methods are available at https://giie com/ 2tt////anauuuuaaaaaa wwm--mmem-eeee elm-experimental.
C ADDITIONAL EXPERIMENTAL RESULTS
C.I ADDITIONAL EXPERIMENTAL RESULTS OF LLADA- -BBAA-B--A -B-INSTRUCT
Besides the comprehensive evaluation with the SoTA Dream-v0- -o-ntuttttttttt77 diffusion model, further validate the effectiveness of the proposed method with LLDA-SB-Instrrr Nie et al. (2025). As presented in Table 7 the proposed FreeCach che and guided unmasking have demonstrated the consistent speedup on the GSM8K dataset with 8-shot chain-of ofain-of-thought (CoT).
The baseline LAA-DA-B--Insrrunn Nie al. (2025) can optionally support semi- semi-auttregressvve un- masking by dividing the sequence into several blocks and unmasking them from left to right. The user-defined hyperparameter bl olok length defines the size of the block Nie al. (2025). How- ever, this does not make the generation autoregressive, and the model still processes the full sequence length each denoising step.
In our proposed guided diffusion method, block length is not used needed since the diffusion model generates all draft tokens at each step, while the AR model is used to guide the unmasking process. In other words, the "effective block length" of the guided unmasking is the length of all the diffused draft tokens at each step of drafting.
C.2 ADDITIONAL EXPERIMENTAL RESULTS ON DREAM-VO-INSTRUCTT7
In addition to the benchmarks reported in Table 3 Table shows HellaSwag (5-shot) results for Dream-vO-Instruct- with FreeCache and guided diffusion, highlighting substantial speedup and accuracy gains over the baseline.
Table 8: HellaSwag accuracy, latency, and speedup relative the Dream-vO-Inntruut-7B Baseline.
Model Variant
Accuracy (%)
Latency (s)
Speedup
Baseline
73.30
21.99
1.00
FreeCache + 1-..255-115B--nstrre Guided (This work)
76.63
2.46
8.94x
FreeCache + Qwen2.5-7B- -ween.55-BB-Instricc Guided (This work)
76.84
3.31
6.64x
C.3 MODEL GPU MEMORY USAGE
Table and Table 10 show the GPU memory usage (in gigabytes) of the proposed method with BL-.AA--B-Insttin and Dream-vO-Insttruce as diffusion models, respectively. The GPU memory recorded directly via torch. cuda memory al located () As shown in the tables, the
13

---

Table 7: GSM8K (8-shot) accuracy, latency, and speedup for LLaDA-SB-Instruc with block sizes 32 and 64 and guided diffusion with Qwen2.5-Instruct models. Speedups are relative to the corresponding LLaDA baseline latency.
Model Setting
Details
Accuracy (%)
Latency (s)
Speedup
LLaDA Baselines
Block Length 32
Baseline
81.52 79.76
57.02
1.00 X
FreeCache (This work)
9.20
6.20
Block Length 64
Baseline
79.30
56.89
1.00 x
FreeCache (This work)
77.18
9.02
6.32 x
Guided Diffusion
with FreeCache
Dwen2.5-1.5B-Instruu
Top-1 Match
79.91
4.29
13.29 x
Qwen2.5-3B-Insteee
Top-1 Match
79.53
5.16
11.05 x
Owen2.5-7BBInstreee
Top-1 Match
79.30
5.21
10.94 X
Qwen2.55-1.5B-Insttue
Top-2 Match
78.85
4.40
12.96 X
Qwen2.5-3B-Instee
Top-2 Match
79.75
4.40
12.96 X
Qwen2.5-7B-Instee In-strruct
Top-2 Match
79.68
4.50
12.67 X
IB---uttt
Top-5 Match
79.91
3.80
15.01 X
Qwen2.5-3B-Instteee
Top-5 Match
80.06
4.29
13.29 X
Qwen2.5-7B-Instruuct
Top-5 Match
79.76
4.42
12.90 X
proposed guided unmasking scheme introduces minimal memory overhead compared to the combined memory consumption of the single regreseeeee and baseline diffusion models.
Table 9: LLaDA-8B -----uuttt Guided Diffusion Memory Usage (GB)
Table 10: Dream-v0-Instruet. Guided Diffu-
sion Memory Usage (GB)
AR Guider
Diff. (GB)
Guide (GB)
Total (GB)
AR Guider
Diff. (GB)
Guide (GB)
Total (GB)
Qwen2.5-0.5B
1.9
22.6
Qwen2.5-0.58
1.9
16.5
Owen2.5-1.5B
4.1
24.8
Owen2.5-1.55
4.1
18.7
20.7
14.6
Qwen2.5-3B
6.7
27.4
Qwen2.5-3B
6.7
21.3
Qwen2.5-7B
17.3
38.0
Qwen2.5-7B
17.3
31.9
C.4 IMPLEMENTATION DETAILS
The proposed method directly employs the off tff-thh-sheef diffusion and auto-regressive large language models (for guided masking) from HuggingFace. The proposed method uses the same set of configurations for all tasks. We believe a more fine-grained hyper-parameter setting can lead to improved performance, but we keep single set of configurations to demonstrate the generality and practicality. Table [I shows the detailed experimental configuration of the proposed method with Dream-vO-Instruet-7 Ye al. (2025) and LLaDA-SB- ---strut Nie et al. (2025).
Stochastic Guided Unmasking, Please note that during guided unmasking, we only consider the Top-K logits of the AR-guider model the guidance logits log,. In addition to the deterministic guidance strategy (Algorithm and Algorithm 2), the maximum token logit of the diffusion output (of each token) is greater 7 max(log,).. ), the token will be unmasked. Otherwise, will remain silent, where 7 is the Gu dance Con Confident dence Threshold d (default = 0.5).
C.5 PROMPT TEMPLATES
Prompt Configuration for Question Answering and Reasoning. We would like to highlight that evaluation protocol encourages the diffusion model generate the output tokens with the sense
14

---

Table 11: Diffusson configuration of the Instruct Nie et al. (2025) employed in this work.
Ye et (2025 and LLaDA-8B-
Setting
Dreass- -i-nt-ruc--- Ti
2035
anl al
Configuration FreeCache (This work)
Outgot
Lengly
2025
Coutiguration of FreeCache Guided Unmasking (This work)
Max Outpu Tokens
1024
1034
Speculation Block Size
Top-X Assisted Tokess Sclection
Guidkmee Confidenc Thresheld
of reasoning for both math solving and basic common QA tasks (e.g.. PiQA). As result, the model achieves higher accuracy compared to the reported performance in Ye et al. (2025). To solidify the fact that not heavily relying on prompt engineering, we release the prompt templates as follows:
ARC (-C/E):
You are a careful reasoning assistant. A commonsense sentence shown with a blank and **four** Answers that could fill the blank. Think step by step about which option makes the sentence most sensible, then decide.
### Sentence:
<sentence>
### What you should do:
1. Briefly explain your reasoning.
2. On a **new line** write exactly: "The final answer is [answer]" where ** *#answer]** ** is either ** Answerl ** Answerr2#* ** Answer3** or ** **Anwer4#* Do * nor** output anything after that line.
GPQA:
You are careful reasoning assistant. A question is shown with **four** possible answers. Think step by step about which option is correct, then decide.
###
Question: <question>>>
### In your response:
First reason and explain your reasoning briefly before providing the final answer to the
question.
2. Then at the end of your explanation, on a nen line**, write exactly: "The final answer is [answer]" where **[answer]** ** is one of ** Answerl ** ** **Anwwer2** ** **Answe3***
** *nnwwrr*** Do **oo*** output anything after that line.
GSMSK:
Given the following problem, reason and give final answer to the problem.
Problem: <problem>>
Your response should end with "The final answer is [answer]" where [answer] is just the final number to the problem.
15

---

HellaSwag:
You are careful reasoning assistant. A commonsense sentence is shown with blank and **four** Endings that could fill the blank. Think step by step about which option makes the sentence most sensible, then decide.
### Sentence:
<sentence>>
### In your response:
1. First reason and explain your reasoning briefly before answering this question.
2. Then at the end of your explanation, on **new line**, write exactly: "The final answer is [answer]" where **[anwwer]** is either **Ending1 ** **Ending2**, **Ending3**, or **Ending*** Do ***o output anything after that line.
PIQA:
Below is an instruction that describes task. Write a response that appropriately completes the request.
### Instruction: <instruction>>
Your response should end with "The final answer is [answer]" where [answer] is the response to the problem.
MMLU-PRO:
The following are multiple choice questions (with answers) about a subject. Think step by step and then finish your answer with "the answer is (X)" where X is the correct letter choice.
The prompt of MMLU-PRO is adopted from the official repository of MMLU-PRO benchmark.
16


Reviews:
[{"review_id": "WiIO55E7mS", "reviewer": "Reviewer_GXxp", "summary": "### **Paper Summary**  \nDiffusion Language Models (DLMs) offer advantages like **parallel token generation** and **inherent bidirectionality** over autoregressive (AR) LLMs, but suffer from slow inference—their iterative denoising requires multiple full-sequence forward passes, leading to high latency. Additionally, parallel generation causes token incoherence, and reducing denoising steps degrades output quality.  To address these issues, the paper proposes **FreeCache** and **Guided Diffusion** techniques under the FlashDLM framework. **FreeCache** is  a training-free KV caching technique for DLMs: It exploits the temporal stability of KV projections in unmasked tokens to reduce redundant computations, enabling efficient long-context inference without fine-tuning. **Guided Diffusion** is a training-free cross-model guidance method: By using a lightweight AR model to validate DLM draft tokens, it resolves token incoherence and drastically reduces denoising iterations while preserving the DLM’s reasoning power.  Extensive experiments on benchmarks show the combined methods deliver an **average 12.14× end-to-end speedup** with negligible accuracy degradation.", "questions": "### **Questions and Suggestions for Authors**  \n\n1. **Can FLASHDLM Maintain Performance on Ultra-Long Contexts?**  \nThe paper claims support for long-context generation (>1024 tokens) but only tests up to 1024 tokens. For ultra-long contexts, FreeCache’s frozen KV blocks may accumulate to cause memory bottlenecks, and Guided Diffusion’s matching ratio could drop due to increased semantic drift. Does FLASHDLM’s latency-accuracy tradeoff hold for these extended sequences, and are there optimizations needed to support them?  \n \n2. **Implement Adaptive Block Size for FreeCache to Improve Task Adaptability**  \nGiven the limitations of a fixed 256-token block size, the authors should design an adaptive block size mechanism. For instance, use smaller blocks for short sequences to reduce redundant computation, and larger blocks for long contexts to minimize window-shrinking overhead. \n\n3. **Evaluate Guided Diffusion with Low-Resource and Domain-Specific AR Guiders**  \nTo enhance practicality, the authors should test Guided Diffusion with low-resource AR models and domain-mismatched guiders.", "limitations": "", "rating": 6, "confidence": 2, "soundness": 2, "presentation": 3, "contribution": 2, "strengths": "### **Strengths of the Proposed Method**  \n1. **Training-Free Design for Off-the-Shelf Deployment**  \nThe core techniques (FreeCache and Guided Diffusion) require no additional training, fine-tuning, or dedicated calibration runs—they directly accelerate pre-trained DLMs \"off the shelf\". This avoids the overhead of retraining large models and significantly lowers the barrier to practical adoption.  \n\n2. **FreeCache: Targeted KV Caching to Cut Redundant Computation**  \nFreeCache leverages a key insight—KV projections of \"clean\" (unmasked) tokens exhibit high temporal stability across denoising steps—to dynamically shrink the active computation window. By freezing KV projections of completed token blocks and only recomputing for pending blocks, it eliminates redundant full-sequence calculations inherent to vanilla DLMs.  \n\n3. **Guided Diffusion Resolves Parallel Generation Incoherence**  \nGuided Diffusion addresses DLM’s critical token incoherence issue by using a lightweight AR model as a \"coherence supervisor\". It only unmask tokens where the DLM’s draft predictions match the AR model’s outputs, ensuring semantic consistency without sacrificing parallel generation advantages. Unlike heuristic sampling methods that suffer severe accuracy loss with fewer steps, Guided Diffusion recovers accuracy even with aggressive denoising reductions.  \n\n4. **Breakthrough Latency Parity with Autoregressive (AR) Models**  \nFor the first time, the method enables DLMs to match or outperform same-sized AR models in latency while preserving accuracy. This bridges the latency gap that previously restricted DLM adoption in high-throughput scenarios.  \n\n5. **Low Memory Overhead for Practical Deployment**  \nGuided Diffusion introduces minimal additional memory usage when combining DLMs and AR guiders. This efficiency makes the framework suitable for edge or resource-constrained environments.", "weaknesses": "### **Weaknesses and Restrictions**  \n1. **Limited Validation Across DLM Architectures and Scales**  \nThe method’s experiments are restricted to only two DLMs: Dream-7B-Instruct and LLaDA-8B-Instruct. It lacks testing on larger DLM variants (e.g., 13B/34B parameter DLMs) or domain-specific DLMs, making it unclear whether FreeCache’s KV stability assumption or Guided Diffusion’s AR supervision generalizes to more complex or specialized DLM structures. \n\n2. **Sensitivity to the Quality and Domain Alignment of AR Guiders**  \nGuided Diffusion relies entirely on a lightweight AR model to ensure token coherence, but the paper provides limited analysis of how AR guider quality or domain mismatch impacts performance.\n\n3. **Fixed Block Size in FreeCache Lacks Adaptive Optimization**  \nFreeCache uses a fixed block size for all tasks and models, with no analysis of how block size impacts latency or accuracy. For short-sequence tasks, a 256-token block may lead to underutilization of the active window. For ultra-long sequences, a fixed block size could prevent optimal window shrinking. The lack of adaptive block size tuning limits FreeCache’s efficiency across sequence lengths and task types.  \n\n5. **Insufficient Comparison with State-of-the-Art DLM Acceleration Methods**  \nWhile the method compares against vanilla DLMs and AR models, it lacks head-to-head evaluation with other state-of-the-art DLM acceleration techniques.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "HfmlZfTEef", "reviewer": "Reviewer_vA4B", "summary": "The paper presents FlashDLM, an inference-time framework to speed up diffusion language models without extra training. It has two parts. FreeCache observes that the Key/Value projections of finalized tokens change very little across denoising steps and reuses those projections, so later steps only recompute attention for the unfinished suffix instead of the full sequence. Guided Diffusion uses a small autoregressive model to check the DLM’s parallel token proposals and confirm the longest common prefix, which reduces the number of denoising steps and improves coherence.", "questions": "1) Which block sizes and shrink schedules work best across tasks? Could a dynamic policy that adapts block size based on local uncertainty or AR-agreement rate further reduce recomputation?\n2) Beyond the current longest-prefix rule with top-k and threshold τ, have you tried alternatives such as per-token margin checks, KL limits, or short rollback windows, and how do they affect step count, latency, and accuracy?", "limitations": "", "rating": 6, "confidence": 3, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "1) The method is training-free.\n2) The experiments connect the stability observation to a concrete algorithm and show clear improvements in latency with small or no drops in accuracy.\n3) The paper motivates FreeCache with a figure that shows stability across steps and positions. The description of block partitioning, active window recomputation, and progressive freezing is easy to follow.\n4) The work targets a key bottleneck for DLMs in long-context reasoning: repeated full-sequence passes and parallel decoding incoherence.", "weaknesses": "1) The study centers on Dream-7B-Instruct and LLaDA-8B-Instruct with reasoning benchmarks. It is unclear how FreeCache scales to much larger DLMs or to domains such as dialogue safety, coding, or open-ended writing, where coherence needs may differ. Adding more domains or larger models would strengthen external validity.\n2) Guided Diffusion depends on a longest-prefix acceptance rule with top-k AR logits and a confidence threshold τ. A deeper ablation on k, τ, and different AR guiders would clarify robustness and failure modes.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "aBwzzVHwyY", "reviewer": "Reviewer_rtU8", "summary": "The authors propose a novel, training-free method to accelerate Diffusion Language Model (DLM) inference. The approach consists of two key techniques: 1) **FreeCache**, an efficient KV cache compression strategy that reduces computational overhead, and 2) **Guided Diffusion**, a collaborative workflow that uses a lightweight autoregressive (AR) model to guide the DLM's token unmasking process. The authors validate their method through comprehensive evaluations on various downstream tasks, demonstrating significant speedups with minimal accuracy degradation. The reported performance improvements are substantial and promising.", "questions": "The paper mentions partitioning the sequence into \"fixed-size blocks.\" How was this block size determined? what is the sensitivity of the results to this choice?", "limitations": "", "rating": 6, "confidence": 2, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "- The paper is clearly written, with a concise and logical explanation of the motivations, insights, and methodological details.\n- The experimental validation is  thorough, including both accuracy benchmarks and detailed inference latency measurements. The demonstrated inference speedup is impressive and a strong contribution.", "weaknesses": "- While the overall inference improvement is significant, a detailed breakdown of the contribution from each component (FreeCache vs. Guided Diffusion) would be beneficial. An ablation study showing the speedup and accuracy impact of each technique individually would help readers understand their relative importance.\n- The AR-guided strategy is interesting. However, the analysis could be strengthened by including a discussion or experiment quantifying the inference overhead introduced by the AR model itself. A theoretical or empirical analysis of the computational cost of the guidance step would provide a more complete picture of the net performance gain.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "LHIapbWF3q", "reviewer": "Reviewer_fREk", "summary": "The authors identify two main problems in current diffusion language models (DLMs). First, the lack of KV-caching, and second, the reduced quality when generating multiple tokens in parallel. The authors introduce (1) FreeCache, a KV-caching approximation, and (2) GuidedDiffusion, to improve the sampling speed and performance respectively.", "questions": "1. Did the authors consider periodically refreshing the KV cache during sampling, rather than keeping it fixed throughout generation? If so, how does occasional refreshing impact performance?\n\n2. **Focus on greedy decoding**: Lines 154-155, Equation 3: The decoding scheme assumes greedy token selection, whereas most prior work (e.g., MDLM, MD4) uses sampling for token selection and random position choice. Restricting to greedy decoding may be problematic, e.g. for coding or math. Why did the author decide to focus on greedy decoding only? Speculative decoding can handle stochastic sampling for example.", "limitations": "", "rating": 2, "confidence": 4, "soundness": 3, "presentation": 3, "contribution": 1, "strengths": "1. The claim on line 207, that the KV projections for the clean tokens exhibit high temporal stability is well-supported, as the authors compute the similarity.\n2. On reasoning tasks, the authors obtain faster generation with a small reduction in performance. \n3. The paper is generally clear and well-written. Aside from the *key* edge case noted in the weaknesses, the implementation details should allow reproducibility.", "weaknesses": "### Major Weaknesses\n1. **Overlap with previous work**. The two contributions of the authors overlap with prior work on discrete diffusion. Namely,\n    - **FreeCache**: KV caching for diffusion language models has already been explored in prior work, which unfortunately is not acknowledged or compared against in this submission. See, for example, [1-2].\n    - **GuidedDiffusion**: There is strong overlap with [3]. My understanding is that the main difference is that GuidedDiffusion here uses a large dLLM, whereas [3] uses a smaller one as the drafter and drafts only a few tokens. Since the AR and diffusion greedy predictions are supposed to align in this work, it seems important to compare GuidedDiffusion with [3], where Dream 7B would be the drafter and the AR model would be Qwen.\n\n2. **Key edge case not discussed**: When the AR model and the diffusion model disagree on the next token (i.e., their argmax outputs differ for a given prompt), how is this conflict resolved? Does the AR model take precedence? This scenario is likely to be common, yet I did not see it discussed.\n\n3. **Potentially unrealistic assumption**: The method assumes that the smaller AR model can reliably verify tokens, but if the AR model is weak, this verification should not work (see previous point).\n\n4. **Poor argument of the shortcomings of parallel generation**: Section 3.1.2 misses the most important point: the main challenge in parallel generation is that DLLMs predict a *factorized* distribution, because joint modeling over all masked tokens is computationally infeasible and grows exponentially with vocabulary size (see [1-2]).\n\n### Other weaknesses\n1. Missing citation to relevant background work: D3PM, SEDD, MD4.\n\n2. It is not stated how the similarity between KV projections in adjacent steps is measured (Figure 2). Is it the cosine similarity?\n\n3. **Focus on semi-AR generation not clear form the background**: The background (lines 153-155) mentions position selection based on confidence, but it is not clearly stated that the authors use semi-autoregressive (semi-AR) decoding. Since their approach relies on an AR model to validate tokens, this should be explicitly clarified to improve reader understanding.\n\n4. Lines 101-102: *\"these methods are computationally expensive for computation\"*. This should be clarified.\n\n5. Lines 342-345: *\"Unlike speculative decoding, Guided Diffusion does not require token-wise correction from the auto-regressive model. In other words, the proposed method produces output sequence without introducing the repetitive correction process, which guarantees the latency benefits obtained from the fast diffusion process.\"*. This paragraph sounds generic, and it is not clear what the authors mean. Guided Diffusion still uses an autoregressive model for generation, and, in my understanding, rejects tokens that are not the most likely under the AR model.\n\n6. Lines 348-349: *\"To that end, the reasoning power of the diffusion model is fully preserved, while the AR guider model simply ensures the causality of the output.\"*. This claim seems unjustified. What if the AR model is too weak? Then I would expect it will not be able to align its argmax with diffusion model.\n\n[1] Ma et al., dKV-Cache: The Cache for Diffusion Language Models.\n\n[2] Wu et al., Fast-dLLM: Training-free Acceleration of Diffusion LLM by Enabling KV Cache and Parallel Decoding.\n\n[3] Christopher et al., Speculative Diffusion Decoding: Accelerating Language Generation through Diffusion.\n\n[4] Xu et al., Energy-Based Diffusion Language Models for Text Generation.\n\n[5] Lui et al., Discrete Copula Diffusion.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}]

Author rebuttal:

Decision: Accept (Poster)