bytes

Bytes is a foundational Rust utility crate from the Tokio project for storing and operating on contiguous slices of memory. Its core Bytes type is a cheaply cloneable, sliceable buffer that enables zero-copy network programming: multiple handles can point to the same underlying, reference-counted memory, each with its own view, so passing buffers around never copies the payload.

Alongside the owned Bytes and mutable BytesMut containers, the crate provides the Buf and BufMut traits, which offer cursor-based, infallible read and write access over any byte storage (contiguous or chunked). It is no_std-compatible and sits at the base of much of the Rust async and networking ecosystem, including Hyper, Tonic, and Tokio itself.

What You Get

• Bytes, a cheaply cloneable and sliceable owned buffer backed by reference-counted shared memory
• BytesMut, a mutable buffer that can be split into owned, immutable Bytes views without reallocation
• The Buf and BufMut traits for cursor-based, infallible reads and writes over arbitrary byte storage
• no_std support and optional Serde integration behind feature flags
• Adapters such as Chain, Take, Limit, and Reader/Writer bridges to std::io

Common Use Cases

• Parsing and framing network protocols where a received buffer is sliced into headers and payloads without copying
• Building async servers and clients on Tokio, Hyper, or Tonic that pass shared buffers between layers
• Accumulating outgoing data in a BytesMut and splitting off completed frames to hand to the transport
• Reading fixed-width integers and byte sequences from a stream via the Buf trait’s typed getters

Under The Hood

Architecture - The crate is organized around two concrete containers in src/bytes.rs and src/bytes_mut.rs and a trait layer in src/buf/. Bytes is a 4-usize struct holding a data pointer, a length, and a pointer to shared state plus a Vtable of function pointers (clone, to_vec, to_mut, is_unique, drop); this dynamic-dispatch design lets one type transparently back static memory, Vec<u8>, or Arc-shared storage while keeping slicing and cloning cheap. BytesMut manages a growable allocation with an atomic reference count so that split/split_to can hand out disjoint owned views. The buf module layers Buf/BufMut traits over any storage and ships adapters (Chain, Take, Limit, Reader, Writer).

Tech Stack - Pure Rust targeting edition 2021 with an MSRV of 1.57 and a #![no_std] core that pulls in alloc. It has zero required dependencies; serde (data formats) and portable-atomic (atomic CAS on constrained targets) are optional feature-gated deps, and loom is used only for concurrency testing. The standard library is opt-in via the default std feature.

Code Quality - Quality is exceptional: the tests/ directory holds roughly 200 test functions across 12 files, including dedicated allocator-behavior tests (test_bytes_odd_alloc.rs, test_bytes_vec_alloc.rs) and loom-based concurrency model checking for the atomic reference-counting paths. Unsafe pointer code is carefully commented, bounds checking is centralized in a range helper, and there is a Miri-checked CI pipeline. Naming is consistent and the public surface is thoroughly documented with runnable doc examples.

API Design - The public API is small, ergonomic, and discoverable: two container types plus two traits cover the whole surface. Typed accessors (get_u16, put_u32, try_get_*) make protocol code read cleanly, From impls accept &[u8], Vec<u8>, and &'static str, and getting started requires nothing more than use bytes::{Bytes, BytesMut, Buf, BufMut}. Documentation on docs.rs is comprehensive with feature-gate annotations.