#binary #encode #decode #serialize #deserialize


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

48 releases (8 stable)

1.2.1 Dec 10, 2019
1.2.0 Sep 24, 2019
1.1.4 May 15, 2019
1.1.2 Feb 16, 2019
0.0.2 Nov 24, 2014

#5 in Encoding

Download history 55224/week @ 2019-10-04 54745/week @ 2019-10-11 59620/week @ 2019-10-18 60016/week @ 2019-10-25 60232/week @ 2019-11-01 61373/week @ 2019-11-08 64984/week @ 2019-11-15 63265/week @ 2019-11-22 57373/week @ 2019-11-29 67786/week @ 2019-12-06 65038/week @ 2019-12-13 37214/week @ 2019-12-20 31214/week @ 2019-12-27 58873/week @ 2020-01-03 63166/week @ 2020-01-10

254,180 downloads per month
Used in 785 crates (471 directly)

MIT license



Build Status

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.


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> = bincode::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 = bincode::deserialize(&encoded[..]).unwrap();

    assert_eq!(world, decoded);


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.