zerocopy
makes zero-cost memory manipulation effortless. We write "unsafe" so you don't have to.
getrandom
A small cross-platform library for retrieving random data from system source
smallvec
'Small vector' optimization: store up to a small number of items on the stack
crc32fast
Fast, SIMD-accelerated CRC32 (IEEE) checksum computation
nalgebra
General-purpose linear algebra library with transformations and statically-sized or dynamically-sized matrices
ndarray
An n-dimensional array for general elements and for numerics. Lightweight array views and slicing; views support chunking and splitting.
rustc-hash
A speedy, non-cryptographic hashing algorithm used by rustc
etherparse
parsing & writing a bunch of packet based protocols (EthernetII, IPv4, IPv6, UDP, TCP ...)
simdutf8
SIMD-accelerated UTF-8 validation
sonic-rs
fast Rust JSON library based on SIMD
serde_bytes
Optimized handling of
&[u8]andVec<u8>for Serde
linkme
Safe cross-platform linker shenanigans
bytecount
count occurrences of a given byte, or the number of UTF-8 code points, in a byte slice, fast
postcard
A no_std + serde compatible message library for Rust
bitvec
Addresses memory by bits, for packed collections and bitfields
zeroize
Securely clear secrets from memory with a simple trait built on stable Rust primitives which guarantee memory is zeroed using an operation will not be 'optimized away' by the compiler…
imgref
A basic 2-dimensional slice for safe and convenient handling of pixel buffers with width, height & stride
bytemuck
mucking around with piles of bytes
palette
Convert and manage colors with a focus on correctness, flexibility and ease of use
atoi
Parse integers directly from
[u8]slices in safe code
arrayref
Macros to take array references of slices
borsh
Binary Object Representation Serializer for Hashing
zerovec
Zero-copy vector backed by a byte array
ecow
Compact, clone-on-write vector and string
bincode-next
A compact, ultra-fast binary serialization format for Rust, optimized for networking and storage!
trie-db
Merkle-Patricia Trie generic over key hasher and node encoding
array-bytes
A collection of Array/Bytes/Hex utilities with full No-STD compatibility
diff
An LCS based slice and string diffing implementation
prettydiff
Side-by-side diff for two files
extendr-api
Safe and user friendly bindings to the R programming language
tls_codec
A pure Rust implementation of the TLS (de)serialization
typed-index-collections
Typed index version of Rust slice and Vec containers
revision
A serialization and deserialization implementation which allows for schema-evolution
aligned-vec
Aligned vector and box containers
circular-buffer
Efficient circular buffer implementation
byte-slice-cast
Safely cast bytes slices from/to slices of built-in fundamental numeric types
gix-config-value
gitoxide project providing git-config value parsing
gix-quote
gitoxide project dealing with various quotations used by git
zlib-rs
A memory-safe zlib implementation written in rust
musli
Müsli is a flexible and efficient serialization framework
mlx-rs
Unofficial rust wrapper for Apple's mlx machine learning library
bitter
Swiftly extracts unaligned bit-level data from a byte slice
str_indices
Count and convert between indexing schemes on string slices
pretty-hex
Pretty hex dump of bytes slice in the common style
core_extensions
Extensions for core/std library types, and other miscelaneous features
mitsein
Strongly typed APIs for non-empty collections, slices, and iterators
gix-refspec
gitoxide project for parsing and representing refspecs
alphanumeric-sort
can help you sort order for files and folders whose names contain numerals
elliptic-curve-tools
Extra Rust-Crypto elliptic-curve adaptors, functions, and macros
bitreader
reading individual bits from a slice of bytes. You can read "unusual" numbers of bits from the byte slice, for example 13 bits at once. The reader internally keeps track of position within the buffer.
linear-srgb
Fast linear↔sRGB color space conversion with FMA acceleration and LUT support
managed
An interface for logically owning objects, whether or not heap allocation is available
tui-piechart
A customizable pie chart widget for Ratatui TUI applications
kawa
Agnostic representation of HTTP/1.1 and HTTP/2.0 for parsing, generating and translating HTTP messages, with zero-copy, made for Sōzu
arrow-array
Array abstractions for Apache Arrow
pct-str
Percent-encoded strings for URL, URI, IRI, etc
epserde
ε-serde is an ε-copy (i.e., almost zero-copy) serialization/deserialization framework
plain
A small Rust library that allows users to reinterpret data of certain types safely
btoi
Parse integers directly from ASCII byte slices
bao-tree
BLAKE3 verfiied streaming with custom chunk groups and range set queries
crop
A pretty fast text rope
bao
BLAKE3 verified streaming
slice-command
slice is a command-line tool that allows you to slice the contents of a file using syntax similar to Python's slice notation
prettytable-rs
printing pretty formatted tables in terminal
multitude
Fast and flexible arena allocator
msg_parser
Outlook Email Message (.msg) parser
bitflagset
Enum and positional typed bitsets with Set API
outref
Out reference
link-section
Link-time initialized slices for Rust, with full support for Linux, macOS, Windows, WASM and many more platforms
hamming-bitwise-fast
Fast bitwise Hamming distance using auto-vectorization with runtime SIMD detection on x86
beef
More compact Cow
dyn-stack
Dynamic stack wrapper for unsized allocations
byteview
Thin, immutable zero-copy slice type
hipstr
string for Rust: zero-cost borrow and slicing, inline representation for small strings, (atomic) reference counting
mmap-io
Zero-copy memory-mapped file I/O for Rust. Safe concurrent reads, writes, and atomic views across Linux, macOS, and Windows. Built for databases, log structures, game runtimes, caches, and IPC.
soa-rs
A Vec-like structure-of-arrays container
json-escape
A no_std, zero-copy, allocation-free library for streaming JSON string escaping and unescaping. Ergonomic, fast, RFC 8259 compliant, with layered APIs for iterators, I/O streaming, and low-level tokens.
platform-mem
Memory for linksplatform
encode_unicode
UTF-8 and UTF-16 character types, iterators and related methods for char, u8 and u16
interp
Matlab's interp1 function
orx-concurrent-vec
A thread-safe, efficient and lock-free vector allowing concurrent grow, read and update operations
oxicode
A modern binary serialization library - successor to bincode
slice-dst
Slice-based custom DSTs
ag
CLI App to slice and dice logfiles
slicec
The Slice parser and other core components for Slice compilers
omeco
Tensor network contraction order optimization
dithereens
Functions & traits for quantizing values with error-diffusion
lebe
Tiny, dead simple, high performance endianness conversions with a generic API
stackalloc
Safely allocate and manipulate arbitrarily-sized slices on the stack at runtime
lowdash
A Lodash inspired utility library to manipulate array and object for Rust
scx_cosmos
Lightweight scheduler optimized for preserving task-to-CPU locality. https://github.com/sched-ext/scx/tree/main
radsort
Radix sort implementation for sorting by scalar keys (integers, floats, chars, bools)
scx_rlfifo
FIFO scheduler in Rust that runs in user-space
slice-group-by
Iterators over groups in slices and strs
anybytes
A small library abstracting over bytes owning types in an extensible way
tokio-io-utility
Some helper functions for tokio::io
sciparse
Zero-copy SCION packet parsing, serialization and control plane components
binary-layout
allows type-safe, inplace, zero-copy access to structured binary data. You define a custom data layout and give it a slice of binary data, and it will allow you to read and write the…
scx_flash
A scheduler designed for multimedia and real-time audio processing workloads. https://github.com/sched-ext/scx/tree/main
as-slice
AsSliceandAsMutSlicetraits
hash-db
Trait for hash-keyed databases
ndarray-slice
Fast and robust slice-based algorithms (e.g., sorting, selection, search) for non-contiguous (sub)views into n-dimensional arrays
toodee
A lightweight 2D wrapper around a Vec
cookie-factory
nom inspired serialization library
bitbuffer
Reading bit sequences from a byte slice
slice-ring-buffer
A double-ended queue that Deref's into a slice
oxideav-ffv1
Pure-Rust FFV1 (RFC 9043) lossless intra-only video codec for oxideav
jetscii
A tiny library to efficiently search strings and byte slices for sets of ASCII characters or bytes
out
fast min and max functionality for collections
mago-bytes
Shared byte-slice utilities for the Mago toolchain: lossy UTF-8 display wrapper, byte trimming helpers
repe
RPC protocol (JSON-focused)
beve
(Binary Efficient Versatile Encoding) specification with serde support
kira-spatial
Deterministic orchestrator for spatial transcriptomics: IO, field transforms, core math, and 3D export
str-macro
The str!() macro, similar to vec![] but for strings
trimothy
Traits for trimming slices, vecs, and strings
easyfft
providing an easy FFT API for arrays and slices
bevy_aseprite_ultra
A Bevy plugin for directly loading spritesheets and animations from aseprite binary files with hot reloading support
hex-display
Display impl for byte slices which provides a hexdump
csgrs
Constructive solid geometry (CSG) on meshes using BSP trees in Rust
extfmt
Extended formatting options for commmon types
morok-tensor
High-level lazy tensor API for the Morok ML compiler
capwriter
Fast saving and loading with annotating cap for vector and slice
oxideav-magicyuv
Pure-Rust MagicYUV lossless decoder for the oxideav framework
scursor
Secure cursor library with support for read and write transactions
purrdf
umbrella crate: RDF 1.2 implementation, slices, and SHACL/ShEx shape validation
yap
Parser library. A lightweight, dependency free, parser combinator inspired set of utility methods to help with parsing strings and slices.
scanner-rust
text scanners which can parse primitive types and strings using UTF-8 or ASCII
nunny
the definitive non-empty slice/array/vec library for Rust
stumpalo
A fast, zero-dependency, memory efficient bump allocator with chunk reuse and scoped stack support
substring
method for string types
oxideav-jpegxs
Pure-Rust JPEG XS (ISO/IEC 21122) low-latency image codec for production / IP video. Round-1 scaffold: codestream marker parsing only; pixel decode pending.
ffi_types
C ABI compatible wrappers for cbindgen/bindgen
ord_subset
Tools for working with the Ord subset of certain PartialOrd types, like floats
display-more
helper to display various types
n_circular_array
An n-dimensional circular array
bit_mask_ring_buf
A ring buffer implementation with cheap indexing
secure-types
Secure data types that protect sensitive data in memory via locking and zeroization
libdd-tinybytes
Tiny implementation of a bytes::Bytes like type that supports AsRef<[u8]>
slice_ring_buf
A ring buffer implementation optimized for working with slices
value-traits
By-value slices and iterators
emc
Event Model Compiler for deterministic event-model authoring, validation, and proof artifact generation
off64
Read from and write to byte slices with u64 offsets
ikigai-llm
Flexible LLM inference as ikigai ROC resources: urn:llm:ask (a facade grammar) dispatches to pluggable backends. Slice 0 ships an OpenAI-compatible REST backend covering Ollama / vLLM / llama…
to_segments
Ergonomic string splitting with readable methods for common manipulation tasks — cleaner alternative to .split().collect() chains
compile_time_sort
Sort arrays and slices of primitives in const contexts
linktime
Link-time registration patterns for Rust (ctors, dtors, link-time slices and sections)
bytearray-ringbuffer
A no_std, no-alloc ring buffer for variable-length byte slices in Rust
lorawan
structures and tools for reading and writing LoRaWAN messages from and to a slice of bytes
picoring
High-performance, zero-copy circular buffer for Rust using hardware memory mirroring
timely_bytes
Disjoint mutable byte slices from a common allocation
assay-runner-linux
Internal/experimental substrate for Assay measured-run workflows. Linux-only platform adapter for the Assay-Runner candidate; hosts cgroup placement primitives (Phase 2D Slice 3). No…
oxideav-bitstream
Minimal IDR/keyframe header parsing for H.264, HEVC, AV1 — used by oxideav HW-accel bridge crates (vaapi, vdpau, vulkan-video) to populate slice-data API parameter buffers without pulling a full SW codec
rlx-tensor
Native ndarray alternative for RLX — NumPy-style tensors that trace, fuse, and run on any backend via the rlx compiler
intern-mint
byte slice interning
atosl
A partial replacement for Apple's atos tool for converting binary addresses to symbols
parcoll
Collections for parallel computing, such as SPSC, SPMC, and MPSC and MPMC queues
vicut
A CLI text processor that uses Vim commands to transform text and extract fields
slice-diff-patch
providing utility functions for diff and patch of slices
piece-tree
Purely functional (immutable) implementation of Piece Tree, inspired by fredbuf
simple-bytes
A small and easy crate to mutate or read u8 slices
ring-seq
Circular (ring) sequence operations for Rust slices — rotations, reflections, necklace canonical forms, symmetry detection, and more
hexplay
Format u8 slices like an hex editor
non-empty-slice
Non-empty slices
sync-cell-slice
Cells and slices that are accessible from multiple threads
direct_ring_buffer
A high-performance, lock-free ring buffer for single-producer, single-consumer scenarios
shuffle
various shuffling algorithms over slices
varmap
Fast, heterogeneous key-value maps for Rust. Store mixed types (integers, strings, bytes, custom structs) under a single key namespace, with compile-time keys, runtime strings, or enum variants…
take-until
A take_until extension for iterators
hdlc
support of the IEEE standard
append-only-bytes
Shareable append-only bytes
par_slice
Slices that may be accessed from multiple threads with different levels of safety
regit-svi
Arbitrage-free SVI volatility surfaces in pure Rust. Raw, Jump-Wings and SSVI parametrisations, calibration, and static-arbitrage checks. Zero dependencies.
ownedbytes
Expose data as static slice
struct-field-names-as-array
generating the field names of named structs as constants
sel-rs
Select slices from text files by line numbers, ranges, positions, or regex
nu-pretty-hex
Pretty hex dump of bytes slice in the common style
second-stack
A fast allocator for short-lived slices and large values
nickel-lang-vector
Persistent vectors for Nickel
mailrs-rfc5322
Pull-based RFC 5322 message parser — lazy header lookup, byte-level scan, zero-alloc borrowed slices. Skip-ahead to the header you want without building a full Message tree.
scattered-collect
Link-time collections for Rust (distributed slices, registries)
slice_trait
A generic trait for any slice, with item as a type parameter
odds
ends — collection miscellania. Extra functionality for slices (
.find(),RevSlice), strings and other things. Things in odds may move to more appropriate crates if we find them.
tailvec
Split Vec to mutable slice and TailVec, the TailVec can push or pop etc
pdqselect
Selects the kth smallest element of a slice, based on Orson Peters's Pattern Defeating Quickselect
non-empty-vec
NonEmptyvector implementation, ensure non-emptiness by construction
swap-buffer-queue
A buffering MPSC queue
powerboxesrs
functions to manipulate and compute metrics on boxes
slices-lexicon
AT Protocol lexicon validation library for Slices
oxford_join
Join string slices with Oxford Commas!
bv
Bit-vectors and bit-slices
assay-runner-spike
Internal/experimental substrate for Assay measured-run workflows. Compatibility wrapper crate that re-exports the Assay-Runner candidate surface from assay-runner-schema (Slice 1) and assay-runner-core (Slice 2)…
bytelines
Read input lines as byte slices for high efficiency
abao
BLAKE3 verified streaming
slice_map
A generic container to store a single type of data into unevenly sized slices
nsi-ffi-wrap
FFI wrapper and macro for NSI-compliant renderers – ɴsɪ
fixed-slice-vec
FixedSliceVecis a dynamic length Vec with runtime-determined maximum capacity backed by a slice
desert
traits for {de,}serializing compact binary formats
leb128fmt
encode and decode LEB128 compressed integers
indices
macros and methods for safely retrieving multiple mutable elements from a mutable slice, addressing scenarios where slice elements would typically require
RefCellorCell(interior mutability approach)
expanding_slice_rb
A self-expanding ring buffer similar to VecDeque optimized for working with slices of data
rev_slice
A newtype for operating on a reversed view of a slice
hex_fmt
Formatting and shortening byte slices as hexadecimal strings
simd-popcnt
Fast bit population count (number of 1 bits) of a byte slice using POPCNT, AVX2, AVX512, ARM NEON and ARM SVE
simd_aligned
Safe and fast SIMD-aligned data structures with easy and transparent 'flat' access
enums
Enumerate trait for vector and slice in rust. It abstracts chain methods like .iter().enumerate().collect() into a clean, reusable method also called enums like python enumerate.
rav1d-disjoint-mut
A provably safe abstraction for concurrent disjoint mutable access to contiguous storage
frame_mem_utils
a few stack oriented utileties designed with unsafe in mind
xsv
A high performance CSV command line toolkit
ot_utils
designed for concatenating audio samples and generating .ot (slice) files for the Elektron Octatrack sampler
sview-fmindex
FM-index library with slice view architecture for efficient text indexing and pattern matching
dyn-slice
&[dyn Trait] implementation, inspired by a Reddit thread
range-lock
Range lock for std::vec::Vec
sprite-slicer
Sprite-sheet slicing, transparent sprite detection, action grouping, background removal, frame normalization, and GIF preview export
arc-slice
Shared memory slices
lib3mf-slicer
3MF file slicer tool that generates slice images from 3D models
read_until_slice
AsyncBufRead::read_until extension to take a slice as a delimiter instead of a single u8
head-tail-iter
An iterator that repeatedly splits head & tail
bufio
std::io::Write for your potentially uninitialized slice of memory
hpc-node
Shared contracts for node-level resource management between HPC systems: cgroup v2 conventions, namespace handoff protocol, mount management, and readiness signaling
unslice-dst
Fancy slice-like DST support
index-ext
Index slices with arbitrary ints and as arrays
structview
Viewing binary data as high-level data structures, safely
cepstrum-extractor
compute the cepstrum of a signal
safe-string
safe interface for interacting with multi-byte strings in Rust, namely IndexedStr, IndexedString, and IndexedSlice
staticview
Turn any borrowed struct into a self-owning
'staticversion — all slice data packed into a single heap allocation, no cloning strings intoString, noVecoverhead. Just raw, flat memory.
fast-slice-utils
Highly optimized slice utilities using SIMD instructions when available
kastellan-worker-egress-proxy
Per-worker egress proxy: host-allowlist + SSRF/IP-pinning boundary enforcement over a UDS. Slice #1 (no TLS interception).
watto
parsing and serializing Plain Old Data
asbytes
Traits for viewing data as byte slices or consuming data into byte vectors. Relies on bytemuck for POD safety.
matrix-slice
Safe abstractions for two-dimensional slices
taped
A lightweight cursor for non-linear parsing of slices
prefetch-index
prefetch a slice element
nine-slices
Scale images using nine-slice scaling
itoaaa
Print integers to target buffer in decimal format, fast
arena-arc
A fast, chunk-based allocator for building contiguous slices and sharing them via handles
nibble_vec
Vector data-structure for half-byte values
array-util
no_std array helpers available without nightly
purrdf-slice
PurRDF native slice catalog: manifest-based discovery, typed artifact inventory, content-addressed IDs
irmf-slicer
A slicer for IRMF (Infinite Resolution Materials Format) files
line-col
Convert string slice indices into line/column numbers
linear-deque
A double-ended queue that can be sliced at any time without preparation
fileslice
Slices of files
u8pool
Stack for u8 slices in a client-provided buffers
paginate
framework agnostic pagination crate, that is especially suited for databases, slices and collections. Paginate calculates the range of pages indexes, making it ideal for accessing slices…
awsm-audio-worklet
Write a WASM DSP processor for the awsm-audio AudioWorklet node
shannon-nu-pretty-hex
Pretty hex dump of bytes slice in the common style
static-mapset
Maps and sets based on ordered array or slice
smooai-smooth-operator-ingestion
Knowledge ingestion + connectors for smooth-operator — pull documents from sources (file/web), chunk, embed, and store them in the StorageAdapter knowledge slice so they're retrievable (feature gap G1/G2/G9)
hud-slice-by-8
HUD Software's Rust improved implementation of the Intel Slice-By-8 algorithm
concat-string
macros for concatenating string slices into owned strings
uniques
Analyze items in a slice and calculate the unique, first, duplicate, and subsequent items and their indices
aligned-array
A newtype with alignment of at least
Abytes
procmod-scan
Fast pattern and signature scanning for byte slices
mut-str
A toolkit for working with mutable string slices (&mut str)
strslice
that provides zero copy string iterators for working with string slices. The library offers iterators similar to standard Rust string methods
unsafe_cell_slice
A microlibrary for creating multiple mutable references to a slice
mlx-rs-burn
Unofficial rust wrapper for Apple's mlx machine learning library (fork with slice, scatter, flip operations for burn-mlx)
streplace
A tiny library for matching and replacing in strings and slices with user-defined functions
rune-hex
Hex encoding and decoding for byte slices and files — lowercase, uppercase, and streaming output
sdset
Set operations for sorted and deduplicated slices. Much performances! Such Wow!
buthash
Fast hash for structs, slices and integers
slice-of-array
Extension traits for casting between slices and slices of arrays. (&[T] <-> &[[T; n]])
sentinel
A sentinel-terminated slice library
partition
slices in-place by a predicate
split_slice
accessing (&[T], &[T]) as if it were a single slice
k-combinations
Efficient iterator over k-element combinations of a slice
xslice
Slice representation using relative extents instead of absolute pointers
zip-to-irmf
Convert zipped image slices to IRMF shaders
stride
A strided slice type
heapify
Convenience functions to turn slices into max-heaps
slice_ops
A selection of useful slice operations
Try searching with DuckDuckGo or on crates.io.