zenzop

A faster fork of the Zopfli DEFLATE compressor, written in Rust.

Zopfli produces near-optimal DEFLATE output at the cost of speed. zenzop produces byte-identical output 1.2–2x faster through algorithmic improvements: precomputed cost tables, SIMD-accelerated match comparison, arena-based Huffman tree construction, pre-allocated stores, and a skip-hash optimization that eliminates redundant hash chain walks on cached iterations.

With enhanced mode enabled, zenzop applies ECT-derived optimizations — expanded precode search, multi-strategy Huffman tree selection, and enhanced parser diversification — to produce smaller output than standard Zopfli at the cost of byte-for-byte parity with the C reference.

Features

• Byte-identical output to C Zopfli (default mode)
• Enhanced mode for smaller-than-Zopfli output (beats ECT-9 at equivalent iterations)
• 1.2–2x faster than C Zopfli (input-dependent; larger gains on smaller blocks)
• no_std + alloc compatible — works on embedded and WASM targets
• Cooperative cancellation via enough::Stop — cancel long-running compressions cleanly
• Streaming encoder API — DeflateEncoder, GzipEncoder, ZlibEncoder
• Parallel block compression with optional rayon support

Usage

Add to your Cargo.toml:

[dependencies]
zenzop = "0.4"

Compress data

use std::io;

fn main() -> io::Result<()> {
    let data = b"Hello, world!";
    let mut output = Vec::new();

    zenzop::compress(
        zenzop::Options::default(),
        zenzop::Format::Gzip,
        &data[..],
        &mut output,
    )?;

    Ok(())
}

Enhanced mode

use std::io;

fn main() -> io::Result<()> {
    let data = b"Hello, world!";
    let mut output = Vec::new();

    let mut options = zenzop::Options::default();
    options.enhanced = true;

    zenzop::compress(options, zenzop::Format::Gzip, &data[..], &mut output)?;

    Ok(())
}

Enhanced mode produces smaller DEFLATE output than standard Zopfli with ~5% runtime overhead. At 60 iterations it beats ECT-9 on representative test data.

Streaming encoder

use std::io::{self, Write};

fn main() -> io::Result<()> {
    let mut encoder = zenzop::DeflateEncoder::new_buffered(
        zenzop::Options::default(),
        Vec::new(),
    );
    encoder.write_all(b"Hello, world!")?;
    let compressed = encoder.into_inner()?.finish()?.into_inner();
    Ok(())
}

With cancellation / timeout

use std::io::{self, Write};

fn compress_cancellable(data: &[u8], stop: impl zenzop::Stop) -> io::Result<Vec<u8>> {
    let mut encoder = zenzop::GzipEncoder::with_stop_buffered(
        zenzop::Options::default(),
        Vec::new(),
        stop,
    )?;
    encoder.write_all(data)?;
    let result = encoder.into_inner()?.finish()?;
    if !result.fully_optimized() {
        eprintln!("compression was cut short by timeout");
    }
    Ok(result.into_inner())
}

Cargo features

For no_std usage: default-features = false.

MSRV

The minimum supported Rust version is 1.89. Bumping this is not considered a breaking change.

Building from source

cargo build --release

The zenzop binary will be at target/release/zenzop.

Testing

cargo test                    # Unit tests + property-based tests
./test/run.sh                 # Golden master: byte-identical to C Zopfli

Image tech I maintain

* as of 2026

General Rust awesomeness

archmage · magetypes · enough · whereat · zenbench · cargo-copter

And other projects · GitHub @imazen · GitHub @lilith · lib.rs/~lilith · NuGet (over 30 million downloads / 87 packages)

License

Apache-2.0

Upstream Contribution

This is a fork of google/zopfli (Apache-2.0). We are willing to release our improvements under the original Apache-2.0 license if upstream takes over maintenance of those improvements. We'd rather contribute back than maintain a parallel codebase. Open an issue or reach out.

Origin

Forked from zopfli-rs/zopfli, which was Carol Nichols' Rust reimplementation of Google's Zopfli. Enhanced mode optimizations derived from ECT (Efficient Compression Tool).

AI-Generated Code Notice

Developed with Claude (Anthropic). Not all code manually reviewed. Review critical paths before production use.