DiffC: Diffusion-Based Image Compression

• DiffC is a diffusion-based lossy image compression method that reinterprets compression as communicating noisy samples via Reverse Channel Coding.
• It leverages pretrained generative models, such as Stable Diffusion, to enable zero-shot image reconstruction at low and ultra-low bitrates.
• The approach incorporates techniques like step skipping and dimensional splitting to optimize encoding efficiency and enhance robustness against bit-level errors.

Searching arXiv for papers on DiffC in image compression to ground the article. In recent image compression literature, DiffC denotes a specific diffusion-based lossy image compression method built around Reverse Channel Coding (RCC) and a pretrained generative prior, rather than a generic acronym for diffusion compression (Vaisman et al., 7 Apr 2026). The method originated as “Lossy Compression with Gaussian Diffusion,” which proposed communicating Gaussian-noise-corrupted pixels instead of quantized transform coefficients (Theis et al., 2022), and was later realized as a practical zero-shot codec using pretrained latent diffusion backbones such as Stable Diffusion and Flux-dev in “Lossy Compression with Pretrained Diffusion Models” (Vonderfecht et al., 16 Jan 2025). Its central idea is to reinterpret compression as the communication of samples along a diffusion trajectory: the encoder transmits only enough information to steer a shared generative decoder toward the target image, and the decoder reconstructs by reverse denoising. This makes DiffC especially relevant at low and ultra-low bitrates, where conventional transform coding becomes rate-constrained and generative priors can dominate perceptual quality (Vonderfecht et al., 16 Jan 2025).

1. Historical development and conceptual scope

DiffC was introduced in “Lossy Compression with Gaussian Diffusion” as a compression scheme that dispenses with transform coding and quantization, instead communicating a Gaussian-noise-corrupted version of the pixels and reconstructing by denoising with a single unconditional diffusion model (Theis et al., 2022). In that formulation, the encoder draws an exact sample $Z_t$ from a known corruption channel applied directly to the pixels $X$, communicates that sample efficiently using RCC, and the decoder reconstructs either by ancestral sampling or by the probability flow ODE (Theis et al., 2022).

A later milestone was “Lossy Compression with Pretrained Diffusion Models,” which described the first complete implementation of DiffC and applied it zero-shot to Stable Diffusion 1.5, 2.1, XL, and Flux-dev (Vonderfecht et al., 16 Jan 2025). That work reframed DiffC as a practical codec for pretrained diffusion backbones and introduced what it described as “simple workarounds” for RCC bottlenecks, making encoding and decoding with large latent diffusion models feasible in under 10 seconds for some settings (Vonderfecht et al., 16 Jan 2025).

A useful clarification appears in “On the Robustness of Diffusion-Based Image Compression to Bit-Flip Errors”: there, “DiffC” refers to a specific RCC-based diffusion compressor based on “Lossy Compression with Gaussian Diffusion,” implemented via the custom CUDA kernel of Vonderfecht and Liu, and it is explicitly distinguished from DDCM and Turbo-DDCM (Vaisman et al., 7 Apr 2026). This suggests that, within the 2025–2026 image compression literature, DiffC functions both as the name of a compression principle and as the name of a particular RCC codec family rooted in the 2022 proposal (Theis et al., 2022).

Paper	Role in DiffC lineage	arXiv
“Lossy Compression with Gaussian Diffusion”	Original DiffC formulation	(Theis et al., 2022)
“Lossy Compression with Pretrained Diffusion Models”	First complete practical implementation with pretrained models	(Vonderfecht et al., 16 Jan 2025)
“On the Robustness of Diffusion-Based Image Compression to Bit-Flip Errors”	Robustness analysis of RCC-based DiffC	(Vaisman et al., 7 Apr 2026)

2. Reverse-channel coding and the communication-of-samples view

The defining mechanism of DiffC is Reverse Channel Coding. In this view, compression is not primarily the entropy coding of transform coefficients or learned latents. Instead, it is the communication of a target sample from a posterior $q$ using a shared proposal distribution $p$, with expected coding cost close to $D_{KL}(q\|p)$ (Vonderfecht et al., 16 Jan 2025). The 2022 DiffC paper states that communicating an exact sample costs at most the mutual information $I[X,Z_t]$ plus a small overhead, and that when the sender and receiver assume a marginal $p_t(Z_t)$, an achievable upper bound is $C_t + \log(C_t+1)+5$, where $C_t = \mathbb{E}_X[D_{KL}(q(Z_t|X)\|p_t(Z_t))]$ (Theis et al., 2022).

In diffusion compression, the encoder and decoder share a pretrained denoising model and shared randomness. The encoder selects a message that causes the decoder’s reverse diffusion trajectory to match the target-conditioned posterior at selected timesteps (Vonderfecht et al., 16 Jan 2025). The 2026 dual-representation paper gives the same RCC intuition in more general form: RCC tackles the problem of communicating a random variable $x\sim q(x)$ when both transmitter and receiver share a reference distribution $X$0, with the objective of sending $X$1 in about $X$2 bits (Zhou et al., 5 Feb 2026).

The exact sampling procedure used in practical DiffC implementations is based on the Poisson Functional Representation (PFR) algorithm of Theis and Ahmed, which provides an exact sampling scheme with expected cost close to $X$3 (Zhou et al., 5 Feb 2026). The 2025 implementation paper emphasizes that naïve PFR is inefficient when per-step KL is either too small or too large, and this led to the two principal engineering workarounds used in DiffC: step skipping when per-step KL is too small, and dimensional splitting when per-step KL is too large (Vonderfecht et al., 16 Jan 2025). The same RCC strategies are described as carrying over directly in later work (Zhou et al., 5 Feb 2026).

This RCC formulation is what makes DiffC conceptually distinct from classical and learned entropy-coded codecs. The entropy model is effectively embedded in the shared generative prior, while the transmitted bits identify which stochastic realization along the reverse process should be reconstructed (Vonderfecht et al., 16 Jan 2025).

3. Diffusion model formulation and codec pipeline

The original Gaussian DiffC paper formulates the forward corruption as

$X$4

with the associated diffusion SDE

$X$5

The decoder then reconstructs either by ancestral sampling from the reverse SDE or by the probability flow ODE (Theis et al., 2022).

In the practical pretrained-model implementation, DiffC operates in latent space for Stable Diffusion 1.5, 2.1, XL, and Flux-dev (Vonderfecht et al., 16 Jan 2025). The DDPM forward noising process is

$X$6

and the reverse model is

$X$7

with $X$8-prediction used for the mean parameterization (Vonderfecht et al., 16 Jan 2025). The target posterior used by RCC is

$X$9

which gives the sender distribution for each communicated step (Vonderfecht et al., 16 Jan 2025).

The practical codec has two phases. First, the encoder communicates a noisy sample $q$0 from the forward chain using RCC, possibly over a schedule that skips timesteps. Second, the decoder denoises deterministically from $q$1 to $q$2, typically with a DDIM-style probability-flow sampler (Vonderfecht et al., 16 Jan 2025). The pretrained-model paper states that DiffC-F, the deterministic probability-flow variant, is both faster and lower-distortion than ancestral sampling, and the 2022 Gaussian paper proves that flow-based reconstruction achieves a 3 dB gain over ancestral sampling at high bitrates (Theis et al., 2022).

The rate–distortion viewpoint is explicit in both formulations. The 2025 paper gives the standard Lagrangian

$q$3

where the tradeoff is controlled by how far along the diffusion chain communication proceeds and how many bits are spent on RCC per step (Vonderfecht et al., 16 Jan 2025). The 2022 paper emphasizes that the same unconditional diffusion model supports arbitrary bitrates by varying the corruption level $q$4, and that partial bitstreams enable progressive reconstruction (Theis et al., 2022).

4. Practical implementation details and system-level behavior

The major practical advance in DiffC was the resolution of RCC inefficiencies. Near the highest noise levels, per-step KL can be too small for PFR to be bitrate-efficient, so DiffC skips multiple diffusion steps and communicates a larger jump instead (Vonderfecht et al., 16 Jan 2025). Near $q$5, per-step KL can become extremely large, so the latent is partitioned into approximately independent factors such that each component has manageable KL, around a “sweet spot” of about 16 bits per chunk in the 2025 implementation (Vonderfecht et al., 16 Jan 2025).

The paper also introduces a greedy shortest-path schedule for selecting which timesteps to communicate. If $q$6 denotes the expected RCC cost of communicating $q$7 from $q$8, then the optimal schedule to a chosen final timestep $q$9 is the shortest path in the graph of expected costs (Vonderfecht et al., 16 Jan 2025). Because $p$0 can be computed in closed form from the model’s $p$1-prediction, this schedule can be optimized without repeated model calls (Vonderfecht et al., 16 Jan 2025).

A further simplification is the use of a hard-coded per-step KL schedule based on dataset averages rather than transmitting stepwise side information (Vonderfecht et al., 16 Jan 2025). The paper reports that rate–distortion curves are robust to these approximations, including min, mean, max, and scaled variants (Vonderfecht et al., 16 Jan 2025).

On the systems side, a custom CUDA implementation of PFR is central. The pretrained-model paper reports that a custom CUDA kernel avoids materializing large arrays of proposal samples and achieves about a $p$2 speedup compared with PyTorch or TensorFlow implementations, making RCC a negligible portion of runtime for 16-bit chunks (Vonderfecht et al., 16 Jan 2025). In consequence, overall runtime is dominated by diffusion inference rather than sampling overhead (Vonderfecht et al., 16 Jan 2025).

The method remains inherently iterative. The 2025 implementation reports, on an NVIDIA A40, encoding times of $p$3–$p$4 s and decoding times of $p$5–$p$6 s for DiffC with Stable Diffusion 1.5 on Kodak; larger models such as SDXL and Flux-dev increase runtime substantially (Vonderfecht et al., 16 Jan 2025). This runtime profile became a central motivation for later few-step and real-time variants (Kimishima et al., 9 Jun 2026, Jia et al., 14 Apr 2026).

5. Empirical performance, bitrate regimes, and robustness

DiffC is primarily positioned for low and ultra-low bitrate compression. The pretrained-model implementation reports natural operation across low and ultra-low regimes, with visual examples in the $p$7–$p$8 bpp range on Kodak (Vonderfecht et al., 16 Jan 2025). In the 2022 Gaussian-diffusion paper, DiffC-F significantly outperformed HiFiC in FID across bitrates on ImageNet $p$9, while both DiffC-F and DiffC-A exceeded BPG and HiFiC in PSNR at high rates (Theis et al., 2022).

At the same time, latent diffusion imposes a hard fidelity ceiling through the underlying VAE. The pretrained-model paper reports average VAE PSNR bounds of about $D_{KL}(q\|p)$0 dB for Stable Diffusion 1.5 and 2.1, $D_{KL}(q\|p)$1 dB for SDXL, and $D_{KL}(q\|p)$2 dB for Flux on Kodak (Vonderfecht et al., 16 Jan 2025). This is why the paper argues that SD-based DiffC is most compelling below the VAE distortion ceiling, whereas Flux’s higher-fidelity VAE supports higher bitrate operation (Vonderfecht et al., 16 Jan 2025).

Robustness to bit-level corruption is an important later development. The robustness paper evaluates DiffC under a Binary Symmetric Channel with bit error rates $D_{KL}(q\|p)$3 (Vaisman et al., 7 Apr 2026). At BER $D_{KL}(q\|p)$4 on Kodak24, DiffC achieved PSNR $D_{KL}(q\|p)$5, LPIPS $D_{KL}(q\|p)$6, FID $D_{KL}(q\|p)$7, and $D_{KL}(q\|p)$8 corrupted files (Vaisman et al., 7 Apr 2026). At BER $D_{KL}(q\|p)$9, DiffC degraded to PSNR $I[X,Z_t]$0, LPIPS $I[X,Z_t]$1, FID $I[X,Z_t]$2, with $I[X,Z_t]$3 corrupted files (Vaisman et al., 7 Apr 2026).

The same study argues that RCC-based diffusion codecs are more robust to bit flips than classical and learned codecs because they transmit fixed-step structured control signals and because the diffusion prior regularizes perturbed guidance back onto the natural image manifold (Vaisman et al., 7 Apr 2026). However, DiffC is still less robust than DDCM and Turbo-DDCM variants that avoid entropy coding altogether, because DiffC’s seeds are entropy-coded and remain vulnerable to desynchronization (Vaisman et al., 7 Apr 2026).

A recurring empirical theme is the balance between realism and semantic faithfulness. DiffC excels at synthesizing fine-grained detail from very limited information, but later work identifies semantic drift as a failure mode at the lowest bitrates, where the early noisy states do not retain complete global semantics (Zhou et al., 5 Feb 2026).

6. Extensions, criticisms, and successor frameworks

A substantial portion of later work on diffusion compression is best understood as a response to specific limitations of DiffC.

The 2026 dual-representation framework argues that existing approaches are constrained by a tradeoff between semantic faithfulness and perceptual realism, and identifies DiffC as strong on fine-grained textures but weak on global semantic consistency when the bitrate is extremely small (Zhou et al., 5 Feb 2026). That work proposes conditioning a diffusion model on explicit high-level semantics while still using RCC for implicit texture transmission, and reports that it surpasses DiffC by $I[X,Z_t]$4, $I[X,Z_t]$5, and $I[X,Z_t]$6 in DISTS BD-Rate on Kodak, DIV2K, and CLIC2020, respectively (Zhou et al., 5 Feb 2026).

The paper “CoD: A Diffusion Foundation Model for Image Compression” argues that Stable Diffusion is not the ideal foundation model for diffusion codecs and replaces text conditioning with learned image-native tokens (Jia et al., 24 Nov 2025). In that account, DiffC is a zero-shot framework that “measures the compression capability” of a diffusion model, and CoD serves as a stronger diffusion backbone for DiffC, especially at ultra-low bitrates such as $I[X,Z_t]$7 bpp (Jia et al., 24 Nov 2025). The paper reports that text conditions harm zero-shot DiffC on Stable Diffusion, whereas compression-oriented conditioning improves low-bitrate performance (Jia et al., 24 Nov 2025).

The real-time paper “CoD-Lite” treats “DiffC (SD)” as the large-prior, multi-step diffusion-compression baseline and contrasts it with a one-step lightweight convolutional codec (Jia et al., 14 Apr 2026). It reports $I[X,Z_t]$8 FPS encoding and $I[X,Z_t]$9 FPS decoding at 1080p, and uses DiffC as a latency baseline illustrating the cost of iterative sampling (Jia et al., 14 Apr 2026). This suggests that, by 2026, DiffC had become the canonical benchmark for multi-step pretrained diffusion compression, even when later systems targeted real-time deployment (Jia et al., 14 Apr 2026).

The paper “Few-step Generative Models as Lossy Compression” explicitly asks whether Rectified Flow, Consistency Trajectory Models, and MeanFlow can be cast as codecs within the same RCC framework as DiffC (Kimishima et al., 9 Jun 2026). It identifies DiffC’s slowness as arising from many forward and reverse steps and derives the posterior and shared distribution quantities needed for RCC from few-step model parameterizations (Kimishima et al., 9 Jun 2026). On low-resolution benchmarks, these codecs reduce encoding and decoding time and improve realism in the low-bit-rate regime (Kimishima et al., 9 Jun 2026).

A more radical shift appears in “Next-Frame Decoding for Ultra-Low-Bitrate Image Compression with Video Diffusion Priors,” which treats DiffC as representative of image-diffusion codecs that start from Gaussian noise and use channel concatenation conditioning (Chen et al., 16 Mar 2026). That paper instead transmits a visible anchor frame and uses a pretrained video diffusion model to perform one-step next-frame prediction. On CLIC2020, it reports over $p_t(Z_t)$0 bitrate savings across LPIPS, DISTS, FID, and KID relative to DiffC, with decoding speedups of up to about $p_t(Z_t)$1 (Chen et al., 16 Mar 2026).

Taken together, these developments suggest a stable interpretation of DiffC within the literature: it is the reference RCC-based diffusion codec that established the feasibility of zero-shot generative image compression with pretrained priors, but later work systematically targets its known weaknesses—semantic drift at ultra-low rates, reliance on latent VAEs, multi-step latency, and entropy-coding fragility under channel corruption (Vonderfecht et al., 16 Jan 2025, Zhou et al., 5 Feb 2026, Vaisman et al., 7 Apr 2026, Kimishima et al., 9 Jun 2026).