Field notes/Mediarusty_tiffrusty_imagerusty_iccperformanceArtCraft

rusty_tiff, rusty_image and rusty_icc 0.1.1: Fewer Instructions, Same Bytes

The 0.1.1 releases of rusty_tiff, rusty_image and rusty_icc cut instruction counts by up to 73 percent with byte-identical output, and record where they still trail.

Signed by M·
Painted village lane at dusk where a lighter handcart carries the same load of parcels between lit houses
What changed in rusty_tiff, rusty_image and rusty_icc 0.1.1?

The 0.1.1 releases removed memory copies and redundant instructions from all three crates without changing a single output byte. Under callgrind, rusty_tiff G4 decode retires 73 percent fewer instructions than 0.1.0, rusty_image QOI RGBA encode 45 percent fewer, and rusty_icc profile parse and encode 66 percent fewer. Wall-clock results against other libraries are mixed and published in full.

Ship it

4 to 6× Faster G4 Decode

than the tiff crate, and 1.3 to 1.6× faster than libtiff, with no C and no unsafe.

Open the rusty_tiff conversion pin →

On 20 November 2026, rusty_tiff, rusty_image and rusty_icc 0.1.1 shipped from the remade_ffmpeg_rs monorepo. The release removed memory copies and redundant instructions from all three crates. Every output byte is the same as 0.1.0. Instruction counts fell by up to 73 percent, and the wall-clock results against other libraries are published here in full, including where the crates still trail.

rusty_tiff reads and writes TIFF and BigTIFF, rusty_image covers BMP, ICO, TGA, PNM, HDR and QOI, and rusty_icc does ICC colour management. Most clock numbers below come from the ArtCraft team's harness, the same team whose timing drove the rusty_jpeg 0.4.4 decode work.

How the Campaign Was Measured

Instruction counts first

Clocks are noisy, so the campaign steered by instruction counts. Callgrind counts the instructions a run retires, and the count barely moves between runs, so a small real change shows up instead of drowning in noise. Every count here is from 1536 by 1024 crops of a real photo, comparing the new release with 0.1.0 on the same input.

Clocks to confirm

Instruction counts do not see cache misses or branch mispredictions, so each claim was checked on the clock as well. Wall-clock numbers are pinned, interleaved (ABBA) runs with N=20 on the ArtCraft team's harness. Two LZW timings come from the crate's own harness and are labelled that way below.

Same bytes, every time

No change in the release was allowed to alter output. Every encoded file and decoded pixel buffer is byte-identical to 0.1.0, so callers can upgrade without re-validating images. The same rule held in the rusty_h265 0.7.0 campaign.

What Got Faster in Each Crate

rusty_tiff

Instruction counts on decode fell 42 percent for 8-bit LZW, 45 percent for 16-bit LZW, 40 percent for uncompressed and 73 percent for CCITT G4. On encode they fell 71 percent for uncompressed, 67 percent for PackBits, 49 percent for LZW and 25 percent for Deflate. On the clock, G4 decode is 4 to 6 times faster than the tiff crate and 1.3 to 1.6 times faster than libtiff. Uncompressed decode ties tiff 0.11 and beats libtiff 1.10 to 1.12 times. PackBits encode is 3.9 to 4.2 times faster than tiff. LZW decode already beat tiff 1.15 to 1.55 times, and its final change alone took the crate's own run from 0.24 to 0.12 seconds at 8 bits and from 0.40 to 0.18 seconds at 16 bits.

The decoder also refuses less. On an 18,024-file set of damaged TIFFs, the new decoder handles 128 of the 141 files that tiff 0.11 decoded but 0.1.0 refused, and 806 files that both refused. No file caused a panic.

rusty_image

QOI decode retires 38 percent fewer instructions for RGB and 35 percent fewer for RGBA, and QOI encode 30 and 45 percent fewer. On the BMP side, decoding 8-bit palette images costs 37 percent fewer instructions, and 32-bit images 33 percent fewer. Against image 0.25.10 on the clock, 24-bit BMP decode is 2.11 times faster, TGA RLE decode 2.06 times, Radiance HDR encode 3.12 times and BMP encode 2.35 to 2.58 times. QOI RGB decode is the best story: it moved from 0.82 times to 1.07 times once the team found that the decoder's per-op dispatch had compiled to a jump table that mispredicted 59 percent of the time.

rusty_icc

Matrix-shaper transforms retire 22 percent fewer instructions, with 12 percent of that from the last commit. 8-bit RGB to CMYK is down 44 percent, and profile parse and encode 66 percent. Wall-clock time against 0.1.0 fell between 1 and 37 percent depending on the transform. Against LittleCMS, rusty_icc is 1.40 times faster on the 16-bit matrix-shaper and 1.14 times faster on Lab to sRGB in float.

Where the Crates Still Trail

The open gaps

rusty_image QOI encode runs at 0.81 times the image crate's speed for RGB and 0.89 times for RGBA. Those numbers predate the last two QOI changes and have not been re-measured, so the gap may be smaller now, but it is not closed. LittleCMS still beats rusty_icc on 8-bit transforms. It uses fixed-point arithmetic there, and copying that would change rusty_icc's output, which this campaign ruled out.

Why publish the losses

A speed table that only lists wins tells a builder nothing about whether to switch, which is why the rusty_tiff, rusty_image and rusty_icc 0.1.1 tables above keep the losing rows. These crates replace C libraries that teams already trust, so the honest comparison, row by row, is what makes the swap a decision instead of a leap. The Media band applies that rule across remade_ffmpeg_rs and its sibling crates.

Where to look next

To try rusty_tiff, rusty_image and rusty_icc 0.1.1, pin the crates from crates.io, and open the repo landings for rusty_tiff, rusty_image and rusty_icc. Fewer instructions per image matter most where decoding runs on modest hardware: RAG Converter decodes scans and pictures inside a browser tab on the user's own machine, and apps hosted on MATA.NETWORK often run on a home computer rather than a data center. For the method behind instruction-count campaigns, Valgrind's callgrind manual is the primary reference.

FAQ

Quick answers for builders evaluating this technology.

How were the 0.1.1 numbers measured?

Instruction counts come from callgrind on 1536 by 1024 crops of a real photo. Wall-clock numbers are pinned, interleaved ABBA runs with N=20 on the ArtCraft team's harness, except two LZW timings from the crate's own harness, which are labelled as such.

Did the 0.1.1 releases change any output?

No. Every output of rusty_tiff, rusty_image and rusty_icc 0.1.1 is byte-identical to 0.1.0. The campaign only changed how much work the code does to produce the same bytes.

Where do these crates still trail other libraries?

rusty_image QOI encode runs at 0.81 times the image crate's speed for RGB and 0.89 times for RGBA, measured before its last two QOI changes. LittleCMS is still faster than rusty_icc on 8-bit colour transforms, because its fixed-point arithmetic would change rusty_icc's output.

Why did rusty_image QOI decode get faster?

The decoder's per-op dispatch had compiled to a jump table that mispredicted 59 percent of the time. Restructuring it moved QOI RGB decode from 0.82 times the image crate's speed to 1.07 times.

Is rusty_tiff 0.1.1 more robust than 0.1.0?

Yes. On an 18,024-file set of damaged TIFFs, the new decoder handles 128 of the 141 files that the tiff crate decoded but 0.1.0 refused, and 806 files that both refused. No file caused a panic.