Paper deep dive
WaiT for the Signal: Simple Frequency-Aware Flow-Matching
Krunoslav Lehman Pavasovic, Théophane Vallaeys, Stéphane Mallat, Giulio Biroli, Luke Zettlemoyer, Brian Karrer, Jakob Verbeek
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 92%
Last extracted: 8/3/2026, 2:09:55 AM
Summary
The paper introduces WaiT (Wavelet-aware image Transformer), a frequency-aware flow-matching model that decomposes image generation into coarse (low-frequency) and fine (high-frequency) bands using the Discrete Wavelet Transform (DWT). By delaying the denoising of high-frequency bands until coarse structures are established, WaiT improves generation quality and reduces sampling compute by up to 50%. It achieves state-of-the-art results on ImageNet 512x512 (FID 1.3) and Kinetics-600 video generation (FVD 0.84) using a three-axis evaluation protocol (FID, 5cFID, hFWD).
Entities (9)
Relation Signals (6)
WaiT → achieves → FID 1.3
confidence 95% · With our largest 2B model, we set a new state-of-the-art FID of 1.3 for pixel-space models on ImageNet 512 resolution.
WaiT → evaluatedon → ImageNet
confidence 95% · On ImageNet 512x512, WaiT achieves a pixel-space FID of 1.43
WaiT → uses → Discrete Wavelet Transform
confidence 95% · We utilize the Discrete Wavelet Transform (DWT) to separate the signal into distinct bands.
WaiT → appliedto → Kinetics-600
confidence 90% · scales seamlessly to ... video generation, achieving a state-of-the-art FVD of 0.84 on Kinetics-600
WaiT → outperforms → JiT
confidence 90% · WaiT improves over the JiT baseline across almost all metrics
WaiT → uses → Flow Matching
confidence 90% · Simple Frequency-Aware Flow-Matching
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:As image generation models scale to ever higher resolutions, global coherence, local detail, and texture fidelity become critical axes for generation quality. However, standard flow matching treats all spatial frequencies uniformly, ignoring the natural frequency hierarchy where high-frequency bands become indistinguishable from pure noise far earlier than coarse structures. We introduce WaiT, a Wavelet-aware image Transformer that decomposes generation into coarse and fine bands via lossless wavelets. True to its name, the high-frequency bands wait for the signal: staying pure noise until coarse structure has emerged, then joining the flow for joint refinement. Since standard FID discards fine-grained detail through aggressive downsampling, we introduce a more stringent three-axis evaluation protocol to assess quality at native resolution. On ImageNet 512x512, WaiT achieves a pixel-space FID of 1.43 and is Pareto-optimal across all three axes, reducing sampling compute by up to 50%. With our largest 2B model, we set a new state-of-the-art FID of 1.3 for pixel-space models on ImageNet 512 resolution. Our formulation outperforms even the strongest latent-space models on texture fidelity, and scales seamlessly to high-resolution OpenImages and to video generation, achieving a state-of-the-art FVD of 0.84 on Kinetics-600 with no algorithmic modifications.
Tags
Links
- Source: https://arxiv.org/abs/2607.28760v1
- Canonical: https://arxiv.org/abs/2607.28760v1
Trouble viewing inline? Open PDF directly →
Full Text
96,140 characters extracted from source content.
Expand or collapse full text
1]FAIR, Meta 2]École Normale Supérieure, Paris 3]Sorbonne University, Paris WaiT for the Signal: Simple Frequency-Aware Flow-Matching Krunoslav Lehman Pavasovic Théophane Vallaeys Stéphane Mallat Giulio Biroli Luke Zettlemoyer Brian Karrer Jakob Verbeek [ [ [ krunolp@meta.com Abstract As image generation models scale to ever higher resolutions, global coherence, local detail, and texture fidelity become critical axes for generation quality. However, standard flow matching treats all spatial frequencies uniformly, ignoring the natural frequency hierarchy where high-frequency bands become indistinguishable from pure noise far earlier than coarse structures. We introduce WaiT, a Wavelet-aware image Transformer that decomposes generation into coarse and fine bands via lossless wavelets. True to its name, the high-frequency bands wait for the signal: staying pure noise until coarse structure has emerged, then joining the flow for joint refinement. Since standard FID discards fine-grained detail through aggressive downsampling, we introduce a more stringent three-axis evaluation protocol to assess quality at native resolution. On ImageNet 512×512, WaiT achieves a pixel-space FID of 1.43 and is Pareto-optimal across all three axes, reducing sampling compute by up to 50%. With our largest 2B model, we set a new state-of-the-art FID of 1.3 for pixel-space models on ImageNet 512 resolution. Our formulation outperforms even the strongest latent-space models on texture fidelity, and scales seamlessly to high-resolution OpenImages and to video generation, achieving a state-of-the-art FVD of 0.84 on Kinetics-600 with no algorithmic modifications. Krunoslav Lehman Pavasovic at . Figure 1: Evaluating WaiT on ImageNet 512 and OpenImages 1024. Left: Pareto fronts of compute vs. FID, 5-crop FID, and high-frequency FWD; WaiT (green) dominates baselines at 2× lower compute. Right: WaiT generates sharper textures/finer details than both JiT and RAE. Figure 2: Overview of WaiT inference process. The low-frequency (LF) wavelet band is denoised first along a coarse time tLFt_LF to prioritize coarse structural coherence. The high-frequency (HF) bands wait as pure noise during this stage. At the crossover tLF=t∗t_LF=t^*, the partially denoised LF band and the noisy HF bands are combined via the inverse DWT and jointly denoised yielding the final image. 1 Introduction Standard flow matching treats all spatial frequencies uniformly, but the natural power-law frequency hierarchy of images calls for a more nuanced approach because high-frequency content is destroyed by noise much earlier than coarse structure [10, 36, 7]. We find that existing models spend a significant portion of their sampling trajectory on HF bands indistinguishable from noise (Figure˜3), wasting modeling capacity precisely when global coherence is being established. We therefore propose to “wait for the signal”, based on a long-standing principle from progressive compression standards like JPEG 2000 [35], and to leverage the lossless Discrete Wavelet Transform (DWT) to embed frequency awareness directly into the generative process. Rather than engineering complex architectural pyramids, we simply decouple the noise schedules of coarse and fine bands in a pixel diffusion model. By delaying the high-frequency generation, much like progressive compression delays high-frequency bit allocation [33], we allow the model to focus on coarse structural coherence without wasting its modeling capacity on high-frequency components early in the denoising process. We achieve this by defining two linear noise schedules: one over the full [0,1][0,1] interval for the coarse band, and one over a limited interval [t∗,1][t^*,1] for the fine band. The denoising process for inference then naturally denoises low frequency components first, after which we inject high frequency noise at time t∗t^*, combine both bands using the inverse wavelet transform, and then denoise both bands jointly. This simple approach substantially improves generation quality while naturally unlocking significant computational savings across model scales, resolutions, and modalities. See Figure˜2 for an overview of our approach. To measure performance for high-resolution image generation, we propose a new three-axis evaluation protocol. As FID downsamples images to 299×299, it inherently discards high-frequency textures and local details that distinguish true high-fidelity outputs, which is fundamentally insufficient as generation scales to 512×512, 1024×1024, and beyond. To properly assess high-frequency generated content, we employ a three-axis evaluation protocol, where in addition to standard FID we use 5-crop FID (5cFID) for local structural detail via native-resolution crops, and high-frequency Fréchet Wavelet Distance (hFWD) to isolate pure texture fidelity (see Appendix˜C for details on how both metrics are computed). We implement our approach on the recent pixel-space JiT model [25]. Through extensive experiments, we show that this approach yields excellent results: an FID of 1.43, 5cFID of 1.63, and hFWD of 0.67 on ImageNet 512×512, while reducing sampling GFLOPs by up to 50% compared to the JiT baseline. Notably, on pure texture fidelity (hFWD) we outperform both state-of-the-art pixel- and latent-space methods. With our largest 2B model we set a new best FID of 1.3 for ImageNet 512 resolution for pixel-space models. Similar trends are observed for class-conditional generation on OpenImages. See Figure˜1 for selected results. Beyond class-conditional generation, WaiT transfers to pixel-space text-to-image synthesis at 1024×1024, matching or exceeding JiT on almost all metrics at up to 3× higher throughput. The same recipe carries over unchanged to the temporal domain, where spatiotemporal wavelets reach a state-of-the-art FVD of 0.84 on Kinetics-600. Our main contributions are as follows: • We introduce Wavelet-aware image Transformer, a pure pixel-space approach that embeds the natural frequency structure of images into the denoising process: a principled inductive bias that improves generation quality while significantly reducing computational cost. • We employ a three-axis evaluation protocol (FID, 5cFID, hFWD) capturing global coherence, local detail, and texture fidelity, revealing complementary weaknesses in both pixel-space and latent-space methods that standard FID alone cannot detect. The protocol is validated, showcasing strong correlation with human preference judgments (Section˜D.2). • We demonstrate Pareto optimality among pixel-space models across all three metrics on ImageNet 512×512 and OpenImages 512×512 and 1024×1024 resolution. • We show that the framework extends directly to text-to-image and video generation. On text-to-image at 1024×1024, WaiT improves over the JiT baseline across almost all metrics while achieving up to 3× higher throughput; on video, spatiotemporal wavelets yield a state-of-the-art FVD of 0.84 on Kinetics-600 using the same core recipe. 2 Related Work Figure 3: Mutual information (MI) between noisy and clean wavelet bands. Top: Forward process on real images. Fine (HF) bands lose MI far earlier than coarse (LF). The star marks t∗≈0.25t^*≈0.25, where fine MI drops below 0.01 nats. Bottom: The same asymmetry persists in backward process for JiT. See Appendix B for details on MI estimation. Pixel-Space and Cascaded Diffusion. Pure pixel-space modeling has recently re-emerged as competitive with latent approaches, led by Simpler Diffusion (SiD2) [19] and Just image Transformers (JiT) [25]. Beyond diffusion, JetFormer [38] models raw images and text jointly with a normalizing-flow–based autoregressive prior, and is also trained end-to-end without a pretrained autoencoder. To scale to high resolutions, cascaded models such as CDM [17], PixelFlow [4], and Pyramidal Flow Matching [21] generate in stages, but suffer a train–test mismatch: the high-frequency band carries faint signal at training time yet is replaced by pure noise at inference. Existing fixes (noise augmentation, learned upsamplers) are ad-hoc; our frequency-domain construction removes this mismatch in a principled manner. Architectural Frequency Awareness. Several methods exploit frequency separation via specialized architectural designs: DeCo [28] pairs a DiT [30] for LF semantics with a pixel decoder for details, PixelDiT [46] and DiP [5] use dual pathways, and LapFlow [49] and Edify Image [1] process Laplacian-pyramid scales in parallel. In contrast, WaiT requires no architectural changes beyond adding a resolution embedding to the existing time and class conditioning, solving frequency awareness purely through the noise schedule on a standard transformer architecture design. Frequency-Domain Representations. DCTdiff [29] models diffusion in DCT space, but relies on lossy HF truncation and a global, uniform noise schedule. Unlike DCTdiff, our wavelet-based approach is lossless, using band-specific schedules to exploit the temporal asymmetry of noise corruption. Closer to us, FreqFlow [36] also observes that flow matching generates low frequencies before high frequencies, but injects this prior via a two-branch architecture with band-specific losses and wavelet-derived features fed into a pixel-level branch. In contrast, our approach acts purely on the noise schedule and requires no architectural changes. 3 The WaiT Approach Our design rests on two well-established observations. First, the natural frequency hierarchy of images [10, 7] implies that high-frequency signals are overwhelmed by noise far sooner than coarse structures, which standard flow matching ignores. We further confirm this asymmetry empirically in trained pixel-space models (Figure˜3). Second, scale-wise factorization is theoretically shown to be more stable than joint modeling [14], suggesting fine details should follow rather than lead the coarse structure during generation. We therefore formulate the generative process in the wavelet domain to explicitly control the noise schedule at different frequencies and delay the fine bands. In practice, we implement this approach on the transformer architecture of JiT with minimal architectural changes. 3.1 Frequency-specific Noise Schedules We utilize the Discrete Wavelet Transform (DWT) to separate the signal into distinct bands. Given an image x∈ℝDx ^D, a single-level DWT yields a low-frequency (LF) approximation band xLF∈ℝD/4x_LF ^D/4 and high-frequency (HF) detail bands xHF∈ℝ3D/4x_HF ^3D/4. Because the DWT is orthogonal and invertible via the IDWT, it serves as a lossless bridge between coarse structure and fine detail without requiring external models. In our framework, the LF band effectively assumes the role of the spatially compressed space used by latent generative models. But unlike learned autoencoders, the wavelet transform is lossless, invertible, and requires no training. In this paper we use the Haar wavelet throughout;111For readers less familiar with the wavelet literature: a single-level 2D Haar transform is, up to a constant scale factor, exactly 2×22×2 average pooling with stride 2. The LF band is the block average, and the three HF bands store the horizontal, vertical, and diagonal differences within each 2×22×2 block—precisely the information discarded by average pooling, and exactly what is needed to invert the transform losslessly. we ablate alternative wavelet families in Section˜D.1 and find WaiT robust to this choice, keeping Haar for simplicity. Standard flow matching models [26] define a uniform interpolation zt=t⋅x+(1−t)⋅ϵz_t=t· x+(1-t)·ε for t∈[0,1]t∈[0,1]. We decouple this process into band-specific signal mixing coefficients tLFt_LF and tHFt_HF. We identify tLFt_LF with the global time t (so the LF band follows the standard schedule), and let the HF band lag behind via the delayed schedule introduced below; we therefore use t and tLFt_LF interchangeably from here on. The initial step is to decompose the clean image x∈ℝDx ^D into its frequency components: (xLF,xHF)=DWT2(x)(x_LF,x_HF)=DWT2(x). Before flow matching we normalize the LF band by a scalar SLFS_LF, writing x~LF=xLF/SLF x_LF=x_LF/S_LF, while the HF bands are left unnormalized (both motivated in the Band Normalization paragraph below). We then apply band-specific interpolation to these components: tHF=max(0,tLF−t∗1−t∗).t_HF= (0, t_LF-t^*1-t^* ). Both bands then follow a straightforward linear interpolation using their respective timescales: zLF,t=tLF⋅x~LF+(1−tLF)⋅ϵLF,zHF,t=tHF⋅xHF+(1−tHF)⋅ϵHF.z_LF,t=t_LF· x_LF+(1-t_LF)· _LF, z_HF,t=t_HF· x_HF+(1-t_HF)· _HF. In this formulation, x~LF x_LF is the normalized LF band and xHFx_HF the HF wavelet coefficients of the clean image x, and ϵLF,ϵHF∼iid(0,I) _LF, _HF N(0,I) are independent Gaussian noise samples drawn directly in the wavelet domain, with the channel dimensions of zLF,tz_LF,t and zHF,tz_HF,t being D/4D/4 and 3D/43D/4, respectively. For tLF≤t∗t_LF≤ t^*, we have tHF=0t_HF=0, so the HF band is pure unit-variance noise: zHF,t=ϵHFz_HF,t= _HF. During sampling, we inject fresh noise ϵHF∼(0,I) _HF (0,I) at precisely t∗t^*, which matches this distribution exactly. This mathematical alignment ensures the sampling distribution perfectly matches the training distribution at the transition point t∗t^*, resolving the train-test discrepancy of discontinuous schedules (see Figure˜4(a)), resulting in a structured, non-diagonal, colored Gaussian noise in the pixel space. Band Normalization. The DWT redistributes signal energy unevenly: the LF band produces values in [-2,2][-2,2] (for input normalized to [-1,1][-1,1]), while HF bands are naturally small-valued (σ∼0.05σ 0.05–0.190.19, measured on ImageNet 256×256). As introduced above, we normalize the LF band before flow matching: x~LF=xLF/SLF, x_LF=x_LF\,/\,S_LF, where SLFS_LF is the 95th percentile of absolute LF coefficients over the training set (e.g., SLF=1.94S_LF=1.94 for ImageNet 256 resolution). We prefer p95p_95 over the maximum (outlier-sensitive) or standard deviation (heavy-tailed). HF bands are left unnormalized: a few large coefficients already match the noise schedule, while the near-zero bulk reflects natural sparsity–preserving it keeps the model focused on structural edges rather than amplifying numerical noise. See App. A.3 for further discussion, where we also ablate several normalization schemes. 3.2 Training Objective and Modifications Training objective. We adopt the same training objective as JiT [25]: x-prediction with v-loss, applied separately to each phase. Using the relation vθ=(xθ−z)/(1−t)v_θ=(x_θ-z)/(1-t), the v-loss becomes a reweighted x-loss. In our case, supervision targets the (scaled) wavelet bands of x1x_1 rather than x1x_1 itself, so each frequency can be weighted by its own noise level, something a single pixel-space loss against x1x_1 cannot express. Coarse objective: The model operates on the normalized LF band, predicting normalized x~LF x_LF from the noisy input zLF,t=tLF⋅x~LF+(1−tLF)⋅ϵLFz_LF,t=t_LF· x_LF+(1-t_LF)· _LF where tLF=t_LF=t: ℒcoarse=t∼U[0,1],x,ϵ[(1−tLF)−2‖xθ(zLF,t,t)−x~LF‖2].L_coarse=E_t U[0,1],\,x,ε [(1-t_LF)^-2\|x_θ(z_LF,t,t)- x_LF\|^2 ]. We let t∼U[0,1]t U[0,1] during training, however during sampling coarse is only until t<t∗t<t^*. We find this to lead to important improvements, and ablate this choice in our experiments. Fine objective: The model operates on the full-resolution image in pixel space for t>t∗t>t^*. Crucially, the noisy input z~t=IDWT(zLF,t⋅SLF,zHF,t) z_t=IDWT(z_LF,t· S_LF,z_HF,t) has frequency-dependent noise levels: the LF band is interpolated at tLF=t_LF=t, while the HF band uses its accelerated schedule tHF=(tLF−t∗)/(1−t∗)t_HF=(t_LF-t^*)/(1-t^*). A single forward pass x^=xθ(z~t,t) x=x_θ( z_t,t) produces a pixel-space prediction, which we decompose via DWT into band-wise predictions (x^LF,x^HF)=DWT2(x^)( x_LF, x_HF)=DWT2( x), normalize the LF prediction as x~^LF:=x^LF/SLF x_LF:= x_LF/S_LF, and supervise with band-specific reweighting: ℒfine=t>t∗,x,ϵ[(1−tLF)−2‖x~^LF−x~LF‖2+(1−tHF)−2‖x^HF−xHF‖2].L_fine=E_t>t^*,x,ε [(1-t_LF)^-2\| x_LF- x_LF\|^2+(1-t_HF)^-2\| x_HF-x_HF\|^2 ]. Here x~LF x_LF is the target normalized LF band and x~^LF x_LF its prediction, while xHFx_HF is the target HF band and x^HF x_HF its prediction. The DWT applied to the network output is computationally negligible compared to the forward pass, and matches the inference-time decomposition in Table˜1. Resolution conditioning. Following PixelFlow [4], we encode the resolution scalar (e.g., 256, 512) via a standard sinusoidal embedding and MLP, adding it to the time and class conditioning so the model can distinguish denoising phases. 3.3 Sampling Table 1: WaiT aligns the generative process with image hierarchy: low frequencies lead the structural synthesis, while high frequencies wait for the signal–evolving on a separate timescale. Wavelet-aware image Transformer (WaiT) 1. zlow,zhigh∼iid(0,I)z_low,\,z_high N(0,I) 2. for t=0→t∗t=0→ t^*: Coarse flows; Fine waits zlow←Denoise(zlow,t)z_low (z_low,\,t) 3. for t=t∗→1t=t^*→ 1: Fine emerges; Joint refinement [zlow,zhigh]←Denoise(zlow,zhigh,t)[z_low,\,z_high] (z_low,\,z_high,\,t) 4. return IDWT(zlowz_low, zhighz_high) Two-phase generation. At inference, generation proceeds in two phases (Table˜1): (1) ODE integration for 0≤t<t∗0≤ t<t^* at low resolution (LF band only), then (2) un-normalize the LF band, inject fresh HF noise at the variance prescribed by t∗t^*, map to full resolution via IDWT, and continue the ODE for t∗<t≤1t^*<t≤ 1, as shown in Figure 4(a) as Delayed Linear. Phase 0 operates at 4×4× fewer tokens (for a single-level DWT); this reduced token count is the source of compute savings. Step allocation. Given a total budget of N ODE steps, we allocate n to Phase 0 and N−nN-n to Phase 1. In practice we parametrize this split by two knobs: the timestep shift α which warps the uniform t-grid to concentrate steps near t=0t\!=\!0 [2, 9], and a Phase 0 multiplier m that scales the resulting fraction of steps falling below t∗t^* (so m=1m\!=\!1 recovers the natural split induced by α, and larger m shifts more steps into the cheaper Phase 0). Since Phase 0 steps operate at 4×4× fewer tokens, larger n (via either α or m) directly reduces total GFLOPs. Full parametrization and the values used in our experiments are given in Section˜A.2. 4 Experiments Datasets. For ablations and main results we consider class-conditional generation based on the common ImageNet-1k [32] at 256 and 512 resolution setup. Going beyond 512 resolution on ImageNet is not meaningful as only 5.3% of the images have a shortest side ≥ 512. So the vast majority of reference images would be upsampled, injecting interpolation artifacts that corrupt precisely the high-frequency statistics we are interested in. We therefore curate natively 512 and 1024 resolution subsets from OpenImages V6 [24] with similar number of classes and images as ImageNet-1k. The dataset construction details (fully deterministic) required to reproduce the exact train/val splits, are provided in Appendix E. Metrics. To measure generation quality we report three different metrics. Standard FID quantifies global coherence, as its downsampling to 299×299 discards high-frequency information. We introduce 5-crop FID to measure local detail by calculating the FID with statistics computed over five distinct, 299 native-resolution crops (corners + center) instead of downsampling. We also tested random native-resolution crops and obtained almost identical results; we adopt the fixed corners+center scheme for determinism and reproducibility. Complementing this, we use high-frequency FWD (hFWD), a dedicated metric for texture fidelity, which computes the Fréchet Wavelet Distance [40] while explicitly excluding the low frequencies (DC wavelet packet). This exclusion is critical because the LF component contains no high-frequency signal and would otherwise dominate the metric, making it redundant with FID. These three metrics (global coherence, local detail, and texture fidelity) together provide a necessary and comprehensive evaluation of modern generative models for high-fidelity, high-resolution synthesis. We further verify that these metrics reflect and align with human perception: on the PIPAL perceptual benchmark [12], both 5cFID and hFWD correlate strongly with its ∼1.13 1.13M human preference judgments (Pearson |PLCC||PLCC| up to 0.710.71 and Spearman |SRCC||SRCC| up to 0.660.66, with Holm–Bonferroni-corrected p<4×10−4p<4× 10^-4); see Section˜D.2 for the full analysis. (a) Schedule choice. (b) Optimal t∗t^*. Design choice FID ↓ Δ 0 Naïve two-stage JiT 7.51 — 1 + Delayed linear sched. (a) 5.43 −2.08-2.08 2 + Global coarse [0,1][0,1] 3.81 −1.62-1.62 3 + Optimal t∗=0.25t^*\!=\!0.25 (b) 3.57 −0.24-0.24 (c) Cumulative ablation. Figure 4: Designing WaiT. Two most important design choices are (a) the multi-res. schedule, where the delayed linear schedule lets HF bands smoothly emerge from t∗t^* while finishing jointly at t=1t=1, and (b) the choice of threshold t∗t^*, optimal at t∗=0.25t^*=0.25 where HF mutual information vanishes (Figure˜3); at t∗=0t^*=0 the method reduces to standard JiT. (c) Cumulative effect of these choices plus global coarse training on ImageNet 256×256 with WaiT-B/16; the final model halves the FID while saving 50% GFLOPs. 4.1 Design ablation How to denoise in the frequency domain? A natural starting point is a discontinuous two-stage cascade as in PixelFlow [4] and Pyramidal Flow [21]: a coarse stage on [0,t∗][0,t^*] followed by HF noise injection at t∗t^* (leftmost panel of Figure˜4(a)). This naïve two-stage baseline (Figure˜4(c), row 0) uses a fixed t∗=0.5t^*=0.5 and trains the coarse stage only on [0,t∗][0,t^*]; rows 1–3 then add our improvements cumulatively. However, the hard handoff creates a train–test mismatch at t∗t^* (FID 7.517.51). Replacing it with a delayed linear schedule which couples LF and HF continuously in a single jointly trained model cuts FID to 5.435.43 (−2.08-2.08); see Fig.4(a) and Fig.4(c). What is the best range to train the LF band? We find global coarse training over the full [0,1][0,1] interval to improve over using [0,t∗][0,t^*] as in [4, 21] (−1.62-1.62 FID; row 2 of Fig.4(c)). This is a simple but intuitive choice that exposes the model to LF tokens across the full trajectory, letting it learn how HF depends on the underlying coarse structure rather than treating LF as an isolated subproblem. Table 2: Results on class-cond. ImageNet 512x512. † using SSL or text-supervised latent space. Results taken from original papers, except for models marked with ∗* which we trained ourselves using open-source code. 5cFID = 5-crop FID. hFWD = high. freq. FWD. We evaluate the latter metrics using open-source weights, or mark ’-’ where not available. Method params GFLOPs FID↓ 5cFID↓ hFWD↓ Latent-space models DiT-XL/2 [30] 675+49M 525 3.04 2.44 1.75 SiT-XL/2 [27] 675+49M 525 2.62 - - REPA, SiT-XL/2† [45] 675+49M 525 2.08 - - FreqFlow [36] 507+49M N/A 2.02 - - DDT-XL/2† [42] 675+49M 525 1.28 1.98 1.16 RAE, DiTDH^DH-XL/2† [50] 839+415M 642 1.13 1.26 1.56 Pixel-space models ADM-G [6] 559M 1983 7.72 6.77 1.53 RIN [20] 320M 415 3.95 - - SiD, UViT/4 [18] 2B 555 3.02 - - PixNerd, XL/16† [41] 700M 583 2.84 - - VDM++, UViT/4 [22] 2B 555 2.65 - - DiP-XL/32 [5] 631 N/A 2.31 - - SiD2, UViT/4 [19] N/A 137 2.19 - - Pixel DiT [46] 797M 1352 1.81 2.19 2.19 SiD2, UViT/2 N/A 653 1.48 - - JiT-B/32 [25] 133M 26 4.02 9.63 2.10 JiT-B/16∗ 133M 118 3.30 5.80 1.10 JiT-L/32 462M 89 2.53 8.75 2.06 JiT-L/16∗ 462M 400 2.10 4.20 0.69 JiT-H/32 956M 183 1.94 6.28 1.33 JiT-H/16∗ 956M 810 1.70 3.30 0.64 JiT-G/32 2B 384 1.78 5.56 1.16 JiT-G/16∗ 2B 1665 1.69 3.30 0.61 Wavelet-aware image Transformer (ours) WaiT-B/32 133M 11 4.77 7.25 2.75 WaiT-B/16 133M 72 3.26 4.28 1.18 WaiT-L/32 462M 56 2.48 5.16 2.46 WaiT-L/16 462M 195 1.68 2.15 1.03 WaiT-H/32 956M 115 1.99 4.31 1.71 WaiT-H/16 956M 397 1.43 1.63 0.67 WaiT-G/32 2B 194 1.67 3.18 1.24 WaiT-G/16 2B 822 1.30 1.45 0.59 Does delaying HF help, and by how much? Our mutual-information analysis (Figure˜3) shows that HF carries no learnable signal at small t, so t∗>0t^*>0 should preserve quality while cutting compute, and free up modeling capacity to improve LF denoising in the first stage. Sweeping t∗t^* confirms this (Figure˜4(b)): t∗=0t^*\!=\!0 is equivalent to a standard JiT, while t∗=0.25t^*\!=\!0.25 gives a further −0.24-0.24 FID. 4.2 Main results: class-conditional image generation ImageNet 512×512. We compare WaiT with state-of-the-art generative image models in Table˜2. WaiT improves over all previous pixel-space models at matched compute, as well as most latent-space baselines, and matches JiT FID at roughly half the inference compute. Notably, WaiT-H/16 reaches FID 1.43 at under 400 GFLOPs, and WaiT-G/16 sets a new pixel-space SOTA of 1.30 FID. Figure˜1 shows that WaiT consistently improves the Pareto-front over JiT across all three metrics; see Fig.5 for qualitative comparison with JiT and RAE, and Figures˜9, 10 and 11 in the supplementary material for additional samples. Figure 5: Qualitative comparison across state-of-the-art methods on ImageNet 512×512. WaiT-H/16, JiT-H/16 and RAE on three classes (strawberry, jacamar, leopard); each class displays the full resolution image with a yellow rectangle marking the zoomed crop. The crops highlight a consistent pattern: JiT visibly struggles with fine local detail (blurred strawberry seeds, jacamar eye and beak, and leopard’s facial detail), while RAE produces sharp textures but distorts high-frequency structure (with visible checkerboard artifacts). WaiT performs well on both axes, preserving fine detail and the underlying high-frequency structure. OpenImages-1M. Figure˜1 reports compute vs. image quality on OpenImages 1024 for WaiT and JiT from B/64 to G/32. WaiT dominates JiT’s Pareto front by a large margin, matching its (5-crop) FID at ∼2× \!2× lower compute; while JiT’s hFWD plateaus around 0.5 already at B/32, WaiT keeps benefiting from more inference compute and pushes hFWD well below 0.3. The appendix provides analogous 512-resolution plots showing similar trends with smaller WaiT-vs-JiT gaps, underlining WaiT strengths at high resolution, together with Haar coefficient distribution analysis and qualitative comparisons at both 512 and 1024 resolutions. Figure 6: High-frequency wavelet coefficient distributions on OpenImages. At 512×512 our distribution already tracks the real data more closely than JiT, and the gap widens at 1024×1024 where JiT degrades to a markedly flatter, broader distribution – our advantage grows with resolution. 4.3 Pixel-space text-to-image generation at 1024 resolution Dataset construction. We construct a high-resolution dataset using three sources: SA-1B [23], DataComp Multimodal (Mitigated subset) [11], and OpenImages [24]. We discard images with shortest side under 1024, while SA-1B and DataComp form the backbone of the corpus. Surviving images were passed through aesthetic scoring and a watermark/OCR detector to eliminate logos and text overlays, yielding a curated dataset of approximately 40M images. To ensure textual alignment for conditioning, we employed a caption enrichment pipeline where we (re)caption most of the dataset with paragraph-length descriptions detailing lighting conditions, micro-textures, and spatial relationships, while retaining high-quality human annotations where available. We use two data preparation pipelines. In the first, we used SigLIP [47] for aesthetic scoring and watermark filtering, Qwen3-VL [37] to generate dense, highly detailed captions for the training images, and T5-v1.1-XXL [31] to represent the captions and condition the model on the embeddings via cross-attention mechanisms within each transformer block. We defined a second pipeline that replaces these models with MetaCLIP [43], Llama 3.2 Vision [8], and Llama 3.1 [8], respectively. The complete, fully public construction recipe—sources, resolution filter, scoring prompts and thresholds, and the captioning prompt—is given in Section˜E.6. Results. We train JiT-H/32 and WaiT-H/32 models on this dataset at 1024 resolution. In Table˜3 we report results as measured over a held-out evaluation set, adding CLIPScore [16] to measure alignment between the prompt and the generated images, as well as the more comprehensive GenEval and DPG metrics. Using both data preparation pipelines, WaiT yields similar or better results than JiT, while achieving up to 3× higher throughput. We present several qualitative examples comparing WaiT with JiT in Figure˜7. Additional examples are provided in Figure˜19 in the appendix. Table 3: Comparison of WaiT with JiT on text-to-image generation. We consider two data preparation pipelines, and train H/32 models at 1024 resolution. Encoders Method FID↓ 5cFID↓ hFWD↓ CLIP↑ GenEval↑ DPG↑ imgs/s↑ SigLIP + Qwen3-VL + T5-v1.1-XXL JiT-H/32 5.35 8.90 3.40 26.71 0.442 0.824 0.10 WaiT-H/32 5.15 8.40 3.30 26.75 0.491 0.823 0.29 MetaCLIP + Llama 3.2 Vision + Llama 3.1 JiT-H/32 5.24 6.62 2.31 39.10 0.419 0.798 0.12 WaiT-H/32 4.78 6.53 2.31 39.43 0.460 0.805 0.28 SigLIP + Qwen3-VL + T5-v1.1-XXLMetaCLIP + Llama 3.2 Vision + Llama 3.1 Figure 7: Text-to-image samples at 1024 resolution. Per-column prompts and per-row method/encoder details are provided in Section˜D.5 in the Appendix. 4.4 Video generation results Table 4: Taichi-HD (128×128) FVD on 5K generated videos vs. training set. FVD (↓ ) LPIPS (↓ ) GFLOPs Unconditional Generation JiT-B/8 28.92 - 21,260 WaiT-B/8 27.13 - 16,624 Conditional Generation (1→ 16 frames) JiT-B/8 19.92 0.297 21,260 WaiT-B/8 19.75 0.292 16,694 Table 5: Kinetics-600 (128×128, 5→ 16 frames). FVD on full validation set. Model FVD (↓ ) GFLOPs / 10210^2 RIN [20] 10.8 1,200 MAGVIT-v2 [44] 4.3 120 W.A.L.T. [13] 3.3 120 Unified Latents (S) [15] 1.7 300 Unified Latents (M) 1.3 700 JiT-B/8 1.50 300 WaiT-B/8 1.45 210 JiT-XL/8 0.89 1,580 WaiT-XL/8 0.84 1,110 Table 6: Kinetics-600 (256×256, 5→ 16 frames). FVD on full validation set. Model FVD (↓ ) GFLOPs / 10210^2 JiT-XL/32 1.32 371 WaiT-XL/32 1.20 319 WaiT directly generalizes to pixel-space video generation: the wavelet decomposition now operates over three axes (height, width, time), reducing the coarse-phase token count 8×8×. We use two datasets for our experiments: Taichi-HD [34] with ∼ 3k videos of people performing Tai Chi, and Kinetics-600 [3] with ∼ 450k videos. In all video experiments we use a temporal patch size of 4 frames, while the model size and spatial resolution vary by experiment (from B/8 at 128×128128× 128 up to XL/32 at 256×256256× 256). To measure the generated video quality we use the FVD metric [39]. In case of generation conditioned on one or more real frames, we also measure LPIPS [48] metric comparing the frames of the generated continuation with those of the ground-truth one. Taichi-HD. We consider generation of 16 frames, either unconditionally or conditioned on an additional initial frame, where the final frame is discarded for FVD evaluation. In Table˜6 we report results for WaiT and the JiT baseline. WaiT improves over JiT in both conditional and unconditional settings, while leading to about 22% compute reduction. Qualitative examples are shown in Fig. 20 in the appendix. Kinetics-600. Here we condition on 5 frames and generate 16 frames. For FVD evaluation, we use the initial 5 frames with the subsequent 11 generated frames, following [13, 15, 20, 44]. In Table˜6 we compare WaiT with JiT (we trained JiT models using open source code) as well as previous results from the literature. While JiT already improves the FVD of 1.7 from Unified Latents (small) [15] to 1.5 at equal compute, WaiT further reduces the FVD to 1.45 while reducing compute by 30%. With the larger WaiT-XL/8 we are able to push the FVD further down to a new state-of-the-art result of 0.84. Uncurated samples are shown in Figure 21 in the appendix. We additionally train XL/32 models on Kinetics-600 at 256×256256× 256 (Table˜6), where WaiT again improves quality while reducing compute. On both benchmarks, Wavelet-aware image Transformer matches or improves video quality while reducing compute by approximately 30%. These results demonstrate that the core benefits of WaiT, improved generation and reduced compute, transfer seamlessly across modalities. In the video experiments we used the shift parameters α and m for sampling optimized for images, but are confident that minor, targeted tuning could yield further substantial GFLOP savings at minimal cost to video quality. 4.5 Further extensions A useful side effect of only modifying the noise schedule is that WaiT is easy to combine with other changes, since the backbone stays untouched. We check this in two ways: adding a third frequency level, and applying the same recipe in a latent space. In both cases we reuse the WaiT recipe directly, running each setting once and without any hyperparameter tuning. Multi-level transitions. Our formulation extends directly from a single (22-level) transition to multiple levels. On OpenImages-1M at 1024×10241024× 1024 (L/32), we apply a 33-level schedule out of the box, normalizing both the first and second LF bands by their respective p95p_95 constants and setting the two transition points to t∗=0.15,0.3t^*=\0.15,0.3\ (Table˜8). The additional level raises compute savings to 33%33\% and improves both high-frequency metrics (5cFID and hFWD), at a marginal cost in FID. Transfer to latent space. Although WaiT is motivated by pixel space, the same recipe applies unchanged in a learned latent space. We apply it to DDT/XL-2 [42] out of the box, training WaiT+DDT from scratch directly at 512×512512× 512 for only 500500k steps, whereas the DDT baseline is trained for 1.281.28M steps at 256×256256× 256 and then finetuned for a further 500500k steps at 512×512512× 512 (Table˜8). Despite using less than a third of the training budget, WaiT+DDT matches the baseline FID (1.331.33 vs. 1.281.28), improves 5cFID (1.771.77 vs. 1.981.98), and reduces inference compute by 35%35\% (329329 vs. 525525 GFLOPs); matching the training budget or light tuning would likely improve this further. Table 7: Multi-level transitions on OpenImages-1M 1024×10241024× 1024 (L/32), applied out of the box, evaluated on 5k images. Configuration FID (↓ ) 5cFID (↓ ) hFWD (↓ ) Compute savings (↑ ) WaiT (22 levels, t∗=0.25t^*=0.25) 9.74 21.71 0.918 18.5% WaiT (33 levels, t∗=0.15,0.3t^*=\0.15,0.3\) 10.11 16.03 0.867 33.0% Table 8: Out-of-the-box transfer to latent space (DDT/XL-2) on ImageNet 512×512512× 512. Method FID (↓ ) 5cFID (↓ ) hFWD (↓ ) GFLOPs (↓ ) Training steps DDT [42] 1.28 1.98 1.16 525 1.28M + 500k WaiT + DDT 1.33 1.77 1.20 329 500k (from scratch) 5 Limitations and future work Coarse-phase compression depth. Our current formulation uses a single DWT level for maximum simplicity (with the exception of the three-level experiment in Table˜8). Future work could explore deeper compression, such as using a two- or three-level low-frequency band to drastically shrink the coarse token grid before injecting all high-frequency levels simultaneously at t∗t^*, or progressively. Finding such quality-compute frontiers will determine if extreme compression can retain enough signal for fine-phase recovery, potentially unlocking substantially larger compute savings. Integration with SOTA architectures. Our text-to-image and video experiments intentionally use basic baseline configurations to isolate the effects of our approach. Future research might integrate standard architectural/optimization improvements, exploring how these compound with our method will clarify how much further performance and compute gains can be unlocked across both modalities. Video evaluation at scale. Because our video experiments align with current pixel-space benchmarks at 128×128 resolution (e.g., Kinetics-600, Taichi-HD) (however we also trained on 256×256), standard FVD cannot capture high-frequency textures, preventing the use of our full three-axis evaluation protocol. As natively high-resolution video datasets emerge, evaluating global coherence, local detail, and texture fidelity will be crucial to demonstrate that our image-domain benefits transfer to high-resolution video. 6 Conclusion We introduced the Wavelet-aware image Transformer (WaiT), a principled extension to pixel-space flow matching models. WaiT employs a delayed and accelerated noise schedule for the HF band, withholding its denoising until low-frequency signals are available. Governed by a single transition point t∗t^* and a lossless, parameter-free wavelet transform, WaiT integrates seamlessly into existing architectures like JiT. Despite this simplicity, WaiT achieves Pareto-optimal compute–quality trade-offs across global structure (FID), local detail (5-crop FID), and texture fidelity (hFWD) on ImageNet 512 and OpenImages 512/1024. On ImageNet 512, we set a new state-of-the-art FID of 1.3 for pixel-space models, improving FID by 23% and 5-crop FID by 56% over compute-matched JiT baselines. We observe similar improvements in pixel-space text-to-image modeling at 1024 resolution. When applied to video, WaiT achieves state-of-the-art FVD on Kinetics-600 with a 30% compute reduction, demonstrating that a single, unified recipe suffices for high-fidelity image and video generation. We hope our approach will serve as a foundation for future pixel-space generative models operating at even higher resolutions and across additional modalities. Acknowledgments This work has received funding from the French government, managed by the National Research Agency (ANR), under the France 2030 program with the reference ANR-23-IACL-0008. Furthermore, this paper is supported by PNRR-PE-AI FAIR project funded by the NextGeneration EU program. We would like to thank David Lopez-Paz, Ricky Chen, Tianhong Li, and Yaron Lipman for fruitful discussions. References Atzmon et al. [2024] Matan Atzmon, Axel Sauer, and Tero Karras. Edify image: High-fidelity image generation with laplacian pyramids. NVIDIA Technical Report, 2024. Black Forest Labs [2024] Black Forest Labs. Flux: State-of-the-art text-to-image generation. https://blackforestlabs.ai/, 2024. Carreira et al. [2018] Joao Carreira, Eric Noland, Andras Banki-Horvath, Chloe Hillier, and Andrew Zisserman. A short note about kinetics-600. arXiv preprint arXiv:1808.01340, 2018. Chen et al. [2025] Shoufa Chen, Chongjian Ge, Shilong Zhang, Peize Sun, and Ping Luo. PixelFlow: Pixel-space generative models with flow. arXiv preprint, 2504.07963, 2025. https://arxiv.org/abs/2504.07963. Chen et al. [2026] Zhennan Chen, Junwei Zhu, Xu Chen, Jiangning Zhang, Xiaobin Hu, Hanzhen Zhao, Chengjie Wang, Jian Yang, and Ying Tai. DiP: Taming diffusion models in pixel space. In Conference on Computer Vision and Pattern Recognition, 2026. https://arxiv.org/abs/2511.18822. Dhariwal and Nichol [2021] Prafulla Dhariwal and Alex Nichol. Diffusion models beat GANs on image synthesis. In Advances in Neural Information Processing Systems, 2021. https://arxiv.org/abs/2105.05233. Dieleman [2024] Sander Dieleman. Spectral autoregression. https://sander.ai/2024/09/02/spectral-autoregression.html, September 2024. Blog post. Dubey et al. [2024] Abhimanyu Dubey, Abhinav Jauhri, Abhinav Pandey, Abhishek Kadian, et al. The llama 3 herd of models. arXiv preprint arXiv:2407.22706, 2024. Esser et al. [2024] Patrick Esser, Sumith Kulal, Andreas Blattmann, Rahim Entezari, Jonas Müller, Harry Saini, Yam Levi, Danilo Lorber, Robin Rombach, and Björn Ommer. Scaling rectified flow transformers for high-resolution image synthesis. arXiv preprint arXiv:2403.03206, 2024. Falck et al. [2025] Fabian Falck, Teodora Pandeva, Kiarash Zahirnia, Rachel Lawrence, Richard Turner, Edward Meeds, Javier Zazo, and Sushrut Karmalkar. A fourier space perspective on diffusion models, 2025. https://arxiv.org/abs/2505.11278. Gadre et al. [2024] Samir Yitzhak Gadre, Gabriel Ilharco, Alex Fang, Jonathan Hayase, Georgios Smber, Julia Kreutzer, and Alec et al. Ross. Datacomp: In search of the next generation of multimodal datasets. In Advances in Neural Information Processing Systems, 2024. Gu et al. [2020] Jinjin Gu, Haoming Cai, Haoyu Chen, Xiaoxing Ye, Jimmy Ren, and Chao Dong. PIPAL: A large-scale image quality assessment dataset for perceptual image restoration. In European Conference on Computer Vision (ECCV), 2020. Gupta et al. [2023] Agrim Gupta, Lijun Yu, Kihyuk Sohn, Xiuye Gu, Meera Hahn, Li Fei-Fei, Irfan Essa, Lu Jiang, and José Lezama. Photorealistic video generation with diffusion models. In European Conference on Computer Vision, 2023. https://arxiv.org/abs/2312.06662. Guth et al. [2022] Florentin Guth, Simon Coste, Valentin De Bortoli, and Stéphane Mallat. Wavelet score-based generative modeling. In Advances in Neural Information Processing Systems (NeurIPS), 2022. Heek et al. [2026] Jonathan Heek, Emiel Hoogeboom, Thomas Mensink, and Tim Salimans. Unified latents (UL): How to train your latents. arXiv preprint arXiv:2602.17270, 2026. https://arxiv.org/pdf/2602.17270. Hessel et al. [2021] Jack Hessel, Ari Holtzman, Maxwell Forbes, Ronan Le Bras, and Yejin Choi. CLIPScore: A reference-free evaluation metric for image captioning. In EMNLP, 2021. Ho et al. [2022] Jonathan Ho, Chitwan Saharia, William Chan, David J. Fleet, Mohammad Norouzi, and Tim Salimans. Cascaded diffusion models for high fidelity image generation. Journal of Machine Learning Research, 23(47), 2022. https://jmlr.org/papers/v23/21-0635.html. Hoogeboom et al. [2023] Emiel Hoogeboom, Jonathan Heek, and Tim Salimans. Simple diffusion: End-to-end diffusion for high resolution images. In International Conference on Machine Learning, 2023. https://arxiv.org/abs/2301.11093. Hoogeboom et al. [2025] Emiel Hoogeboom, Thomas Mensink, Jonathan Heek, Kay Lamerigts, Ruiqi Gao, and Tim Salimans. Simpler diffusion (SiD2): 1.5 FID on ImageNet512 with pixel-space diffusion. In Conference on Computer Vision and Pattern Recognition, 2025. https://arxiv.org/abs/2410.19324. Jabri et al. [2023] Allan Jabri, David Fleet, and Ting Chen. Scalable adaptive computation for iterative generation. In International Conference on Machine Learning, 2023. https://arxiv.org/abs/2212.11972. Jin et al. [2025] Yang Jin, Zhicheng Sun, Ningyuan Li, Kun Xu, Kun Xu, Hao Jiang, Nan Zhuang, Quzhe Huang, Yang Song, Yadong Mu, and Zhouchen Lin. Pyramidal flow matching for efficient video generative modeling. In ICLR, 2025. https://arxiv.org/abs/2410.05954. Kingma and Gao [2023] Diederik P. Kingma and Ruiqi Gao. Understanding diffusion objectives as the ELBO with simple data augmentation. arXiv preprint, 2303.00848, 2023. https://arxiv.org/abs/2303.00848. Kirillov et al. [2023] Alexander Kirillov, Eric Mintun, Nikhila Ravi, Hanzi Mao, Chloe Rolland, Laura Gustafson, Tete Xiao, Spencer Whitehead, Alexander C. Berg, Wan-Yen Lo, Piotr Dollár, and Ross Girshick. Segment anything. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 4015–4026, 2023. Kuznetsova et al. [2020] Alina Kuznetsova, Hassan Rom, Neil Alldrin, Jasper Uijlings, Ivan Krasin, Jordi Pont-Tuset, Shahab Kamali, Stefan Popov, Matteo Malloci, Alexander Kolesnikov, Tom Duerig, and Vittorio Ferrari. The open images dataset v4: Unified image classification, object detection, and visual relationship detection at scale. International Journal of Computer Vision, 128(7):1956–1981, 2020. Li et al. [2025] Xiang Li, Kai Chen, and Zhenguo Wang. Just image transformers: Pixel-space diffusion without pretrained autoencoders. arXiv preprint, 2025. Lipman et al. [2022] Yaron Lipman, Ricky Chen, Heli Ben-Hamu, Maximilian Nickel, and Matt Le. Flow matching for generative modeling. arXiv preprint, 2022. https://openreview.net/forum?id=PqvMRDCJT9t. Ma et al. [2024] Nanye Ma, Mark Goldstein, Michael S. Albergo, Nicholas M. Boffi, Eric Vanden-Eijnden, and Saining Xie. SiT: Exploring flow and diffusion-based generative models with scalable interpolant transformers. In European Conference on Computer Vision, 2024. https://arxiv.org/abs/2401.08740. Ma et al. [2025] Yuxin Ma, Wei Zhang, and Chen Liu. Deco: Decoupled low-frequency semantics and high-frequency details for image generation. arXiv preprint, 2025. Ning et al. [2024] Mang Ning, Mingxiao Li, Jianlin Su, Albert Ali Salah, and Itir Onal Ertugrul. Dctdiff: Intriguing properties of image generative modeling in the dct space. arXiv preprint arXiv:2401.02992, 2024. Peebles and Xie [2023] William Peebles and Saining Xie. Scalable diffusion models with transformers. In International Conference on Computer Vision, 2023. https://arxiv.org/abs/2212.09748. Raffel et al. [2020] Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J Liu. Exploring the limits of transfer learning with a unified text-to-text transformer. The Journal of Machine Learning Research, 21(1):5485–5551, 2020. Russakovsky et al. [2015] Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, Alexander C. Berg, and Li Fei-Fei. Imagenet large scale visual recognition challenge. International Journal of Computer Vision, 115(3):211–252, 2015. Shapiro [1993] Jerome M. Shapiro. Embedded image coding using zerotrees of wavelet coefficients. IEEE Transactions on Signal Processing, 41(12):3445–3462, 1993. 10.1109/78.258085. Siarohin et al. [2019] Aliaksandr Siarohin, Stéphane Lathuilière, Sergey Tulyakov, Elisa Ricci, and Nicu Sebe. First order motion model for image animation. In Advances in Neural Information Processing Systems, 2019. Skodras et al. [2001] A. Skodras, C. Christopoulos, and T. Ebrahimi. The jpeg 2000 still image compression standard. IEEE Signal Processing Magazine, 18(5):36–58, 2001. 10.1109/79.952804. Sucheng et al. [2026] Ren Sucheng, Yu Qihang, He Ju, Shen Xiaohui, and Chen Liang-Chieh. Frequency-aware flow matching for high-quality image generation. In CVPR, 2026. Team [2025] Qwen Team. Qwen3-vl: Scaling vision-language models with improved architecture and training. arXiv preprint arXiv:2502.13923, 2025. Tschannen et al. [2025] Michael Tschannen, André Susano Pinto, and Alexander Kolesnikov. Jetformer: An autoregressive generative model of raw images and text. In International Conference on Learning Representations, volume 2025, pages 85995–86016, 2025. Unterthiner et al. [2019] Thomas Unterthiner, Sjoerd van Steenkiste, Karol Kurach, Raphael Marinier, Marcin Michalski, and Sylvain Gelly. Towards accurate generative models of video: A new metric & challenges. In ICLR Workshop on Deep Generative Models for Highly Structured Data, 2019. https://arxiv.org/abs/1812.01717. Veeramacheneni et al. [2025] Lokesh Veeramacheneni, Moritz Wolter, Hildegard Kuehne, and Juergen Gall. Fréchet wavelet distance: A domain-agnostic metric for image generation, 2025. Wang et al. [2025a] Shuai Wang, Ziteng Gao, Chenhui Zhu, Weilin Huang, and Limin Wang. PixNerd: Pixel neural field diffusion. In International Conference on Learning Representations, 2025a. https://arxiv.org/abs/2507.23268. Wang et al. [2025b] Shuai Wang, Zhi Tian, Weilin Huang, and Limin Wang. DDT: Decoupled diffusion transformer. arXiv preprint, 2504.05741, 2025b. https://arxiv.org/abs/2504.05741. Xu et al. [2023] Hu Xu, Saining Xie, Xin Tan, Po-Yao Huang, et al. Demystifying clip data. arXiv preprint arXiv:2309.16671, 2023. Yu et al. [2024] Lijun Yu, José Lezama, Nitesh B. Gundavarapu, Luca Versari, Kihyuk Sohn, David Minnen, Yong Cheng, Agrim Gupta, Xiuye Gu, Alexander G. Hauptmann, Boqing Gong, Ming-Hsuan Yang, Irfan Essa, David A. Ross, and Lu Jiang. Language model beats diffusion – tokenizer is key to visual generation. In International Conference on Learning Representations, 2024. https://arxiv.org/abs/2310.05737. Yu et al. [2025a] Sihyun Yu, Sangkyung Kwak, Huiwon Jang, Jongheon Jeong, Jonathan Huang, Jinwoo Shin, and Saining Xie. Representation alignment for generation: Training diffusion transformers is easier than you think. In International Conference on Learning Representations, 2025a. https://arxiv.org/abs/2410.06940. Yu et al. [2025b] Yongsheng Yu, Wei Xiong, Weili Nie, Yichen Sheng, Shiqiu Liu, and Jiebo Luo. Pixeldit: Pixel diffusion transformers for image generation. arXiv preprint arXiv:2511.20645, 2025b. Zhai et al. [2023] Xiaohua Zhai, Basil Wang, Alexander Kramer, et al. Sigmoid loss for language image pre-training. arXiv preprint arXiv:2303.15343, 2023. Zhang et al. [2018] R. Zhang, P. Isola, A. Efros, E. Shechtman, and O. Wang. The unreasonable effectiveness of deep features as a perceptual metric. In Conference on Computer Vision and Pattern Recognition, 2018. https://arxiv.org/abs/1801.03924. Zhao et al. [2026] Zelin Zhao, Petr Molodyk, Haotian Xue, and Yongxin Chen. Laplacian multi-scale flow matching for generative modeling. arXiv preprint arXiv:2602.19461, 2026. Zheng et al. [2026] Boyang Zheng, Nanye Ma, Shengbang Tong, and Saining Xie. Diffusion transformers with representation autoencoders. In International Conference on Learning Representations, 2026. https://openreview.net/forum?id=0u1LigJaab. Contents of Appendix Appendix A Implementation details A.1 Training and inference Training. Unless otherwise noted, we follow the JiT [25] training recipe verbatim, changing only the items required by our wavelet formulation. Concretely: 600 epochs, 5 warmup epochs, Adam (β1,β2=0.9,0.95 _1, _2=0.9,0.95), batch size 1024, learning rate 2×10−42\!×\!10^-4 with constant schedule, weight decay 0, EMA decay 0.999, logit-normal time sampler logit(t)∼(μ,σ2)logit(t) (μ,σ^2) with μ=−0.8,σ=0.8μ=-0.8,σ=0.8, noise scale 1.0×image size/2561.0×image size/256, (1−t)(1-t)-division clip of 0.050.05, and class-token drop probability 0.10.1 for CFG. Video preprocessing. For video experiments, frames are decoded at a target sampling rate of 8 FPS with a random temporal offset during training. Each frame is center-cropped to a square using the shorter spatial side and then resized to the target resolution (128×128128×128) via bilinear interpolation with antialiasing. A random horizontal flip is applied during training. This crop-then-resize ordering selects the same spatial region as the resize-then-crop convention used in prior work [13, 15], ensuring comparability of FVD scores. Inference. For class- and text-conditioned image sampling we again follow the JiT setup: Heun ODE solver with 50 steps on a linear grid in [0,1][0,1], and CFG interval [0.1,1][0.1,1]. The CFG scale is swept in [1.0,5.0][1.0,5.0] with increment 0.10.1 for class-conditional image generation, and in [1.0,10.0][1.0,10.0] with increment 0.50.5 for text-to-image generation. The two parameters specific to our two-phase schedule (Section 3.3) are tuned by sweeping α∈1,2,3α∈\1,2,3\ and m∈1,2m∈\1,2\ and selecting the best per setting. Model configurations. We use the standard JiT/DiT family of transformer backbones across all model scales. Architectural hyperparameters are summarized in Table˜9. WaiT inherits the exact same backbone for each scale and adds only the resolution embedding (Section˜3.2); the parameter counts therefore match JiT to within <0.1%<0.1\%. Hyperparameter B L XL H G Depth 12 24 28 32 40 Hidden dim 768 1024 1152 1280 1664 Heads 12 16 16 16 16 Head dim 64 64 72 80 104 MLP hidden (SwiGLU, 4×4\!×) 3072 4096 4608 5120 6656 Bottleneck dim 128 128 192 256 256 Dropout (attn / proj) 0.0 0.0 0.0 0.2 0.2 In-context start block 4 8 8 10 10 Parameters 133M 462M 686M 956M 2B Table 9: Model configurations for JiT and WaiT backbones at scales B/L/XL/H/G. All variants use in-context length =32=32 class tokens (when in-context conditioning is enabled). Image size is 256×256256×256 (or 512×512512×512/1024×10241024×1024 depending on the experiment); patch size is image-size/16/16 for the larger-patch variant and image-size/8/8 for the smaller-patch variant (e.g. at 512×512512×512 this gives patch size 3232 or 6464, respectively). Pseudo code. For reproducibility, we provide pseudocode for both the standard JiT baseline and our Wavelet-aware image Transformer extension, side by side, for both training in Table˜10 and sampling in Table˜11. Standard JiT (Baseline) Wavelet-aware image Transformer (Ours) Input: image x, label y Input: image x, label y, threshold t∗t^*, scale SLFS_LF 1. Sample t∼(ϵ,1−ϵ)t (ε,1-ε) 1. Sample tLF∼(0,1)t_LF (0,1) 2. ε∼(0,I) (0,I) 2. xLF,xHF=DWT(x)x_LF,x_HF=DWT(x) 3. z=t⋅x+(1−t)⋅εz=t· x+(1-t)· 3. x~LF=xLF/SLF x_LF=x_LF\,/\,S_LF — Phase 0 (coarse, H/2×W/2H/2× W/2) — 4. x^=fθ(z,t,y) x=f_θ(z,t,y) 4. εc∼(0,I) _c (0,I) 5. v=(x−z)/(1−t)v=(x-z)/(1-t) 5. zc=tLF⋅x~LF+(1−tLF)⋅εcz_c=t_LF· x_LF+(1-t_LF)· _c 6. v^=(x^−z)/(1−t) v=( x-z)/(1-t) 6. x^LF=fθ(zc,tLF,y,res=0) x_LF=f_θ(z_c,t_LF,y, res=0) 7. ℒ=‖v−v^‖2L=\|v- v\|^2 7. ℒc=‖x^LF−x~LF‖2/(1−tLF)2L_c=\| x_LF- x_LF\|^2/(1-t_LF)^2 — Phase 1 (fine, H×WH× W) — 8. Sample tLF′∼(t∗,1)t _LF (t^*,1) 9. εLF∼(0,I) _LF (0,I), εHF∼(0,I) _HF (0,I) 10. zLF=tLF′⋅x~LF+(1−tLF′)⋅εLFz_LF=t _LF· x_LF+(1-t _LF)· _LF tHF=(tLF′−t∗)/(1−t∗)t_HF=(t _LF-t^*)/(1-t^*) 11. zHF=tHF⋅xHF+(1−tHF)⋅εHFz_HF=t_HF· x_HF+(1-t_HF)· _HF 12. zf=IDWT(zLF⋅SLF,zHF)z_f=IDWT(z_LF· S_LF,\;z_HF) 13. x^=fθ(zf,tLF′,y,res=1) x=f_θ(z_f,t _LF,y, res=1) 14. (x^LF,x^HF)=DWT(x^)( x_LF, x_HF)=DWT( x) 15. ℒf=‖x^LF/SLF−x~LF‖2(1−tLF′)2+‖x^HF−xHF‖2(1−tHF)2L_f= \| x_LF/S_LF- x_LF\|^2(1-t _LF)^2+ \| x_HF-x_HF\|^2(1-t_HF)^2 Return: ℒL Return: ℒc,ℒfL_c,\;L_f Table 10: Training pseudocode comparison. Left: standard flow-matching (JiT baseline). Right: our Wavelet-aware image Transformer extension. Both phases are packed into a single forward pass via FlashAttention’s variable-length interface; fθf_θ is the shared model. SLFS_LF: 95th-percentile normalization constant (Section 3.1). εc,εLF,εHF _c, _LF, _HF: independent standard Gaussian noise samples. Standard JiT (Baseline) Wavelet-aware image Transformer (Ours) Input: labels y, steps K, CFG w Input: labels y, steps K, CFG w, t∗t^*, shift α, multiplier m, scale SLFS_LF — Step schedule — 1. ti=linspace(0,1,K+1)\t_i\=linspace(0,1,K+1) 1. Apply shift: t′=tα/(tα+(1−t)α)t =t^α/(t^α+(1-t)^α) 2. Split at t∗t^*: K1,K2K_1,K_2 via multiplier m 2. z∼(0,I)z (0,I) [H×WH× W] 3. z∼(0,I)z (0,I) [H/2×W/2H/2× W/2] — Phase 0 (t=0→t∗t=0→ t^*, coarse, normalized LF only) — 3. for i=0i=0 to K−1K-1: 4. for i=0i=0 to K1−1K_1-1: x^=(1+w)fθ(z,ti,y)−wfθ(z,ti,∅) x=(1+w)f_θ(z,t_i,y)-wf_θ(z,t_i, ) x^LF=(1+w)fθ(z,ti,y,0)−wfθ(z,ti,∅,0) x_LF=(1+w)f_θ(z,t_i,y,0)-wf_θ(z,t_i, ,0) v=(x^−z)/(1−ti)v=( x-z)/(1-t_i) v=(x^LF−z)/(1−ti)v=( x_LF-z)/(1-t_i) z←z+(ti+1−ti)⋅vz← z+(t_i+1-t_i)· v z←z+(ti+1−ti)⋅vz← z+(t_i+1-t_i)· v — Transition at t∗t^*: un-normalize LF, inject fresh HF noise — 5. zLF=z⋅SLFz_LF=z· S_LF 6. zHF∼(0,I)z_HF (0,I) [HF resolution] 7. z=IDWT(zLF,zHF)z=IDWT(z_LF,z_HF) [H×WH× W, pixel space] — Phase 1 (t∗→1t^*→ 1, fine, joint LF + HF in pixel space) — 8. for i=K1i=K_1 to K−1K-1: x^=(1+w)fθ(z,ti,y,1)−wfθ(z,ti,∅,1) x=(1+w)f_θ(z,t_i,y,1)-wf_θ(z,t_i, ,1) (zLF,zHF)=DWT(z)(z_LF,z_HF)=DWT(z), (x^LF,x^HF)=DWT(x^)( x_LF, x_HF)=DWT( x) tHF=(ti−t∗)/(1−t∗)t_HF=(t_i-t^*)/(1-t^*) vLF=(x^LF−zLF)/(1−ti)v_LF=( x_LF-z_LF)/(1-t_i) vHF=(x^HF−zHF)/(1−tHF)v_HF=( x_HF-z_HF)/(1-t_HF) zLF←zLF+(ti+1−ti)⋅vLFz_LF← z_LF+(t_i+1-t_i)· v_LF zHF←zHF+(ti+1−ti)⋅vHFz_HF← z_HF+(t_i+1-t_i)· v_HF z=IDWT(zLF,zHF)z=IDWT(z_LF,z_HF) Return: z Return: z Table 11: Sampling pseudocode comparison. Left: standard single-phase sampling. Right: our two-phase cascade. The model performs x-prediction internally. In Phase 1 the velocity is computed band-by-band because the LF and HF bands evolve on different schedules: vLF=(x^LF−zLF)/(1−tLF)v_LF=( x_LF-z_LF)/(1-t_LF) with tLF=t_LF=t, and vHF=(x^HF−zHF)/(1−tHF)v_HF=( x_HF-z_HF)/(1-t_HF) with tHF=(t−t∗)/(1−t∗)t_HF=(t-t^*)/(1-t^*). The model is fed the pre-DWT pixel-space state z, so each Phase-1 step takes a DWT to obtain (zLF,zHF,x^LF,x^HF)(z_LF,z_HF, x_LF, x_HF), advances each band along its own time, and applies an IDWT to return to pixel space (this is cheap since the DWT is a linear orthogonal transform). Phase 0 operates on 4×4× fewer tokens at H/2×W/2H/2× W/2 resolution. The transition at t∗t^* un-normalizes the LF state by SLFS_LF and re-initializes the HF bands as fresh (0,I)N(0,I) noise (matching the distribution of εHF _HF at training time, which the model expects to see when tHF=0t_HF=0). Heun steps can replace Euler (doubles NFE). A.2 Step Allocation Parametrization Here we make precise the two knobs (α,m)(α,m) used in Section˜3.3 to split a budget of K ODE steps between the coarse Phase 0 (t∈[0,t∗]t∈[0,t^*]) and the fine Phase 1 (t∈[t∗,1]t∈[t^*,1]). Timestep shift. Following SD3 [9] and Flux [2], we start from a uniform grid ti=i/Kt_i=i/K for i=0,…,Ki=0,…,K and apply the shift ti′=tiαtiα+(1−ti)α,α≥1.t _i\;=\; t_i^αt_i^α+(1-t_i)^α, α≥ 1. At α=1α=1 the grid is uniform; larger α concentrates points near t=0t=0, where the signal first emerges from noise. Let K1α=|i:ti′<t∗|K^α_1=|\i:t _i<t^*\| denote the natural number of shifted steps falling into Phase 0. Phase 0 multiplier. The shifted split is then reweighted by a multiplier m≥1m≥ 1: K1=min(K,round(m⋅K1α)),K2=K−K1,K_1\;=\; \! (K,\;round\! (m· K^α_1 ) ), K_2\;=\;K-K_1, where K1K_1 (K2K_2) is the number of steps actually allocated to Phase 0 (Phase 1). Phase 0 steps are then placed on the shifted grid restricted to [0,t∗][0,t^*] (rescaled to use exactly K1K_1 steps), and analogously for Phase 1 on [t∗,1][t^*,1]. Setting m=1m=1 recovers the natural split induced by α alone; larger m pushes more steps into the cheaper Phase 0. Values used in our experiments. Unless otherwise noted we use t∗=0.25t^*=0.25 throughout. Across all experiments we sweep α∈1,2,3α∈\1,2,3\ and select the best per setting, while the Phase 0 multiplier is fixed to m=2m=2. A.3 Band Normalization This section provides additional details on the normalization scheme summarized in Section 3.1. A practical but critical detail for stable training is the normalization of wavelet bands. The DWT redistributes signal energy unevenly across bands: for the orthonormal Haar wavelet, the LF (low-frequency) band computes the energy-normalized sum of 2×22× 2 pixel blocks, producing values in [-2,2][-2,2] when the input is normalized to [-1,1][-1,1]. The HF detail bands, by contrast, capture differences and are naturally small-valued (typical standard deviation ∼0.05 0.05–0.190.19). This dynamic range mismatch means the flow-matching interpolation zt=t⋅x+(1−t)⋅ϵz_t=t· x+(1-t)·ε operates in different regimes for each band if left unnormalized. Choice of normalization constant. We use the 95th percentile (p95p_95) of the absolute LF coefficient values, computed empirically over the training set: SLF=Quantile0.95(|xLF|),S_LF=Quantile_0.95 (\,|x_LF|\, ), where the quantile is taken over all spatial positions and all training images. This is computed once per dataset as a preprocessing step. We prefer p95p_95 over the maximum because the maximum is sensitive to rare outlier images, leading to an overly conservative scale that compresses the effective dynamic range. The p95p_95 percentile provides a robust estimate that maps the vast majority of LF values to [-1,1][-1,1], with only 5% of values slightly exceeding this range, a negligible effect that the network learns to handle. Compared to standard deviation normalization, p95p_95 better preserves the bounded structure of the data distribution, avoiding the heavy tails that arise from std-based scaling. Dataset-specific values. In practice, we pre-compute SLFS_LF for each (dataset, resolution, wavelet filter) combination. For example, SLF=1.94S_LF=1.94 for ImageNet 256×256 with the Haar wavelet, and SLF=1.95S_LF=1.95 for OpenImages 512×512 (the normalization constant is dataset-specific as the frequency content distribution varies across datasets). However, SLFS_LF is remarkably stable across datasets of similar content, and the method is not sensitive to small perturbations in its value. This formulation yields a remarkably simple recipe: replace standard flow-matching with band-specific schedules in wavelet space, normalize the LF band by its empirical p95p_95, and inherit the entire unchanged JiT training and sampling pipeline. In our preliminary analysis we experimented with applying an analogous per-band normalization to the HF coefficients, but did not observe any consistent benefit on the datasets considered here. We attribute this to the relatively small dynamic range and well-behaved sparsity of HF coefficients in natural images at the resolutions we study, which already match the unit-variance noise schedule reasonably well. We expect this picture may change for substantially larger or more diverse datasets whose high-frequency power spectra and tail behavior differ markedly from natural images (e.g., synthetic, scientific, or highly textured imagery), where an HF normalization analogous to SLFS_LF could yield further stability and quality gains. Ablation of the normalization scheme. We compare LF normalization choices—none, p95p_95/p99p_99 percentile, maximum, and standard-deviation scaling (all computed globally over the training set)—across pixel and latent spaces, multiple datasets, and up to three DWT levels (Table˜12). Percentile scaling (p95p_95/p99p_99) is consistently best; removing normalization degrades performance in every setting, and standard-deviation scaling is worst (its heavy tails skew the variance). We therefore adopt p95p_95. The strong sensitivity in the latent-space (DDT) and 33-level settings confirms that normalization is a fundamental requirement across architectures, not a pixel-space-specific detail. Table 12: Ablation of the LF normalization scheme (FID, lower is better; p95p_95, ours, in bold). Setting No norm. p95p_95 p99p_99 Max Std. ImageNet 512, pixel, B/16 (FID-50k) 3.89 3.26 3.31 3.35 4.72 ImageNet 512, latent DDT (FID-50k) 3.53 1.33 1.37 1.36 5.71 OpenImages 512, two levels, L/16 (FID-5k) 17.98 15.10 15.10 15.23 20.32 OpenImages 1024, three levels, L/32 (FID-5k) 16.14 10.11 10.32 10.72 27.12 Appendix B Mutual Information Estimation The mutual information curves in Figure˜3 measure, for a single time step t, how much information the noisy wavelet coefficients carry about the clean ones. We use a simple, model-agnostic plug-in histogram estimator. Wavelet decomposition. For an image (or a state along a generative trajectory) we apply a single-level orthonormal Haar DWT, which yields one coarse band c∈ℝD/4c ^D/4 (LF) and three detail bands stacked into a single fine vector f=[LH;HL;H]∈ℝ3D/4f=[LH;HL;H] ^3D/4. We work directly with the flattened coefficient vectors, treating the different HF channels as independent draws of the same random variable. Plug-in MI estimator. Given two scalar samples X=xii=1NX=\x_i\_i=1^N and Y=yii=1NY=\y_i\_i=1^N obtained by concatenating coefficients across many spatial positions (and, for the backward setting, across many trajectories), we form a 2D histogram with K=64K=64 uniform bins per axis to obtain a discrete joint distribution p^(x,y) p(x,y) together with the marginals p^(x),p^(y) p(x), p(y). The mutual information is then estimated as MI^(X,Y)=∑x,y:p^(x,y)>0p^(x,y)logp^(x,y)p^(x)p^(y). MI(X,Y)\;=\; _x,y\,:\, p(x,y)>0 p(x,y) p(x,y) p(x)\, p(y). We apply this estimator independently to the coarse pair (ct,c1)(c_t,c_1) and the fine pair (ft,f1)(f_t,f_1), where c1,f1c_1,f_1 are the clean (or final) wavelet coefficients and ct,ftc_t,f_t are the noisy ones at step t. Forward (real images, top panel). We sample ϵ∼(0,I)ε (0,I), form xt=tx1+(1−t)ϵx_t=t\,x_1+(1-t)ε, take the Haar DWT, and compute MI^(ct,c1) MI(c_t,c_1) and MI^(ft,f1) MI(f_t,f_1) at a uniform grid of 41 timesteps in [0,1][0,1]. Here x1x_1 are 5050 real images randomly sampled from ImageNet at 256×256256×256 resolution, and we average each MI over these images and over independent noise draws to reduce variance. Backward (generated images, bottom panel ). For JiT, we cache the intermediate trajectory states across a large set of generated images. For each saved timestep we treat the model’s final sample (last step) as x1x_1 and the current step as xtx_t, decompose both, and concatenate coefficients across all images before computing MI^(c1,ct) MI(c_1,c_t) and MI^(f1,ft) MI(f_1,f_t). This pools the empirical joint distribution over many spatial positions and many trajectories, yielding a single MI value per band per step. Concretely, the curves in the bottom panel of Figure˜3 are obtained by averaging over 50 generated samples of the golden retriever class from a JiT-B/32 model trained on ImageNet 512×512512×512. Crossover threshold. In both panels the dashed vertical line and star mark the smallest t at which the fine-band MI first exceeds 0.010.01 nats. Appendix C Evaluation metrics: 5-crop FID and high-frequency FWD Both metrics are designed to evaluate generation quality at native resolution, avoiding the aggressive 299×299299×299 downsampling of standard FID that destroys exactly the high-frequency content WaiT is built to model. 5-crop FID (5cFID). Instead of resizing each image, we extract five 299×299299×299 patches at the native resolution – the four corners and the center – and pass each patch through InceptionV3 to obtain its 20482048-d feature. Features from all crops of all generated images are pooled into a single set, from which we estimate the Gaussian mean and full covariance and compute the standard Fréchet distance against precomputed reference statistics for the matching (dataset, resolution, crop strategy). We applied the same protocol to alternative crop variants (center-only, four-corner, and a random crop with a fixed seed) and found the relative ranking of methods to be unchanged across all of them; we therefore report only the 5-crop variant in the paper. High-frequency FWD (hFWD). The Fréchet Wavelet Distance [40] replaces InceptionV3 features with a wavelet-packet decomposition. We apply a level-44 Haar wavelet packet transform, which splits the image into 44=2564^4=256 packets ordered from low to high frequency: packet 0 is the pure low-pass (DC) packet, and the remaining 255255 packets cover progressively finer frequency mixtures. Each packet is reduced to a compact descriptor (global average pooling per channel, or a small adaptive pool for larger packets), and we maintain a streaming estimate of its mean and covariance across the dataset using a numerically stable batch update in float64; in distributed evaluation these are aggregated across ranks before the final statistics are formed. A Fréchet distance is then computed independently per packet between the generated and reference statistics. The overall FWD is the average across all 256256 packets; high-frequency FWD (hFWD) drops packet 0 and averages over the remaining 255255 packets, isolating texture fidelity from the LF content already captured by FID. Per-packet distances can also be inspected individually for fine-grained analysis. Appendix D Additional results D.1 Additional Ablations in ImageNet 256 resolution Here we provide ablation results summarized in Table 4(c) of the main text. For these ablations we use JiT-B/16 models trained on ImageNet 256 resolution for 1k epochs. In Table˜13 we compare the different noise schedules visualized in Figure˜4(a). Our Delayed Linear schedule eliminates the train-test discrepancy, achieving the best 5cFID and the best balance between FID and efficiency. Note that, unlike the cumulative ablation in Figure˜4(c) of the main text—which starts from a naïve two-stage baseline (t∗=0.5t^*=0.5, coarse trained only on [0,t∗][0,t^*]) and adds one improvement per row—each schedule in Table˜13 is reported with its own tuned setting (best t∗t^* and global coarse training). On top of the two schedules already discussed in the main text (Discontinuous and Delayed Linear), we also experimented with two additional variants: Cascaded (super-resolution) and Mixed which we report here for completeness. We briefly describe all four schedule variants below; they are visualized in Figure˜8: • Discontinuous: A naive two-stage cascade in the spirit of PixelFlow [4] and Pyramidal Flow [21]. The LF band is denoised on [0,t∗][0,t^*], then at t∗t^* HF noise is injected and both bands are jointly denoised on [t∗,1][t^*,1]. The hard handoff at t∗t^* creates a train–test mismatch (the HF band is unseen at exactly the noise level injected at inference). • Delayed Linear (ours): The LF band follows the standard linear schedule on [0,1][0,1], while the HF band stays as pure noise until t∗t^* and then linearly interpolates from noise to data on [t∗,1][t^*,1]. By construction the HF distribution at t∗t^* is exactly (0,I)N(0,I), eliminating the discontinuity. • Cascaded (super-resolution): A fully separate two-model cascade: the LF model is trained on [0,t′][0,t ] at low resolution, and a second HF/super-resolution model is trained on [t′,1][t ,1]. The two models share no parameters and the HF model never sees a noisy LF input, mirroring classical cascaded super-resolution diffusion [17]. Critically, LF and HF are denoised strictly sequentially: HF only starts once LF is fully clean. • Mixed: LF and HF follow parallel linear schedules but with different start times; LF begins at t=0t=0 and reaches data at t′t , while HF waits until t′<t′t <t and then climbs in parallel to LF, reaching data at t=1t=1. The key difference from Cascaded is the overlap window [t′,t′][t ,t ] during which both bands are simultaneously partially noisy and are denoised jointly, allowing HF generation to be conditioned on a still-noisy LF context (rather than waiting for a fully clean LF as in the Cascaded variant). A figure visualizing all four schedules is provided in Figure˜8. Figure 8: Multi-resolution schedule variants compared in Table˜13. Blue: LF band signal coefficient; Red: HF band signal coefficient. Our Delayed Linear schedule (green title) is the only variant in which the HF band is, by construction, exactly pure (0,I)N(0,I) noise at t∗t^*, removing the train–test discontinuity present in the other variants. Table 13: Comparison of multi-resolution schedules. Evaluated on ImageNet 256×256 using a JiT-B/16 backbone. GFLOPs and savings relative to JiT baseline. Schedule FID (↓ ) 5cFID (↓ ) GFLOPs Savings Baseline (JiT-B/16) 3.60 9.12 100% 0% Discontinuous 3.41 8.92 70% 30% Cascaded 4.50 10.72 75% 25% Mixed 4.20 10.38 75% 25% Delayed linear (ours) 3.50 8.38 50% 50% In Table˜14 we consider the effect of changing the transition threshold t∗t^*. We find that t∗=0.25t^*=0.25 strikes a good tradeoff between (cropped) FID and compute savings. Table 14: Sensitivity to transition threshold t∗t^*. Evaluated on ImageNet 256×256 using a JiT-B/16 backbone. GFLOPs and savings relative to JiT baseline. Threshold t∗t^* FID (↓ ) 5cFID (↓ ) GFLOPs Savings 0.10 3.48 8.41 88% 12% 0.25 (ours) 3.50 8.38 50% 50% 0.40 4.25 9.12 32% 68% 0.50 4.92 11.45 25% 75% In our final ablation in Table˜15 we consider whether the coarse training is performed over the full [0,1][0,1] interval or only from 0 to t∗t^*. We find that training the coarse stage over the full [0,1][0,1] interval leads to best results, improving coarse image structure captured in FID as well as the details captured by the cropped FID. We speculate that exposing the model to LF tokens across the entire trajectory by including the regime t>t∗t>t^* where it is also conditioned on noisy HF inputs may help it implicitly learn the relationship between coarse and fine frequency content, rather than treating the LF band as an isolated subproblem. Table 15: Ablation of coarse training range. Evaluated on ImageNet 256×256 using a JiT-B/16 backbone. GFLOPs and savings relative to JiT baseline. Training Range (Coarse) FID (↓ ) 5cFID (↓ ) Restricted [0,t∗][0,t^*] 4.81 10.28 Full [0,1][0,1] (ours) 3.50 8.38 Sensitivity to the wavelet family. We ablate the wavelet basis on ImageNet-256 with a JiT-B/16 backbone at t∗=0.25t^*=0.25 (Table˜16). Performance is stable across families (within 0.190.19 FID); we adopt Haar throughout for its simplicity—it is orthogonal, lossless, has minimal spatial support, and its L band is a clean 2×22× 2 average pool—and note that the strong results of wider-support bases (CDF 9/7, Symlet) show this image-like property is not required for WaiT to work. Table 16: Sensitivity to the wavelet family (ImageNet-256, JiT-B/16, t∗=0.25t^*=0.25). Wavelet Haar CDF 5/3 CDF 9/7 Db2 Symlet FID (↓ ) 3.50 3.48 3.53 3.62 3.67 D.2 Perceptual validation of the evaluation metrics To confirm that 5cFID and hFWD capture human perception rather than wavelet-domain bias, we evaluate them on the PIPAL benchmark [12], which pairs ground-truth images with high-frequency distortions mirroring generative failure modes (super-resolution errors, blur, noise, GAN artifacts) and provides ∼1.13 1.13M human Elo judgments across 116116 distortion groups. For each metric we report the Pearson (PLCC, linear) and Spearman (SRCC, rank-order) correlations with human preference (Table˜17). Both show strong, statistically significant agreement (Holm–Bonferroni-corrected and permutation-tested, p<4×10−4p<4× 10^-4), confirming that WaiT’s metric gains reflect genuine perceptual improvements rather than overfitting to the wavelet domain. Table 17: Correlation of 5cFID and hFWD with human preference on PIPAL. Metric |PLCC||PLCC| PLCC p-value |SRCC||SRCC| SRCC p-value 5cFID 0.695 <4.7×10−18<4.7× 10^-18 0.656 <1.38×10−15<1.38× 10^-15 hFWD 0.708 <6.69×10−19<6.69× 10^-19 0.663 <5.15×10−16<5.15× 10^-16 D.3 ImageNet 512 resolution In Figure˜9 we provide samples for ImageNet 512 resolution class-conditional generations. Figure 9: Uncurated class-conditional samples from WaiT-H/16, ImageNet 512×512. Each row shows eight samples from a single class. From top to bottom: macaw, lion, bee, red panda, balloon, castle, ice cream, strawberry, cliff, volcano, daisy. In Figure˜10 we compare samples generated with WaiT, JiT and RAE for ImageNet 512 resolution class-conditional generations. Figure 10: Single-class comparison (lighthouse) across methods on ImageNet 512×512. Top: WaiT-H/32 (ours). Middle: JiT baseline. Bottom: RAE latent-space model. Four different samples per method, each with zoomed-in crops of distinctive regions (sea, sky, texture, rocks). Figure˜11 shows the full-resolution starfish samples that complement the cropped comparison in Figure˜5 of the main text. Figure 11: Full-resolution starfish samples on ImageNet 512×512. From left to right: WaiT-H/32 (ours), JiT baseline, RAE. D.4 OpenImages Figure˜12 shows the Pareto fronts for WaiT and the JiT baseline across all model scales on OpenImages 512 resolution (train FID over 5k samples). The WaiT Pareto front (green, solid) dominates the one for the JiT baseline (blue, dashed), achieving the same or better performance at 2× lower compute. Figure 12: OpenImages 512×512 Pareto fronts (5k train FID): FID, 5-Crop FID, and hFWD. WaiT (green triangles, solid line) dominates the JiT baseline (blue circles, dashed line) across all metrics and model scales, with the largest gap on high-frequency metrics. OpenImages 1024×1024 Pareto fronts are shown in the teaser (Figure˜1). In Figure˜6 (top) we show wavelet coefficient distributions for OpenImages at 512 resolution. In Figure˜13 we provide samples from WaiT for OpenImages at 512 resolution. In Figure˜14 we show more WaiT samples and compare to JiT and RAE. Figure˜15 compares WaiT and JiT using four samples for a single class. Figure 13: Uncurated WaiT-H/32 samples on OpenImages 512×512. Each row shows four samples from a single class. From top to bottom: butterfly, grass, leaf, rock, spider, twig. Figure 14: Qualitative comparison on OpenImages 512×512. Each cell shows the generated image with two zoomed-in crops. Top: WaiT-H/32 (ours). Bottom: JiT baseline. Columns: brick, feather, insect, whiskers. Figure 15: Single-class comparison on OpenImages 512×512. Four samples from the class stained glass for WaiT-H/32 (top) and JiT baseline (bottom). In Figure˜16 we provide samples from WaiT for OpenImages at 1024 resolution. Figure˜17 compares WaiT and JiT using four samples for a single class. Finally, in Figure˜6 (bottom) we compare the wavelet coefficient distributions of samples from WaiT and JiT, as well as real images. Figure 16: Uncurated samples from WaiT-H/64 for OpenImages 1024×1024. Each row shows four samples from a single class, from top to bottom: car, duck, rose, sculpture, waterfall, airplane. Figure 17: Single-class comparison on OpenImages 1024×1024. Samples for the class palm tree for WaiT-H/64 (ours, top), and JiT-H/64 baseline (bottom). Figure 18: Qualitative comparison on OpenImages 1024×1024. Each cell shows the generated image with two zoomed-in crops. Top: WaiT-H/64 (ours). Bottom: JiT-H/64 baseline. Columns: car, cattle, cat, castle. WaiT produces sharper textures (e.g., cattle fur, cat whiskers) alongside better global structure. D.5 Text-to-image samples (extended captions) This subsection spells out the per-column / per-row details of the text-to-image figures and provides the additional uncurated samples. Figure˜7 (main text). Both rows show 1024×1024 generations from H/32 models on a held-out evaluation set; the top row is the JiT-H/32 baseline and the bottom row is our WaiT-H/32. The eight columns correspond to two encoder pipelines: Columns 1–4 use the SigLIP + Qwen3-VL + T5-v1.1-XXL pipeline (25 training epochs, CFG 5.0). Columns 5–8 use the MetaCLIP + Llama 3.1 + Llama 3.2 Vision pipeline (25 training epochs). Within each pipeline the four columns show the same set of prompts for the baseline and our method, so column-wise comparisons are like-for-like. The prompts (left to right) are: • Col 1 (SigLIP): “a hummingbird hovering in front of a fuchsia flower, wings frozen mid-beat”. • Col 2 (SigLIP): “a Venetian gondolier in a striped shirt rowing through a narrow canal at sunset”. • Col 3 (SigLIP): “the interior of a grand Moorish palace with intricate geometric tile work”. • Col 4 (SigLIP): “a stack of fluffy pancakes with maple syrup dripping down the sides”. • Col 5 (MetaCLIP): “A solitary lighthouse on a rocky cliff during a thunderstorm, waves crashing below, lightning in the background”. • Col 6 (MetaCLIP): “A detailed macro photograph of a peacock feather with iridescent blue and green patterns”. • Col 7 (MetaCLIP): “A hand-painted ceramic bowl filled with fresh berries, morning dew still visible on them”. • Col 8 (MetaCLIP): “A street in Havana with colorful vintage cars, pastel colonial buildings, and palm trees”. Figure˜19 (additional samples). Same setup as Figure˜7, on the remaining columns not shown in the main text. Columns 1–3: SigLIP + Qwen3-VL + T5-v1.1-XXL. Columns 4–6: MetaCLIP + Llama 3.1 + Llama 3.2 Vision. Top row: JiT-H/32 (baseline). Bottom row: WaiT-H/32 (ours). The prompts (left to right) are: • Col 1 (SigLIP): “a moose standing in a misty morning lake with autumn foliage in the background”. • Col 2 (SigLIP): “an endless glowing salt flat at dusk reflecting pink and orange clouds”. • Col 3 (SigLIP): “an ancient ruined temple completely overtaken by jungle roots”. • Col 4 (MetaCLIP): “A crystal clear mountain lake reflecting snow-capped peaks and a cloudless blue sky”. • Col 5 (MetaCLIP): “A freshly baked sourdough loaf on a wooden cutting board, steam rising from a torn piece”. • Col 6 (MetaCLIP): “A quaint English cottage with a thatched roof surrounded by a wildflower garden in full bloom”. Figure 19: Additional text-to-image samples at 1024×1024 (uncaptioned). See Section˜D.5 above for the per-column / per-row description. D.6 Video generation samples In Figure˜20 we provide unconditional samples from WaiT-B/8 trained on Taichi-HD. In Figure˜21 we provide samples for Kinetics-600. Figure 20: Unconditional Taichi-HD samples from our wavelet-aware image transformer WaiT-B/8 model (128x128, 16 frames). Figure 21: Samples of WaiT-B/8 trained on Kinetics-600. Conditioned on first 5 frames, generates 16. Appendix E Dataset Construction Details This section provides complete instructions to reproduce the OpenImages-512 (512×512512×512) and OpenImages-1024 (1024×10241024×1024) datasets used in this work, starting exclusively from the publicly available OpenImages V6 [24] data release. No pre-built dataset files need to be distributed; the entire pipeline is deterministic given the public source data and a fixed random seed. Note on script versions. The dataset used in this paper was produced with the parameters documented below. Table˜18 gives an overview of both datasets. Table 18: Dataset statistics for OpenImages-512 and OpenImages-1024. Property OI-512 OI-1024 Resolution 512×512512×512 1024×10241024×1024 Training images 848,746 942,360 Validation images 49,974 42,950 Classes 1,000 859 Val. balance 50/class 50/class Image format JPEG q=100q=100, 4:4:4 JPEG q=100q=100, 4:4:4 Approx. train size ∼267 267 GB ∼870 870 GB E.1 Source Data Both datasets are derived from the following publicly available components of OpenImages V6 (February 2020 release). All files are hosted by Google. Training images. ∼6,595,306 6,595,306 JPEG files, distributed across archive files train_0.tar through train_f.tar. After extraction, all images reside in a single flat directory ($IMAGE_DIR). Download instructions: https://storage.googleapis.com/openimages/web/download_v6.html Human-verified labels. oidv6-train-annotations-human-imagelabels.csv (∼57 57M rows). Columns: ImageID, Source, LabelName (Freebase MID), Confidence (0 or 1). We use only rows with Confidence=1 Confidence=1. https://storage.googleapis.com/openimages/v6/oidv6-train-annotations-human-imagelabels.csv Machine-generated labels. train-annotations-machine-imagelabels.csv (∼164 164M rows). Columns: ImageID, Source, LabelName, Confidence (float, e.g., 0.778). Critical: some redistributed versions have all confidences zeroed out; the original file with float values is required. Class descriptions. oidv6-class-descriptions.csv (∼19,995 19,995 classes) and class-descriptions-boxable.csv (601 classes, fallback). https://storage.googleapis.com/openimages/v6/oidv6-class-descriptions.csv https://storage.googleapis.com/openimages/v5/class-descriptions-boxable.csv E.2 OpenImages-512 Construction Stage 1: Manifest building 1. Class selection. All classes ranked by human-verified positive label count; top 1,000 selected. 2. Image assignment (rarest-first). Each multi-labeled image is assigned to its rarest valid class: argminc∈Ci|Sc| _c∈ C_i|S_c|. Tie-breaking: when multiple classes share the same count, Python’s stable sort preserves the order in which labels appear in the source CSV. Images are iterated in dictionary insertion order (order of first appearance in the CSV). Both behaviors are deterministic given the same input file and Python ≥3.7≥ 3.7. 3. Per-class cap at 1,280 images (≈ ImageNet’s 1,281/class). 4. Machine label supplementation. For classes below 1,280 images, machine-labeled images with confidence ≥0.90≥ 0.90 are added. Dynamic deduplication ensures each image is assigned to at most one class. 5. Thin-class retention. ∼103 103 classes remain below 1,280 (min ∼111 111); retained as-is. 6. Validation carve-out. 65 images/class (50 target ++ 15 buffer), random.seed(42). Buffer absorbs ∼6% 6\% resolution filter loss in Stage 2. Table 19: Manifest parameters for OpenImages-512. Parameter Value Number of classes 1,000 Max images per class 1,280 Machine label confidence ≥ 0.90 Validation target / buffer per class 50 / 15 Random seed 42 Stage 2: Image processing For each manifested image: 1. Resolution filter. Discard if min(w,h)<512 (w,h)<512 (strict ≥; the code is if min(w,h) < MIN_DIM). No upsampling. ∼6% 6\% filtered. 2. Convert to RGB (before resize; handles grayscale, CMYK, palette). 3. Resize shorter side to 512 px via Lanczos. 4. Center crop to 512×512512×512: left=⌊(w′−512)/2⌋ left= (w -512)/2 , top=⌊(h′−512)/2⌋ top= (h -512)/2 . 5. Save JPEG quality=100, subsampling=0 (4:4:4), icc_profile=None. Validation is capped at exactly 50/class after processing; surplus deleted. Final counts: 848,746 train, 49,974 val (2626 validation images short of 50,00050,000 were skipped due to corrupt/unreadable source files). E.3 OpenImages-1024 Construction The 1024 variant’s key architectural difference: resolution filtering occurs before class assignment, ensuring zero post-manifest filtering loss. Stage 1: Manifest building. Using only the 4.7M high-resolution images: 1. Class selection. Top 1,000 classes by human label count, counting only high-res images. 2. Image assignment. Rarest-first (identical to 512, including tie-breaking). 3. Per-class cap at 1,500 (increased from 1,280 to compensate for smaller pool). 4. Machine label supplementation. Flat threshold ≥0.70≥ 0.70 (lowered from 0.90). Candidates restricted to the high-res set and sorted by confidence (highest first) before assignment. 5. Thin-class pruning. Classes with <500<500 images are dropped → 141 removed, 859 classes remain. 6. Validation carve-out. 100/class (50 target ++ 50 buffer), random.seed(42). Table 20: Manifest parameters for OpenImages-1024. Parameter Value Initial class pool / final (after pruning) 1,000 / 859 Max images per class 1,500 Min images per class (pruning) 500 Min. source resolution 1,024 px (shortest side) Machine label confidence ≥ 0.70 Validation target / buffer per class 50 / 50 Random seed 42 Stage 2: Image processing (openimages1024_portable/process_openimages1024.py). Identical logic to the 512 variant at 1024×10241024×1024: verify min(w,h)≥1024 (w,h)≥ 1024 (should always pass), convert to RGB, Lanczos resize shorter side to 1024, center crop to 1024×10241024×1024, save JPEG q=100q=100 4:4:4, strip ICC. Validation capped at 50/class. Final counts: 942,360 train, 42,950 val (50×85950× 859). E.4 Summary of Differences Table 21: Comparison of OpenImages-512 and OpenImages-1024 construction. Aspect OI-512 OI-1024 Resolution filtering After manifest Before manifest Min. source resolution 512 px 1,024 px Candidate pool ∼6.6 6.6M ∼4.7 4.7M (71%) Final classes 1,000 859 Train / val images 848,746 / 49,974 942,360 / 42,950 Max / min per class 1,280 / — 1,500 / 500 Machine conf. ≥ 0.90 0.70 Machine-labeled frac. ∼28% 28\% ∼36% 36\% Post-manifest filter loss ∼6% 6\% ∼0% 0\% Shared: seed=42=42; JPEG q=100q=100, 4:4:4; Lanczos + center crop; 50 val/class; rarest-first assignment; class ranking by human labels only. E.5 Design Rationale Why OpenImages? ImageNet images are predominantly small (256–512 px), heavily compressed, and subject to licensing restrictions. OpenImages V6 provides 6.6M images at high native resolution (median shortest side ∼1,936 1,936 px) under a C license. Near-lossless JPEG. Quality=100=100 with 4:4:4 chroma achieves PSNR >50>50 dB vs. original, ∼30% 30\% smaller than PNG. No upsampling. Upsampled images contain synthetic high-frequency content from interpolation artifacts, corrupting the training signal for high-frequency generation. Lanczos interpolation. Sharpest standard resampling filter; bilinear/bicubic attenuate high frequencies more aggressively. Rarest-first. Prevents common classes (e.g., “Person,” 1.7M labels) from absorbing multi-labeled images that also belong to rarer categories. Lower confidence at 1024. Pool shrinks to 71%; threshold lowered from 0.90 to 0.70 to compensate, still preferring highest-confidence candidates (sorted before assignment). Class pruning at 1024. 141 classes have <500<500 high-res images: too few for reliable training. Pruning yields a cleaner 859-class dataset. At 512, even the thinnest class has ∼111 111 images, which is workable. E.6 Text-to-image dataset construction We build the 1024×10241024× 1024 text-to-image corpus entirely from publicly available sources using publicly available models; no proprietary data, annotations, or APIs are involved, so the corpus can be reconstructed from scratch. We start from three public sources: SA-1B [23], the DataComp (Mitigated) subset [11], and OpenImages [24]. The pipeline has four stages. We describe the SigLIP + Qwen3-VL + T5 configuration; the second (MetaCLIP + Llama) configuration is identical with the corresponding models substituted. Stage 1 (resolution filter). We scan all sources and keep only images whose shorter side is at least 10241024 pixels, parsing image headers without decoding pixels. SA-1B and DataComp form the backbone of the corpus. Stage 2 (aesthetic and watermark scoring). Each surviving image is scored zero-shot with a public vision–language model (SigLIP 2, google/siglip2-large-patch16-384; MetaCLIP in the second pipeline). For each of the two concepts we use a small set of positive and negative text prompts, take the mean image–text cosine similarity per side, and apply a softmax with the model’s native logit scale to obtain a probability in [0,1][0,1]: • Aesthetic—positive: “a beautiful high quality photograph”; “a professional photograph with great composition”; “an aesthetically pleasing image with good lighting”. Negative: “a low quality blurry photograph”; “an ugly poorly composed image”; “a low resolution amateur snapshot”. • Watermark—positive: “an image with a watermark”; “a photo with text overlay”; “an image with a logo watermark”; “a stock photo with watermark text”. Negative: “a clean photograph without watermarks”; “a natural photo without text overlay”. We then retain images with aesthetic_prob>0.05aesthetic\_prob>0.05 and watermark_prob<0.80watermark\_prob<0.80, leaving the curated corpus of ∼40 40M images reported in Section˜4.3. Stage 3 (captioning). Each retained image is resized to 448×448448× 448 and captioned by a public VLM (Qwen3-VL-30B-A3B-Instruct; Llama-3.2-Vision in the second pipeline) with greedy decoding (max_new_tokens=160 max\_new\_tokens=160, target ∼60 60 words) and the prompt: “Describe this image in a single vivid paragraph of approximately 60 words. Focus on the main subject, its attributes, the setting or background, colors, lighting, composition, and overall mood. Do not use bullet points. Do not add preamble like ‘This image shows’; go straight to the description.” Stage 4 (packaging). SA-1B and OpenImages are repacked at 1024×10241024× 1024 (short-edge resize then center crop, JPEG quality 85) together with their captions into WebDataset shards; DataComp is streamed from its original tars at training time and joined to its captions. Text conditioning. At training time captions are encoded on the fly by a frozen text encoder (T5-v1.1-XXL; Llama-3.1 in the second pipeline) with a maximum length of 128128 tokens, and a cached null-caption embedding is used for classifier-free guidance with text-dropout probability 0.10.1.