Crate bincode 

Bincode is a crate for encoding and decoding using a tiny binary serialization strategy. Using it, you can easily go from having an object in memory, quickly serialize it to bytes, and then deserialize it back just as fast!

If you’re coming from bincode 1, check out our migration guide

Serde

Starting from bincode 2, serde is now an optional dependency. If you want to use serde, please enable the serde feature. See Features for more information.

Features

Name	Default?	Affects MSRV?	Supported types for Encode/Decode	Enabled methods	Other
std	Yes	No	HashMap and HashSet	decode_from_std_read and encode_into_std_write
alloc	Yes	No	All common containers in alloc, like Vec, String, Box	encode_to_vec
atomic	Yes	No	All Atomic* integer types, e.g. AtomicUsize, and AtomicBool
derive	Yes	No			Enables the BorrowDecode, Decode and Encode derive macros
serde	No	Yes (MSRV reliant on serde)	Compat and BorrowCompat, which will work for all types that implement serde’s traits	serde-specific encode/decode functions in the serde module	Note: There are several known issues when using serde and bincode

Which functions to use

Bincode has a couple of pairs of functions that are used in different situations.

Situation	Encode	Decode
You’re working with fs::File or net::TcpStream	encode_into_std_write	decode_from_std_read
you’re working with in-memory buffers	encode_to_vec	decode_from_slice
You want to use a custom Reader and Writer	encode_into_writer	decode_from_reader
You’re working with pre-allocated buffers or on embedded targets	encode_into_slice	decode_from_slice

Note: If you’re using serde, use bincode::serde::... instead of bincode::...

Untrusted input

The *_untrusted decoding functions opt into collection allocation safeguards. Ordinary decoding functions retain upstream 2.0.1 behavior. Untrusted functions require the independent DecodeUntrusted/BorrowDecodeUntrusted traits. Derive only DecodeUntrusted for client types that should not support ordinary decoding, or derive both traits when both APIs are intended. Nested values dispatch through the corresponding untrusted trait. These implementations own guarded allocation; ordinary Decode is independent of the decoder capability. Manual implementations must also call the untrusted traits for nested values. Both paths retain the same configuration and wire format.

#[derive(bincode::DecodeUntrusted)]
struct Message { value: u8 }
let (message, consumed): (Message, _) = bincode::decode_from_slice_untrusted(
    &[42], bincode::config::standard(),
).unwrap();
assert_eq!(message.value, 42);
assert_eq!(consumed, 1);

With Serde, custom implementations explicitly implement serde::DeserializeUntrusted for their entire deserialization graph. Serde constructors expose constrained decode/decode_seed methods in this mode.

Untrusted native vector and hash collection implementations allocate storage after entries decode. Byte vectors first verify the available payload, or read bounded chunks when the reader cannot expose it. Failed reservations in these containers return error::DecodeError::LimitExceeded. Serde adapters omit collection size hints that could otherwise cause visitors to allocate from an unchecked length.

These safeguards are not a general memory, recursion, or CPU budget. Custom decoders and Serde visitors remain responsible for their own resource use; types that consume no bytes can still decode from arbitrarily large counts. Existing configured limits retain their meaning, including with_no_limit(). Failed untrusted byte-vector reads may consume earlier chunks and report a missing-byte estimate for the failing chunk. Successful values and consumed lengths are unchanged; hash collection iteration order is unspecified.

Example

let mut slice = [0u8; 100];

// You can encode any type that implements `Encode`.
// You can automatically implement this trait on custom types with the `derive` feature.
let input = (
    0u8,
    10u32,
    10000i128,
    'a',
    [0u8, 1u8, 2u8, 3u8]
);

let length = bincode::encode_into_slice(
    input,
    &mut slice,
    bincode::config::standard()
).unwrap();

let slice = &slice[..length];
println!("Bytes written: {:?}", slice);

// Decoding works the same as encoding.
// The trait used is `Decode`, and can also be automatically implemented with the `derive` feature.
let decoded: (u8, u32, i128, char, [u8; 4]) = bincode::decode_from_slice(slice, bincode::config::standard()).unwrap().0;

assert_eq!(decoded, input);

Re-exports

pub use de::BorrowDecode;

pub use de::BorrowDecodeUntrusted;

pub use de::Decode;

pub use de::DecodeUntrusted;

pub use enc::Encode;

Modules

config

The config module is used to change the behavior of bincode’s encoding and decoding logic.

de

Decoder-based structs and traits.

enc

Encoder-based structs and traits.

error

Errors that can be encounting by Encoding and Decoding.

migration_guide

Migrating from bincode 1 to 2

serdeserde

Support for serde integration. Enable this with the serde feature.

specalloc and derive

Serialization Specification

Macros

impl_borrow_decode

Helper macro to implement BorrowDecode for any type that implements Decode.

impl_borrow_decode_untrusted

Implement borrowed untrusted decoding by delegating to an explicit owned implementation.

impl_borrow_decode_with_context

Helper macro to implement BorrowDecode for any type that implements Decode.

Structs

IoReaderstd and (alloc or derive or serde or std)

Adapts a standard reader for bincode’s Reader trait.

Functions

borrow_decode_from_slice

Attempt to decode a given type D from the given slice. Returns the decoded output and the amount of bytes read.

borrow_decode_from_slice_untrusted

Borrow-decode from a slice with the untrusted collection safeguards. Returns the decoded value and the number of bytes consumed.

borrow_decode_from_slice_untrusted_with_context

Borrow-decode with a context and the untrusted collection safeguards. Returns the decoded value and the number of bytes consumed.

borrow_decode_from_slice_with_context

Attempt to decode a given type D from the given slice with Context. Returns the decoded output and the amount of bytes read.

decode_from_reader

Attempt to decode a given type D from the given Reader.

decode_from_reader_untrusted

Decode from a custom reader with the untrusted collection safeguards.

decode_from_slice

Attempt to decode a given type D from the given slice. Returns the decoded output and the amount of bytes read.

decode_from_slice_untrusted

Decode from a slice with the untrusted collection safeguards. Returns the decoded value and the number of bytes consumed.

decode_from_slice_untrusted_with_context

Decode from a slice with a context and the untrusted collection safeguards. Returns the decoded value and the number of bytes consumed.

decode_from_slice_with_context

Attempt to decode a given type D from the given slice with Context. Returns the decoded output and the amount of bytes read.

decode_from_std_readstd

Decode type D from the given reader with the given Config. The reader can be any type that implements std::io::Read, e.g. std::fs::File.

decode_from_std_read_untrustedstd

Decode from a standard reader with the untrusted collection safeguards.

decode_from_std_read_untrusted_with_contextstd

Decode from a standard reader with a context and the untrusted collection safeguards.

decode_from_std_read_with_contextstd

Decode type D from the given reader with the given Config and Context. The reader can be any type that implements std::io::Read, e.g. std::fs::File.

encode_into_slice

Encode the given value into the given slice. Returns the amount of bytes that have been written.

encode_into_std_writestd

Encode the given value into any type that implements std::io::Write, e.g. std::fs::File, with the given Config. See the config module for more information. Returns the amount of bytes written.

encode_into_writer

Encode the given value into a custom Writer.

encode_to_vecalloc

Encode the given value into a Vec<u8> with the given Config. See the config module for more information.

Derive Macros

BorrowDecodederive

BorrowDecodeUntrustedderive

Decodederive

DecodeUntrustedderive

Encodederive