Learn/Remade with RustDigital Freedom

rusty_h265 Is a Faster Rust HEVC Decoder, With a Mixed FFmpeg Result

The Rust HEVC decoder 0.7.0 decodes three measured clips 1.37x to 1.50x faster than its own 0.6 build. Against FFmpeg on one thread the result is mixed, and we print both.

Signed by M·
An open laptop on a walnut desk at dusk showing a grid of paused family video frames, a ceramic mug and a closed notebook beside it under a desk lamp
Is the Rust HEVC decoder 0.7.0 faster than FFmpeg?

Not across the board. In repository-reported single-thread runs against FFmpeg 8.1.2, rusty_h265 0.7.0 was 1.37x faster on a weighted-prediction stream, about 0.80x to 0.86x as fast on ordinary 8-bit inter clips, and at parity on 10-bit and deblocking-heavy inputs.

The Rust HEVC decoder in the Remade with Rust family just got a real upgrade, and the honest version of the story has two halves. rusty_h265 0.7.0, published on crates.io on 7 November 2026 from release commit c01a7b2b, decodes three measured clips 1.37x, 1.39x and 1.50x faster than its own 0.6 build. Against FFmpeg 8.1.2 running one thread, it wins on a weighted-prediction stream, trails on ordinary 8-bit inter video, and ties on 10-bit and deblocking-heavy clips. Both halves belong in the same paragraph, so here they are.

Every number on this page is repository-reported. We read the campaign's own ledger and commits. We did not rerun the benchmarks for this article. The decoder is the codec half of remade_ffmpeg_rs, the media pipeline we covered earlier, and the field note for the crate lives at remadewithrust.com. The product page is rusty_h265 on MATA.

HEVC, also called H.265, is the format a lot of modern video is stored in. The ITU-T H.265 recommendation is the specification the decoder is written against. A decoder turns that compressed file back into pictures. It does not make video smaller. That is an encoder's job, and this release has no encoder in it.

What The 0.7.0 Campaign Actually Measured

The campaign measured two things on the same decoder before and after: how many instructions the CPU retired, and how long decoding took.

Instructions came from callgrind, the Valgrind instruction-counting tool, on the shipping configuration with rusty_alloc and AVX2, built natively under WSL. The ledger says two runs of the same binary differ by about 20,000 instructions on a five-billion count. It does not name the CPU or the rustc version for that section.

  • A 20-second 720p x265 inter clip: 25.162 billion to 16.614 billion instructions, down 34.0 percent.
  • The all-intra ipred_x24 clip: 42.237 billion to 26.733 billion, down 36.7 percent.
  • The deblocking-heavy dblk_heavy clip: 5.251 billion to 3.869 billion, down 26.3 percent.

Time came from the repository's codec-bench.ps1 script on an Intel i7-14650HX, one pinned core, both builds alternated in ABBA order, 11 of 11 pairs favoring the new build on each clip. The ratios are 1.37x on the x265 clip, 1.39x on a 60-frame JCT-VC 720p clip, and 1.50x on ipred_x24. The plan also records about 1.23x to 1.36x on its 8-bit, 10-bit, deblocking and weighted-prediction set.

One caution we keep: the crate README and the plan print different absolute milliseconds for the new build on the same x265 clip. So we quote paired ratios against a named baseline and never average the milliseconds.

Where rusty_h265 Stands Against FFmpeg

The same harness timed FFmpeg 8.1.2's native HEVC decoder with -threads 1. That is one configuration of FFmpeg on one machine. FFmpeg's frame threading is outside this measurement, so none of this says anything about multithreaded playback.

Weighted Prediction Is Where It Wins

On the wp_x10 weighted-prediction stream, rusty_h265 0.7.0 ran at 1.37x the speed of FFmpeg on one thread, 20 of 21 pairs, with a reported z of 4.15. Weighted prediction is a tool encoders use for fades and brightness changes. It is a real feature, and it is also a narrower slice of video than everyday inter frames. One strong row is one strong row.

Ordinary 8-Bit Inter Video Is Slower

On the clips most people would think of as normal video, the Rust HEVC decoder is behind. The plan records 0.82x on the x265 clip and on ipred_x24, 15 of 15 pairs, and 0.80x on its 8-bit set. The crate README table shows 0.82x, 0.86x and 0.82x on its three clips. Read that as roughly 80 to 86 percent of FFmpeg's single-thread speed on ordinary 8-bit content. That is slower, and we will not round it into anything else.

10-Bit And Deblocking-Heavy Clips Sit At Parity

On 10-bit and deblocking-heavy inputs the two decoders landed at parity. The README treats differences inside about 5 percent as noise, because FFmpeg measured against itself on that harness reads 0.95x. Two other tricks were counted and left out of the shipping build: profile-guided optimization, which the plan calls an upper bound because it trained on the test streams, and an x86-64-v3 CPU target. Neither number is in the shipped decoder, so neither belongs in a speed claim.

What A Faster Decoder Means For Video You Keep

Speed is a cost question. The privacy question is where the work happens. A decoder that runs on hardware you hold can read your own recordings without an upload, and a faster one makes that cheaper. That is the whole connection, and it ties to the three primitives of Digital Freedom: Trust, Security, Incentive.

Trust: A Conformance Gate On Every Change

Each change in the campaign was kept only if callgrind counted fewer instructions and the decoder stayed bit-exact. The reported gate is 147 of 147 JCT-VC HEVC_v1 streams bit-exact and 6,183 of 6,183 picture-hash SEI messages matching. The conformance bitstreams are the ones defined for ITU-T H.265.1. Passing them means the output matches the reference on that suite. It is not a promise about every malformed file a camera or a stranger can produce.

Security: Memory-Safe Code For Untrusted Files

Video files are input from the outside world, and decoders have a long history as attack surface. The NIST Secure Software Development Framework asks developers to reduce whole classes of vulnerabilities, and memory-safe languages are part of that answer. The Rust HEVC decoder is written in Rust. That lowers one category of risk. It does not replace fuzzing or code review, and a conformance pass is not a security audit.

Incentive: The New Decoder Is On Main

The published decoder crate is still rusty_h265 0.7.0, and the ratios on this page were measured on the campaign commits, not re-timed on the integration commit. Pull request 98 merged at 10:37 AM MST on 7 November 2026. remade_ffmpeg_rs main is ee52ed9b and pins rusty_h265 and rusty_h265-accel at 0.7.0. The mixed speed sentence is on that readme. At 10:40 AM MST, ci, portfolio-check, and release-plz on the merge commit were still running, so this is not a new released tool binary. Before the merge, the MP3 and AAC cargo-vet jobs failed because rusty_alloc 2.4.0 lacked safe-to-run. That is not an HEVC decode result, and it does not change these ratios.

When video lives on a home computer instead of a rented folder, decode cost is your electricity and your wait. The Freedom Guide walks through bringing files home. For streaming HEVC between machines, the IETF's RTP payload format for HEVC is the transport reference. More pieces like this one sit in Learn, and the MATA home page is where the rest of the stack starts.

FAQ

Short answers already in this article.

How much faster is rusty_h265 0.7.0 than the 0.6 decoder?

The repository reports paired single-core timing on an Intel i7-14650HX: 1.37x on a 20-second 720p x265 clip, 1.39x on a 60-frame JCT-VC 720p clip, and 1.50x on the all-intra ipred_x24 clip, 11 of 11 pairs each. Instruction counts fell 34.0, 36.7 and 26.3 percent on three inputs.

Does the remade_ffmpeg_rs tool already ship the faster HEVC decoder?

Pull request 98 merged at 10:37 AM MST on 7 November 2026. remade_ffmpeg_rs main is ee52ed9b and pins rusty_h265 and rusty_h265-accel at 0.7.0. The public rusty_h265 crate is still 0.7.0. At 10:40 AM MST, ci, portfolio-check, and release-plz on that merge were still running, so this is not a new released tool binary.

Is rusty_h265 an HEVC encoder?

No. rusty_h265 is a decoder for HEVC Main, Main 10 and Main Still Picture, 4:2:0 at 8 and 10 bits. The 0.7.0 campaign did not touch an encoder, H.264, AV1 or AVIF.

How was correctness checked for the rusty_h265 0.7.0 release?

The campaign commit and pull request 98 report 147 of 147 JCT-VC HEVC_v1 conformance streams bit-exact and 6,183 of 6,183 picture-hash SEI messages matching. That is a pass on that suite, not proof that every HEVC file in the wild decodes safely.

Why does a faster local HEVC decoder matter for privacy?

Decoding on your own machine means home video can be read without an upload to someone else's transcoder. A faster decoder lowers the cost of doing that work locally. It does not, by itself, change where any app sends your data.