Bincode-Next

Bincode-Next is a high-performance binary encoder/decoder pair that uses a zero-fluff encoding scheme. It is a modernized fork of the original bincode library, maintained by the Apich Organization to ensure continued development and extreme performance optimizations for the Rust ecosystem.

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.

Key Features

• Performance: Leverages SIMD (SSE2 on x86_64, NEON on AArch64) for rapid varint scanning and bulk primitive copying for massive throughput.
• Zero-Copy: Nested Zero-copy support via Relative Pointers and Const Alignment. (optional feature, using the zerocopy feature to enable)
• Bit-Packing: Bit-level Packing for Space-Optimized Serialization. (optional, using the BitPacked derive macro with the config::standard().with_bit_packing() config to enable)
• Schema Fingerprinting: Schema Fingerprinting for Safe Versioning. (optional, using the config::standard().with_fingerprint() with the derive macro Fingerprint to enable)
• Compile-time Memory Bound Validation: Compile-time Memory Bound Validation via Const Generics. (optional feature, enable the static-size feature to use it)
• Stream Support: Works seamlessly with std::io (Reader/Writer) and no_std environments.

Getting Started

Add bincode-next to your Cargo.toml:

[dependencies]
bincode-next = "3.0.0-rc.5"

Basic Example

use bincode_next::{config, Decode, Encode};

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

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

fn main() {
    let config = config::standard();

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

    // Encode to a Vec<u8>
    let encoded: Vec<u8> = bincode_next::encode_to_vec(&world, config).unwrap();

    // Decode from a slice
    let (decoded, len): (World, usize) = bincode_next::decode_from_slice(&encoded[..], config).unwrap();

    assert_eq!(world, decoded);
    assert_eq!(len, encoded.len());
}

Bit-Packing Example

Enable bit-packing in your configuration to use bit-level field sizing:

use bincode_next::{config, BitPacked};

#[derive(BitPacked, PartialEq, Debug)]
struct Packed {
    #[bincode(bits = 3)]
    a: u8,
    #[bincode(bits = 5)]
    b: u8,
}

fn main() {
    let config = config::standard().with_bit_packing();
    let val = Packed { a: 7, b: 31 };
    
    let encoded = bincode_next::encode_to_vec(&val, config).unwrap();
    // 'a' (3 bits) + 'b' (5 bits) = 8 bits (1 byte)
    assert_eq!(encoded.len(), 1); 
}

Performance Optimizations

Bincode-Next includes advanced optimizations for extreme performance:

• SIMD Varint Scanning: Accelerates decoding of collections (like Vec<u64>) by scanning for small values using SSE2 or NEON instructions.
• Bulk Native Copy: Automatically detects when data can be copied directly from memory (e.g., slices of primitives with matching endianness) to avoid element-wise processing.
• Uninitialized Memory: Utilizes MaybeUninit and set_len optimizations for Vec decoding to avoid redundant zero-initialization.

git clone https://github.com/Apich-Organization/bincode.git
cd bincode
# We need root permission and use nightly compiler to ensure the most accurate result
sudo cargo +nightly bench --bench extreme_perf
sudo cargo +nightly bench --bench complex

TL;DR:Please visit https://bincode-next.apich.org/ for more detailed information.

Performance Comparison: Decoding

Baseline: bincode-next (traits, varint) at 16.878 µs

Performance Comparison: Encoding

Baseline: bincode-next (traits, fixed) at 2.9350 µs

Efficiency Score: Combined Round-Trip Performance

Sum of Median Decode + Median Encode (Normalized to the fastest = 1.00x)

Vector u64 Decoding: Varint Performance

Contrasting small vs. large integer varint decoding.

Vector u64 Decoding: Fixed Performance

Baseline: bincode-next (current) at 1.8373 µs

Bulk u8 Decoding: Throughput Performance

Baseline: bincode-next (current) at 160.44 ns

About Security and Code Quality

For security issues, please visit the Security Team Homepage for more details on reporting.

All code tests passed miri and all main crate source code passed clippy without errors.

MIRIFLAGS="-Zmiri-disable-isolation" cargo +nightly miri test --all-features --no-fail-fast
cargo clippy --all-features

We remain committed to code security and welcomed security reporting.

And please notice that contributors shall follow the community guide lines of bincode-next.

Specification

The formal wire-format specification is available in docs/spec.md.

FAQ

Why Bincode-Next?

Bincode-Next was created to continue the legacy of the original Bincode project while pushing the boundaries of what's possible with modern Rust performance techniques and AI-assisted development.

Is it compatible with Bincode 1.x / 2.x?

Yes, Bincode-Next is designed to be wire-compatible with Bincode 2.x when using the same configurations. It also supports legacy 1.x formats via configuration.

Contributing

We welcome contributions! Please see CONTRIBUTING.md for more details.

License

Bincode-Next is licensed under either of:

• The MIT License (MIT)
• The Apache License, Version 2.0

See LICENSE.md for details.