Text Lives in the Guidance: Preventing Silent Text Rewriting in Cached Diffusion Transformers

Kun Zhou, Wenmian Yang, Zhensheng Wang, Weijia JiaarXiv 2026 · arXiv

TL;DR

Feature caching is a standard trick to speed up Diffusion Transformers (DiTs), but it often "silently" garbles rendered text while maintaining high image-level quality scores. This paper introduces GuideCache, a method that identifies and recomputes only the specific image tokens where guidance error is highest, restoring near-perfect text fidelity with a ~2.4x speedup.

What Problem Does This Paper Address?

Modern Diffusion Transformers like Z-Image and Qwen-Image have finally cracked the code on rendering long, legible text. However, generating high-resolution (1024²) images is computationally expensive, requiring dozens of passes through multi-billion parameter networks.

To speed things up, researchers use feature caching: instead of computing every step fully, they compute "anchor" steps and extrapolate the features for the steps in between. While standard metrics like CLIP score or FID suggest these caches are "lossless," the authors discovered a phenomenon they call silent text rewriting. As shown in Figure 1, accelerated models might keep the overall layout and "vibe" of an image perfectly, but they subtly swap characters or turn legible words into gibberish. Because standard metrics don't "read" the text, this failure goes unnoticed during evaluation.

Figure 1. Feature caching silently rewrites text. Full-compute images (left) and text crops on Z-Image (top) and Qwen-Image (bottom); tags count the target strings that OCR reads correctly. FORA and TaylorSeer (2.94× fewer FLOPs) keep the layout of full compute but garble the text. With GuideCache (2.41× and 2.46×), TaylorSeer writes it correctly.

Methods

The authors trace the root of the problem to Classifier-Free Guidance (CFG). In CFG, the model makes two predictions: an unconditional one ($u$) and a conditional one ($c$). The final output is a weighted combination: $v = u + w(c - u)$, where $(c - u)$ is the "guidance term" ($g$).

Their key discovery is that caching errors are not distributed equally. The guidance term $g$ is much harder to extrapolate than the shared part $u$, especially in text regions.

GuideCache addresses this with a surgical approach:

  1. Split Caching: It stores the shared part $u$ and the guidance term $g$ separately at anchor steps.
  2. Error Prediction: On cached steps, it doesn't just guess. It uses the finite difference of stored guidance terms to predict which tokens will have the highest extrapolation error.
  3. Selective Recomputation: It performs a "partial forward pass" to recompute both CFG branches only for the top-$k$ tokens with the highest predicted error. The rest of the tokens are extrapolated as usual.
Figure 3. Overview of GuideCache. Anchor steps (left) store the shared part ua and the guidance term ga. Cached steps (right) score tokens from the stored ga, recompute both branches on the top-kt tokens, and extrapolate the rest.

Datasets

The authors evaluated their method on:

  • LongText-Bench: A benchmark with 320 English and Chinese prompts specifically designed to test text rendering.
  • DrawBench: Used to ensure general image quality (non-text) remains high.
  • CVTG-2K: Used for calibrating the error-proportional budget.
  • Models: They tested on Z-Image (6B) and Qwen-Image (20B) at $1024^2$ resolution.

Key Insights and Ideas

  • Text Lives in the Guidance: Text regions have a significantly higher "guidance share" than the background. In Z-Image, the guidance term makes up 1.66x more of the output norm in text regions compared to texture-matched control regions.
  • The Extrapolation Gap: Caches extrapolate the guidance term roughly twice as poorly in text as in other regions, while the shared "unconditional" part is extrapolated equally well everywhere.
  • Causal Splice: By manually "splicing" exact guidance values into a cached run only within text boxes, the authors recovered 83% of the lost prompt fidelity. This proved that the guidance term is the primary failure point.
  • Guidance as a Signal: You don't need OCR or attention maps to find the text. The magnitude and curvature of the guidance signal itself are excellent predictors of where the cache will fail, naturally highlighting text tokens.
Analysis showing that the guidance term (w g) carries the most error and that recomputing it specifically in text regions recovers the vast majority of lost fidelity.

Key Results

  • Fidelity Recovery: On TaylorSeer (a state-of-the-art cache), GuideCache at a 2.4x speedup recovered 91% of the word accuracy lost by the plain cache on Z-Image and 73% on Qwen-Image.
  • Efficiency: GuideCache achieves better text rendering than other token-wise methods like ToCa or TeaCache while staying much closer to the full model's original output (measured by lower LPIPS).
  • Robustness: It works across different cache orders (0th-order reuse like FORA or 1st-order Taylor expansion). Even at high speedups (3.85x), it prevents the total collapse of text that occurs in standard caches.
Visualization of tokens selected by GuideCache. Even without knowing where the text is, the algorithm naturally selects tokens corresponding to the text elements.

Limitations and Future Work

  • True CFG Dependency: GuideCache relies on the model having separate conditional and unconditional branches. It is not directly applicable to "guidance-distilled" models (like SDXL-Turbo or Lightning) that merge these steps.
  • OCR-Centric Evaluation: The study uses OCR readers to score success. While effective for legibility, it doesn't account for more subjective "stylistic" rewriting or typographic nuances.
  • Future Directions: The authors suggest that all future acceleration methods for DiTs should be evaluated specifically on their ability to preserve rendered text, as standard image-level metrics are insufficient "silent" witnesses to text degradation.

Summary updated

Abstract

Diffusion transformers (DiTs) now render long, legible text in images, and feature caching is a standard way to accelerate them. Caches are judged by image-level metrics, which do not check whether the rendered text is still correct. We find that caching silently rewrites this text. On Z-Image, TaylorSeer at 2.9x fewer FLOPs lowers word accuracy from 62% to 46%, while ImageReward and CLIP Score barely change. Sampling with fewer steps at the same compute keeps almost all of this text, so the loss comes from how the cache predicts the skipped steps. Decomposing the cache error along classifier-free guidance (CFG), we trace this loss mainly to the guidance term, the difference between the conditional and unconditional predictions, which caches extrapolate worst on text. Correcting the guidance inside the text alone recovers most of the lost text. We therefore propose GuideCache, which recomputes both CFG branches only on the tokens with the largest predicted guidance error, using the guidance terms that the cache already stores. At 2.4x fewer FLOPs, GuideCache restores full-compute prompt fidelity on Z-Image and Qwen-Image, and on Z-Image it renders text as well as or better than ToCa, TeaCache, and FasterCache while staying much closer to the full model's output. GuideCache works with caches of any order, and on top of fewer sampling steps it keeps more text than step reduction at a higher speedup. These results suggest that acceleration methods for text-rendering models should be evaluated on the text they render.
BibTeX
@misc{zhou2026text,
  author = {Kun Zhou and Wenmian Yang and Zhensheng Wang and Weijia Jia},
  title = {{Text Lives in the Guidance: Preventing Silent Text Rewriting in Cached Diffusion Transformers}},
  year = {2026},
  eprint = {2611.25382},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2611.25382},
}
Figure