Zerompk debuts as a fast zero-copy MessagePack crate for Rust

Zerompk landed with a familiar Rust promise and an unusually sharp edge: a MessagePack crate that aims to outrun rmp_serde without giving up an approachable derive-based API. The author pitched it as zero-copy, zero-dependency, and no_std-compatible, which makes it more than a serialization experiment. It is a portability play for developers who want speed in hot paths without signing up for a heavy runtime footprint.

The first thing the thread showed was how ordinary the surface area looks. A simple struct can be handled through derive-based usage, so the crate does not ask users to abandon the ergonomics that made serde popular in the first place. That matters because Zerompk is trying to sell a performance story to Rust teams that already know the cost of too much abstraction, but still need code that is maintainable enough to live in production.

The benchmark table is where Zerompk makes its case. The crate was compared with serde_json, msgpacker, and rmp_serde across several serialize and deserialize workloads, including a small struct, a map-form struct, a large array-style workload, and a no-copy case. In the posted numbers, Zerompk was competitive or faster in the scenarios the author highlighted, and it looked especially strong when deserialization was the dominant cost. The author also argued that the serde interface itself carries meaningful overhead, pushing the comparison beyond raw byte-shuffling and into the cost of the abstraction layer.

There was one important caveat in the thread: msgpacker does not actually generate correctly formatted MessagePack binaries, so the benchmark set is not a clean winner-take-all race. That warning keeps the discussion grounded. Zerompk is not just claiming speed against a named rival; it is also asking Rust developers to think about what they are paying for when they reach for serde, and whether the format, the trait layer, or the API design is where the slowdown really lives.

That makes Zerompk relevant in the places Rust performance work usually gets real: embedded systems, network services, data pipelines, and any workload where wire-format efficiency and allocation control matter. The crate’s no_std angle and zero-copy design point to developers who are willing to trade some flexibility for tighter control over layout, validation, and memory behavior. Zerompk’s pitch is simple enough to read in one glance, but ambitious enough to challenge a default that many Rust projects have treated as settled.