>> rusts type system is strong enough to build extremely powerful zerocopy serialization > Unclear what you mean, but other than syn and quote you don't have a

>> rusts type system is strong enough to build extremely powerful zerocopy serialization > Unclear what you mean, but other than syn and quote you don't have a way to reflect and do code gen, outside of build script. Which also use it. > Note there are alternative like mini serde and nano serde, but no library for type reflection. Reflection/comptime/codegen are all orthogonal to zero copy (de)serialization. To briefly(ish) describe zero copy by way of comparison, consider JSON: there's no way to parse a JSON object into your language's data structures without (among other things) copying any strings you come across (rather than directly borrowing a slice of the original buffer). Why not? Consider escapes: you must first unescape the string, which entails a new allocation. But this doesn't stop at strings: if you have an array, you must first parse that array (usually accumulating a copy of the elements in a Vec<Object> or similar, which in turn means that the whole array was effectively copied), rather than providing a "cursor" into the original buffer. Parsing JSON requires traversing the entire buffer and copying everything you come across. Protocol buffers works much the same way: because structures are variable length (and in fact, scalars are too -- integers are stored as base 128 varints), if you want the Nth element of an array, you have no choice but to parse all the proceeding elements (rather than nudging a cursor's offset by N×sizeof(Elem) -- you can't do that because the size of any element is unknown until after you've parsed it). Because you want O(1) indexing after parsing, the logical implication is that whenever you parse a protobuf message, the protobuf library parses (and copies) the entire thing, and any array/repeated field ends up as a new array allocation in your language (e.g. Vec<Elem>). Contrast with something like flatbuffers or Cap'n Proto: the code generated from your schema file gives you structures that (more or less) have two fields: a reference to a buffer, and an offset into that buffer. When you do something like person.age(), the offset of the age field (which is constant) is added to the offset of this person record, and that combined offset if used to index into the buffer (something like buffer.read_u32(offset)). Using a library like this gives you performance similar to what you'd have dereferencing array indices and struct fields in plain old data types in your language of choice. You don't pay in memory and processor time parsing everything up front, you only pay for the scalar memory reads you actually use (and a little bit of quasi-pointer chasing, not unlike what would happen with native structs). Put another way: a zero copy (de)serialization protocol is one where the on-disk format is the same as the (readily usable) in-memory format. This rules out things like string escaping (just store the original bytes), variable sized records/integers, variable length arrays stored inline with records (otherwise that would make records themselves variable length), storing pointers in records (because those pointers will be meaningless when read from disk; instead: store offsets), etc. You can read more about zero copy as it relates to Rust here: https://manishearth.github.io/blog/2022/08/03/zero-copy-1-not-a-yoking-matter/ https://manishearth.github.io/blog/2022/08/03/zero-copy-1-no... Here's the Wikipedia article: https://en.wikipedia.org/wiki/Zero-copy https://en.wikipedia.org/wiki/Zero-copy Examples of zero copy (de)serialization libraries: https://github.com/rkyv/rkyv https://github.com/rkyv/rkyv https://github.com/google/flatbuffers https://github.com/google/flatbuffers https://github.com/capnproto/capnproto https://github.com/capnproto/capnproto