jpegli-rs

Pure Rust implementation of jpegli - Google's improved JPEG encoder/decoder from the JPEG XL project.

Features

• Pure Rust - No C/C++ dependencies required
• Perceptual optimization - Uses adaptive quantization for better visual quality
• Backward compatible - Produces standard JPEG files readable by any decoder
• SIMD accelerated - Uses wide crate for portable SIMD
• Color management - Optional ICC profile support via lcms2 or moxcms

What is jpegli?

jpegli is Google's improved JPEG encoder that produces smaller files at the same visual quality, or better quality at the same file size. It achieves this through:

• Adaptive quantization - Content-aware bit allocation
• Improved quantization tables - Better than standard IJG libjpeg tables
• XYB color space (optional) - Perceptually optimized color representation
• Smart zero-biasing - Intelligent coefficient rounding

Usage

use jpegli::{Encoder, Quality, PixelFormat};

// Encode RGB image data to JPEG
let jpeg_data = Encoder::new()
    .width(800)
    .height(600)
    .pixel_format(PixelFormat::Rgb)
    .quality(Quality::default())  // Q90
    .encode(&rgb_pixels)?;

// Decode JPEG to RGB
let decoded = jpegli::Decoder::new().decode(&jpeg_data)?;
println!("{}x{}", decoded.width, decoded.height);
let rgb_pixels: &[u8] = &decoded.data;

Feature Flags

Encoder Status

The encoder is feature-complete and production-ready:

Encoder Performance: 30-55 MP/s (varies by image complexity and quality setting)

Decoder Status

The decoder is functional with 12-bit internal precision (matching C++ jpegli):

Decoder Performance (1024x768 image):

The decoder is slower than alternatives because it uses a float pipeline for 12-bit precision, matching C++ jpegli's design. See Future Goals for planned optimizations.

Encoder Parity with C++ jpegli

Tested on CLIC2025 + Kodak datasets (56 images × 20 quality levels = 1,120 encodings per encoder):

Overall Results

Performance by Corpus

jpegli-rs produces byte-for-byte nearly identical output to C++ jpegli with 15-50% faster encoding.

Quality by Quality Level

Lower DSSIM is better. Higher SSIMULACRA2 is better.

Development

Running FFI Comparison Tests

To verify the Rust implementation matches the C++ original:

# Linux/macOS
./internal/setup-ffi-tests.sh

# Windows
.\internal\setup-ffi-tests.ps1

This requires CMake, a C++ compiler, and ~10 minutes for the initial C++ build. See internal/README.md for details.

Running Benchmarks

# Decoder performance comparison
cargo run --release --example decode_benchmark

# Encoder benchmark vs C++ cjpegli (requires cjpegli in PATH)
cargo run --release --example encode_benchmark

# Encoder quality comparison (jpegli vs mozjpeg)
cargo run --release --example pareto_comparison

Future Goals

Decoder Optimization (Target: 100+ MP/s)

The current decoder uses f32 arithmetic for 12-bit precision. To reach competitive speeds:

• Optional integer IDCT path for u8 output
• Platform-specific SIMD (AVX2, NEON) for hot paths
• Optimized bit reader with bulk byte loading
• Multi-threaded decoding for large images

Encoder Improvements

• Parallel block processing
• Memory-efficient streaming API
• Further entropy coding optimizations

License

AGPL-3.0-or-later

A commercial license is available from https://imageresizing.net/pricing

The original jpegli from libjxl is BSD-3-Clause licensed. This Rust implementation is an independent port, not a derivative work.

Acknowledgments

This is a Rust port of jpegli from the JPEG XL project by Google.

AI-Generated Code Notice

This crate was developed with significant assistance from Claude (Anthropic). While extensively tested against the C++ reference implementation with 220+ tests, not all code paths have been manually reviewed.

Before production use in critical applications:

• Review code paths relevant to your use case
• Run your own validation tests
• Report any issues at https://github.com/imazen/jpegli-rs/issues