rusty_dds and rusty_alloc: cooking textures and measuring allocator CPU in a game stream
Cook-time quality for rusty_dds versus 0.1.2, a 24-case DirectXTex comparison, and rusty_alloc's share of process CPU on a game-like streaming path, caveats attached.

What measurements are published for this DDS toolkit and allocator on a game-like path?
rusty_dds and rusty_alloc are used together on a cook and stream path. The published numbers are cook-time quality versus the 0.1.2 release, a 24-case DirectXTex board, and process-CPU share for the allocator on the streaming simulator, all taken from the rusty_dds repository with the caveats attached.
I work on these crates. Remade with Rust is a project of MATA, built by US-based security and tech engineers. This post is about two of our libraries, a DDS texture toolkit and a general-purpose allocator, and the measurements we still stand behind when they are used together on a game-like path. I am writing it so those numbers can be read in one place, with the caveats attached.
Two libraries, one pipeline
rusty_dds is a pure-Rust DirectDraw Surface toolkit: container parse, decode, encode, and GPU upload plans, without a C or C++ DirectXTex stack. rusty_alloc is a pure-Rust allocator, a remake of mimalloc, that can be installed as the process global allocator. Games care about both sides of that pairing. Textures have to cook, and they have to stream. The allocator sits under all of that work.
The numbers below are taken from the rusty_dds repository as it stands. Where a later write-up in that repo withdrew a claim, I leave the claim out.
Cook-time quality, including a GameSDK texture set
The in-tree cook corpus has 102 cases: ambientCG CC0 maps, 16 CryTIF .tif files from CRYTEK's GameSDK, and 10 USC-SIPI TIFFs. This is a cook-time comparison against our own 0.1.2 release, not a runtime comparison with CryEngine. We have not published a CryEngine runtime test, and I am not claiming one.
The repository's performance snapshot is the more careful accounting: four of the 102 cases are lossless and cannot move, so the quality row is the 98 lossy ones. 85 of those 98 improved versus 0.1.2, 13 were unchanged, and none regressed. The largest single-case gain is +13.53 dB on BC7 crytif_startscreen. Whole-corpus encode time on that harness fell from 0.851 s to 0.644 s. An earlier note in the same README still says "89 of 102 cases improved"; I am using the snapshot's 85-of-98 figure because it explains the lossless cases. The max gain and the "zero regressions" result are the same in both places.
Against DirectXTex, on a 24-case ambientCG board
On a 24-case ambientCG CC0 proxy corpus (about 1024² albedo, normal, and mask maps, cooked to BC1, BC4, BC5, and BC7), rusty_dds is measured against Microsoft DirectXTex as follows:
- Encode quality (PSNR): 22 higher, 1 tie, 1 lower (±0.25 dB).
- Encode speed (per core): 24 ahead, 0 behind.
- Decode speed: 24 ahead, 0 behind.
The one quality loss on that board is named in the README: Wood095_NormalGL as BC5S, at −0.51 dB, from turning the signed BC4/BC5 window sweep off by default. The proxy corpus is not a studio asset pack; the repo invites other maps as the real gate. A separate 54-case synthetic grid is also reported honestly: DirectXTex is genuinely higher on 17 of those cases, but the headline 24-case board is the one above.
The DirectXTex peer flag for BC7 on that board is TEX_COMPRESS_BC7_QUICK, which is the mode-6 class that matches our encoder. rusty_dds encode uses strip parallelism at 4096 blocks and up; the DirectXTex peer is TEX_COMPRESS_DEFAULT (no TEX_COMPRESS_PARALLEL). Those protocol details are in the rusty_dds README next to the board.
Reproduce with the in-tree harvest_corpus_* and bench_encode_corpus examples. The 0.1.2 cook comparison builds that release from commit 286d070 and runs both arms on the same harness.
Platforms
Windows, macOS, and Linux on x86-64 are the timed hosts, with SSE2 / SSSE3 / AVX2 detected at runtime. aarch64 builds and passes its tests, including NEON block-decode kernels under qemu, but no timing has been taken on real ARM silicon, and we claim none. The WebAssembly path is decode-only.
Pairing it with rusty_alloc
The cook numbers above are about the codec. The streaming simulator in sim/ is about the other half of a game path: container parse, subresource slicing, and upload-plan construction. It does not decode. It hands compressed BCn toward a GPU path, which is what a streaming engine should do. Frame-percentile cockpit numbers on the main thread can miss work that runs on streaming workers, so the allocator comparison is done on process CPU.
Commit a214e6b recorded a paired comparison, 20 pairs, pack high192. rusty_alloc accounted for 11.1–14.8% of total sim CPU across both stacks (rusty_dds and DirectXTex) and both scenarios in that matrix, reported with a z-score (up to +4.36). The same commit notes that ten pairs were not enough: a 9.5% stack regression seen at n=10 did not survive n=20. The script, sim/bench_arms.py, is still in the tree:
python bench_arms.py arrival pack/high192 20
That is a process-CPU result on this simulator, not a frame-time result, and not a claim about every game.
What I am not claiming
The simulator also counted "hitches" as frames whose streaming path cost more than 1 ms. A later write-up in docs/plans/optimization-plan.md voided those earlier hitch boards. A hash in the harness had been pushing ordinary frames past the 1 ms line, so hitch rates measured the instrument. I am not repeating any hitch-reduction claim.
I am also not comparing rusty_dds to a running CryEngine. The GameSDK CryTIF files were inputs to a cook corpus. That is all.
Why it matters to us
Texture cooking and streaming are a large part of a game's asset path. A memory-safe DDS toolkit that can sit in a cook pipeline or a loader, and an allocator that shows up in process CPU on that same path, are the kind of pieces we want Rust game developers to be able to reach for. The work is pre-1.0, the measurements have caveats, and the honest ones are still useful.
On this site, see the rusty_dds field note, the rusty_alloc field note, the rusty_dds conversion pin, the rusty_alloc conversion pin, and game memory allocator for developers.
FAQ
Quick answers for builders evaluating this technology.
How did rusty_dds cook-time quality change versus the 0.1.2 release?
On the in-tree cook corpus, four of 102 cases are lossless and cannot move, so the quality row is the 98 lossy ones. 85 of those 98 improved versus 0.1.2, 13 were unchanged, and none regressed. The largest single-case gain is +13.53 dB on BC7 crytif_startscreen. Whole-corpus encode time on that harness fell from 0.851 s to 0.644 s.
How does rusty_dds compare with DirectXTex on the 24-case ambientCG board?
On that 24-case ambientCG CC0 proxy corpus, encode quality (PSNR) was 22 higher, 1 tie, 1 lower (±0.25 dB). Encode speed per core was 24 ahead, 0 behind. Decode speed was 24 ahead, 0 behind. The one quality loss is Wood095_NormalGL as BC5S, at −0.51 dB.
What did the rusty_alloc pairing measure on the streaming simulator?
The simulator in sim/ covers container parse, subresource slicing, and upload-plan construction. It does not decode. Commit a214e6b recorded a paired comparison, 20 pairs, pack high192. rusty_alloc accounted for 11.1–14.8% of total sim CPU across both stacks and both scenarios, reported with a z-score (up to +4.36). That is a process-CPU result, not a frame-time result, and not a claim about every game.
Is this a CryEngine runtime comparison?
No. The GameSDK CryTIF files were inputs to a cook corpus. This is a cook-time comparison against the 0.1.2 release, not a runtime comparison with CryEngine. No CryEngine runtime test has been published, and none is claimed.
Why does this article omit hitch-reduction claims?
The simulator counted hitches as frames whose streaming path cost more than 1 ms. A later write-up in docs/plans/optimization-plan.md voided those earlier hitch boards, because a hash in the harness had been pushing ordinary frames past the 1 ms line. Hitch rates measured the instrument, so no hitch-reduction claim is repeated.