#binary-encoding #serialization #binary #deserialize #networking #codec

bincode2

A binary serialization / deserialization strategy that uses Serde for transforming structs into bytes and vice versa!

2 stable releases

Uses old Rust 2015

2.0.1 Jan 20, 2020

#1113 in Encoding

Download history 1152/week @ 2024-11-17 866/week @ 2024-11-24 921/week @ 2024-12-01 2313/week @ 2024-12-08 2529/week @ 2024-12-15 401/week @ 2024-12-22 827/week @ 2024-12-29 2402/week @ 2025-01-05 2106/week @ 2025-01-12 2097/week @ 2025-01-19 2210/week @ 2025-01-26 2790/week @ 2025-02-02 3014/week @ 2025-02-09 2943/week @ 2025-02-16 3553/week @ 2025-02-23 3900/week @ 2025-03-02

13,537 downloads per month
Used in 34 crates (14 directly)

MIT license

76KB
2K SLoC

Bincode 2

A maintained fork of the now-defunct Bincode.

A compact encoder / decoder pair that uses a binary zero-fluff encoding scheme. The size of the encoded object will be the same or smaller than the size that the object takes up in memory in a running Rust program.

In addition to exposing two simple functions (one that encodes to Vec<u8>, and one that decodes from &[u8]), binary-encode exposes a Reader/Writer API that makes it work perfectly with other stream-based APIs such as Rust files, network streams, and the flate2-rs compression library.

API Documentation

Bincode in the wild

  • google/tarpc: Bincode is used to serialize and deserialize networked RPC messages.
  • servo/webrender: Bincode records webrender API calls for record/replay-style graphics debugging.
  • servo/ipc-channel: IPC-Channel uses Bincode to send structs between processes using a channel-like API.

Example

use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize, PartialEq, Debug)]
struct Entity {
    x: f32,
    y: f32,
}

#[derive(Serialize, Deserialize, PartialEq, Debug)]
struct World(Vec<Entity>);

fn main() {
    let world = World(vec![Entity { x: 0.0, y: 4.0 }, Entity { x: 10.0, y: 20.5 }]);

    let encoded: Vec<u8> = bincode2::serialize(&world).unwrap();

    // 8 bytes for the length of the vector, 4 bytes per float.
    assert_eq!(encoded.len(), 8 + 4 * 4);

    let decoded: World = bincode2::deserialize(&encoded[..]).unwrap();

    assert_eq!(world, decoded);
}

Details

The encoding (and thus decoding) proceeds unsurprisingly -- primitive types are encoded according to the underlying Writer, tuples and structs are encoded by encoding their fields one-by-one, and enums are encoded by first writing out the tag representing the variant and then the contents.

However, there are some implementation details to be aware of:

  • isize/usize are encoded as i64/u64, for portability.
  • enums variants are encoded as a u32 instead of a usize. u32 is enough for all practical uses.
  • str is encoded as (u64, &[u8]), where the u64 is the number of bytes contained in the encoded string.

Dependencies

~180–435KB