Lib.rs

bytes

Types and traits for working with bytes

serde_bytes

Optimized handling of &[u8] and Vec<u8> for Serde

byteorder

reading/writing numbers in big-endian and little-endian

bytesize

Semantic wrapper for byte count representations

wasm-encoder

A low-level WebAssembly encoder

byte-unit

interacting with units of bytes

smol_str

small-string optimized string type with O(1) clone

rmp

Pure Rust MessagePack serialization implementation

scroll

A suite of powerful, extensible, generic, endian-aware Read/Write traits for byte buffers

bytemuck

mucking around with piles of bytes

os_str_bytes

Lossless functionality for platform-native strings

const-hex

Fast byte array to hex string conversion

human_bytes

convert bytes into human-readable values

self_encryption

Self encrypting files (convergent encryption plus obfuscation)

atomic

Generic Atomic<T> wrapper type

bytestring

A UTF-8 encoded read-only string using Bytes as storage

writeable

A more efficient alternative to fmt::Display

tls_codec

A pure Rust implementation of the TLS (de)serialization

ubyte

complete, const-everything, saturating, human-friendly, no_std library for byte units

parse-size

Parse byte size into integer accurately

bstr

A string type that is not required to be valid UTF-8

bytes-utils

Additional utilities for working with the bytes crate

unicode-bom

Unicode byte-order mark detection for files and byte arrays

tokio-io-utility

Some helper functions for tokio::io

atomic-maybe-uninit

Atomic operations on potentially uninitialized integers

bytebuffer

networking and binary protocols

hexyl

A command-line hex viewer

bytes-varint

variable-length integer encoding (protobuf-style) for the bytes crate

dhat-to-flamegraph

Convert dhat JSON output to a flamegraph

tendril

Compact buffer/string type for zero-copy parsing

string

A UTF-8 encoded string with configurable byte storage

cobs

Consistent Overhead Byte Stuffing (COBS) algorithm. COBS is an algorithm for transforming a message into an encoding where a specific value (the "sentinel" value) is not used…

bufsize

bytes::BufMut implementation to count buffer size

arrow-ipc

Support for the Arrow IPC format

loupe

Profiling tool for Rust

file_type

File type detector

blobby

Iterator over simple binary blob storage

datasize

A simplified heap memory size estimator

serde-bytes-repr

Serde adapter for controlling the representation of bytes

bytecodec

A tiny framework for implementing encoders/decoders of byte-oriented protocols

midi2

Ergonomic, versatile, strong types wrapping MIDI 2.0 message data

human-repr

Generate beautiful human representations of bytes, durations, and even throughputs!

guacamole

linearly-seekable random number generator

imsz

Get width and height from an image file reading as few bytes as possible

wambo

All-in-one binary to convert decimal/bin/oct/hex + interpret data as i8-i64, u8-u64, and f32/f64

keket

Database-like Asset management on top of ECS storage

biodiff

Compare binary files using sequence alignment

linkedbytes

linked list of Bytes and BytesMut

nu_plugin_file

a nushell plugin called file

octseq

Abstractions for types representing octet sequences

cbored

CBOR exact reader and writer

serde_json_bytes

a JSON Value object with strings backed by Bytes, parsed by serde_json

jppe

byte stream structured serialization and deserialization library

endi

endian-handling library

rustdb

SQL database

jetscii

A tiny library to efficiently search strings and byte slices for sets of ASCII characters or bytes

autonomi

client API

countio

Byte counting for std::io::{Read, Write, Seek} and its async variants from futures and tokio

include_bytes_aligned

macro that embeds the bytes of an external file into the executable and guarantees that they are aligned

byte

A low-level, zero-copy and panic-free serializer and deserializer for binary

endian-num

Byte-order-aware numeric types

whitehole

fast, intuitive parser combinator framework for Rust

zncat

Command line relay for Zenoh

walle_mqtt_protocol

一个mqtt报文解析库

rustkey

— rust library for tillitis TKey application development

av-bitstream

bit writer/reader

include_data

Include typed data directly in your executable

tcp-handler

Conveniently transfer data in chunk through tokio TCP stream

arrow-row

Arrow row format

cheetah-string

A lightweight, high-performance string manipulation library optimized for speed-sensitive applications

tegra_swizzle

Tegra X1 block linear texture memory tiling

timely_communication

Communication layer for timely dataflow

print_bytes

Print bytes as losslessly as possible

const-serialize

A serialization framework that works in const contexts

octs

Finally, a good byte manipulation library

watto

parsing and serializing Plain Old Data

byte_reader

A minimal byte-by-byte reader for parsing input

oem_cp

that handles OEM code pages (e.g. CP{437,737,850}) for single byte character sets

humanize-bytes

Format byte sizes in human readable form

minicdn

Static files, compressed for efficiency

hyper_byte

An unsafe, near-zero cost (1-2 instructions) byte transmuter to numeric types with fast byte reader

caracat

A fast ICMP/UDP IPv4/v6 Paris traceroute and ping engine

tokio-util-codec-compose

Building blocks for composing tokio-util codecs

byteordered

Abstraction for reading and writing data with implicit byte order awareness

stupidfs

More files per file: hide files by storing them in the metadata of other files

line-wrap

Efficiently insert line separators

simple-bytes

A small and easy crate to mutate or read u8 slices

anybytes

A small library abstracting over bytes owning types in an extensible way

vc_8bit

This project is a virtual computer that takes a vector of bytes and runs it as instructions. Also included is a complete assembler and compiler.

aligned-buffer

A buffer with controllable alignment, that can be sealed and shared by reference count

libhydrogen

A modern and easy to use cryptography library

compact_bytes

A memory efficient bytes container that transparently stores bytes on the stack, when possible

toktrie

LLM Token Trie library

parquet-format-safe

Safe Parquet and Thrift reader and writer (sync and async)

density-rs

Superfast compression library

shared-buffer

An abstraction over buffers backed by memory-mapped files or bytes in memory

tick-encoding

encoding scheme to encode binary data into ASCII strings

wasm_dep_analyzer

Wasm module dependency analysis for module resolution

neofile

linux file command for windows. PATCH 4.

mcp2517

CAN controller

bytes_parser

wrapper to parse primitive Rust types from a slice of bytes

timely_bytes

Disjoint mutable byte slices from a common allocation

hi-doc-jumprope

fast rope (fancy string) library built on top of Skiplists - hi-doc fork

varuint

Variable length signed and unsigned integer types

rjiter

Streaming JSON parser on top of Jiter

bytelines

Read input lines as byte slices for high efficiency

jbytes

byte stream structured serialization and deserialization library

show-option

displaying Options

sfbinpack

read Stockfish Binpacks

base64-serde

Integration between rust-base64 and serde

binocle

A graphical tool to visualize binary data

polars-row

Row encodings for the Polars DataFrame library

syxpack

Helpers for processing MIDI System Exclusive messages

columnation

Unsafe columnar containers for native Rust types

human-units

Size and duration serialization and formatting library designed for configuration files and command line arguments

scuffle-bytes-util

working with bytes

twoten

human readable digest tool

bytey

convenient and easy to use byte storage

loro-kv-store

Key-value store component for Loro, a high-performance CRDTs framework

mser

bool_vec

A crates that exposes a vector called BoolVec which allows you to store a boolean in a single bit

abomonation

A high performance and very unsafe serialization library

hd

Hex Display: A modern xxd alternative

polars-parquet-format

Safe Parquet and Thrift reader and writer (sync and async)

rawcode

Implements a simple as-is encoding format

python_marshal

reading and writing Python marshal files

presence

Privacy friendly presence tokens

bebytes

serialization and deserialization of network structs

byteserde

A generic serialization/deserialization framework for mapping byte streams to/from arbitrary struct types with focus on performance

dns-protocol

A DNS protocol implementation in Rust

bytescale

Demonstration of humanbyte usage for human readable byte functions

craftflow-nbt

A serde-based NBT (from Minecraft) binary format implementation

ms-pdb-msfz

Reads Compressed Multi-Stream Files, which is part of the Microsoft PDB file format

friendly

Human-friendly display library

hidreport

HID Report Descriptor and HID Report parser

bpe-tokenizer

A BPE Tokenizer library

bytevec2

serialization library that uses byte vectors

postcard-cobs

Consistent Overhead Byte Stuffing (COBS) algorithm. COBS is an algorithm for transforming a message into an encoding where a specific value (the "sentinel" value) is not used…

typed-bytesize

Represent bytesize in decimal or binary prefix unit

transformable

Transform its representation between structured and bytes form

lbasedb

Low level DBMS in Rust focusing on datasets

tora

A lite, byte-based serialization and deserialization library

tapir-bf

Tapir is a moderately useful Brainfuck interpreter

append-only-bytes

Shareable append-only bytes

museair

Fast portable hash algorithm with highest bulk throughput and lowest small key latency (1-32 bytes) among portable hashes listed in SMHasher3, and made improvements for quality and usability

utf58

High-tech encoding of the Unicode space in one quibble and up to 3 bytes

sss-rs

A secret sharing scheme implemented in Rust

sanitation

developing memory-safe programs while detecting and capturing possibly malicious bytes

sketches-rust

DDSketch

ord-uuid

Creates lexically sortable uuid values of size 16 bytes

bencode2json

A Bencoded to JSON converter library and console app with no intermediary in-memory structure

hex-buffer-serde

Helper for serializing byte buffers as hex strings in serde

kib

embed-resources

embed resources (files, URLs, data) as byte arrays

bytesio

a network io library using tokio

byteorder-lite

reading/writing numbers in big-endian and little-endian

byte-transcoder

A Rust+Typescript library to transcode higher-level data types to/from bytes

framous

sending and receiving packets to and from a Reader/Writer

ethan-rs-wc

The ethan-rs-ws(erwc) is word, line, character, and byte count. Like wc command but not just wc command, more accurate and faster. Text can also be read from standard input for statistics.

bitchomp

reading in different types from a buffer of bytes

circbuf

A growable circular buffer for working with bytes

cbfr

A buffer that run on stack, focusing on performance and speed

sawp-ffi

FFI helper macros and traits

rkyv-owned-archive

Helpers for having owned Archived types in rkyv

cbvm

Cross bytes virtual machine used for building, running and reading CBVM files

podio

Additional trait for Read and Write to read and write Plain Old Data

serde-human-bytes

Optimized handling of &[u8] and Vec<u8> for Serde

penumbra-sdk-proto

Bindings and extension traits for Penumbra protobufs

mime_more

better MIME function integrations

tc_tea

Tencent's varient of TEA (tc_tea)

mqtt-bytes-v5

MQTT v5 serialization and deserialization

simple_parse

A declarative converter for Rust type to and from binary

ordered-varint

Byte-orderable, variable length encoding

bin-it

efficient Rust library for binary serialization and deserialization

aligned-buffer-pool

A buffer-pool with controllable alignment

byteutils

that provides a collection of frequently used utility functions for working with bytes, strings, and vectors. It includes common tasks such as converting between strings and byte arrays…

sqlite_ext_ntqq_db

A SQLite VFS extension to directly read NTQQ database files, skipping the leading bytes

lzfse

Rust bindings for the LZFSE reference implementation

oshash

https://pypi.org/project/oshash/ in Rust

rs2io

Types and utilities for processing io with a design heavily focused around the custom protocols used by the popular MMORPG Runescape

smol_buf

small-string optimized string / buffer type with O(1) clone

hubpack

A predictable serialization format

json-session

A streaming parser for JSON which emits fragments and location spans from an iterator-style API

streamcatcher

A thread-safe, shared (asynchronous), almost-lockless stream buffer

huby

(supporting serde) to handle byte sizes as human

bytestream

convenient way of writing binary data to a buffer

egui-video

a video library for egui

bitman

An easy to use bit manipulation library for Rust

parser-helper

Helpers for handling buffers of bytes

dns-protocol-patch

A DNS protocol implementation in Rust

CryptTool

A versatile and efficient cryptography library implemented in Rust

DEWQ

QR Code Generation Library

mimetype

detech mime type from file bytes

beetle_bits

A collection of bit-based types. Currently only u1 (1bit uint) and f3 (3bit float) are implemented

primitive-archiver

Primitive archiver

namaste

serde_atproto_dagjson

At protocol's version of DAG-JSON support for Serde

mmap_bytey_byte_buffer

Mmap Bytey MByteBuffer code, use Mmap Bytey instead

libload_reflective

A package to reflectively load libraries from memory

vu128

Efficient variable-length integers

gfarch

Good-Feel's GoodFeelArchives

fortran-descriptor-parser

Parse bytes which are formatted according to a fortran format edit descriptor

orio

Small serialization library

byte_counter

Timestamped byte counter

lize

A stupid way of serializing and deserializing really small data into bytes. Supports recursive data structures.

serde_tran

helper to serde your data into encoded bytes

le-stream

De-/serialize objects from/to little endian byte streams

timely-bytes-master

Disjoint mutable byte slices from a common allocation

byte-calc

Helper crate to work with bit, byte, and block sizes

number-bytes

trait for converting generic numeric types to and from bytes

swimos_byte_channel

SwimOS Byte Channel

ed

Encode and Decode traits

png_filters

PNG filtering related functions

block-db

Local Byte DB

doge_dns

The dns interaction component of the doge package

supply-chain-trust-example-crate-000061

reading/writing numbers in big-endian and little-endian

byteserde_types

A procedural macro for mapping byte streams to/from arbitrary struct types with focus on performance

hid-io-protocol

HID-IO protocol implementation for both servers and devices. Devices are optimized for Cortex-M devices, but may work for other platforms

primitive-byte-iter

An Iterator which can load primitive types and glam types from bytes

msgpck

A no-std and async compatible msgpck de/serializer

byte-size

An effective short string shrinker with total disregard for speed, memory usage and executable size

chainbuf

Fast chained buffers

byte_set

Efficient sets of bytes

cobs-rs

A minimal no-std library for doing Consistent Overhead Byte Stuffing

spacepacket

A CCSDS compliant spacepacket en/de-coder with CRC and Sink/Stream support

fr_alebref_libbrefdata

BrefData library

aligners

alignment guarantees for data

byte-tools

Bytes related utility functions

sha-to-hex

function to encode string using secret and return hex string

bytes-kman

serialize and deserialize bytes, a simple way to comunicate to other computer or to save state!

neutrondb

log-structured merge-tree key-value store for any implemented data type

distrans_fileindex

Distrans file indexing

kvarn_utils

HTTP and Rust utilities used in the Kvarn web server

absolut

Autogenerated Bytewise SIMD-Optimized Look-Up Tables

castflip

encoding/decoding numeric variables, arrays and structures in little-endian and big-endian

arc-bytes

A reference-counted byte buffer

midi-convert

converting into/from midi_types::MidiMessage

unbytes

Panic-free reading of bytes

big_unsigned_ints

Big Unsigned Integers ranging from U256 to U2048 using u64 arrays all under a fixed-size of 32

rcbytes

Rc version bytes crate

dbus-message-parser

Libary to encode and decode DBus message

varu64

A variable length encoding for unsigned 64 bit integers

nombytes

that provides a wrapper for the bytes::Bytes byte container for use with nom

generic-bytes

A derivable trait for conversion to and from an array of bytes with a type-level size

streamvbyte64

stream-vbyte codec supporting 64-bit wide values