Crate hashcrew 

Fast, portable hashing for non-cryptographic use.

APIs are grouped by family under cityhash, fnv, md5, murmur, and xxhash. No features are enabled by default; each family requires its same-named Cargo feature. Use free functions for complete byte slices and state types for incremental input. CityHash is intentionally one-shot. Streaming states with 32- or 64-bit digests also implement core::hash::Hasher.

Raw digests are stable across platforms for identical byte streams. The core::hash adapters use Rust’s typed encodings, which can vary across platforms and compiler versions. In particular, hashing a string or slice through core::hash::Hash can add framing bytes that a raw one-shot call does not receive. Use the free functions or update with an explicitly defined byte encoding for persistent checksums and cross-language protocols. These hashes are deterministic and are not cryptographically secure.

Choosing an algorithm

Prefer XXH3 for new checksums, cache keys, and trusted-input hash tables. The CityHash, MurmurHash3, FNV-1a, XXH32, and XXH64 APIs are primarily for interoperability with an existing format or data set. Choose a 128-bit variant when the application needs a lower collision probability than a 64-bit digest provides. MD5 is available for compatibility with existing formats and protocols that require its standard digest; it is cryptographically broken.

API model

Choose the interface from the form of input rather than from a separate implementation:

• Call a module-level function such as xxhash::xxh3_64 when the complete byte slice is available.
• Construct a state such as xxhash::Xxh3_64, call its update method for each slice, and call digest to read the current result. Further updates extend the same message.
• With the std feature, use the same state as std::io::Write when bytes come from an I/O producer.
• For a Rust hash collection, pass the matching builder as its core::hash::BuildHasher. These adapters consume Rust’s typed core::hash::Hash encoding rather than a portable byte serialization.

Capability map

Variant	Complete input	Incremental state	Digest	Hasher / builder
CityHash32	cityhash32	—	u32	—
CityHash64	cityhash64*	—	u64	—
CityHash128	cityhash128*	—	u128	—
XXH32	xxh32	Xxh32	u32	Xxh32 / Xxh32Builder
XXH64	xxh64	Xxh64	u64	Xxh64 / Xxh64Builder
XXH3-64	xxh3_64*	Xxh3_64	u64	Xxh3_64 / Xxh3_64Builder
XXH3-128	xxh3_128*	Xxh3_128	u128	—
MurmurHash3 x86_32	murmur3_x86_32	Murmur3X86_32	u32	Murmur3X86_32 / Murmur3X86_32Builder
MurmurHash3 x86_128	murmur3_x86_128	Murmur3X86_128	u128	—
MurmurHash3 x64_128	murmur3_x64_128	Murmur3X64_128	u128	—
FNV-1a 32	fnv1a_32*	Fnv1a32	u32	Fnv1a32 / Fnv1a32Builder
FNV-1a 64	fnv1a_64*	Fnv1a64	u64	Fnv1a64 / Fnv1a64Builder
MD5	md5	Md5	[u8; 16]	—

A trailing * indicates additional explicitly named configuration forms. xxhash::Xxh3_64SecretBuilder provides the custom-secret XXH3-64 hash-table adapter. The 128-bit states do not implement core::hash::Hasher because its finish method can only return u64. MD5 returns its standard 16 digest bytes; the other 128-bit algorithms return u128. Integer results need an explicit byte order for storage or transmission; see each family’s module documentation for digest encoding. CityHash has no streaming state because bounded-memory incremental hashing cannot reproduce its one-shot algorithm. MurmurHash3’s x86 and x64 labels distinguish incompatible algorithms, not target requirements.

Feature flags

No features are enabled by default. Enable the families an application uses; each family feature exposes its same-named module:

Feature	Hash family
cityhash	CityHash32, CityHash64, and CityHash128
fnv	FNV-1a 32 and 64
md5	MD5
murmur	MurmurHash3 x86_32, x86_128, and x64_128
xxhash	XXH32, XXH64, XXH3-64, and XXH3-128

[dependencies]
hashcrew = { version = "0.2", features = ["xxhash", "md5"] }

All families work without std. Enable the independent std feature for std::io::Write adapters and XXH3 runtime CPU-feature detection. It does not enable any hash family. Without it, XXH3 selects hardware kernels only from features guaranteed by the target, with scalar code as the fallback. For example, enable xxHash with standard I/O integration using:

[dependencies]
hashcrew = { version = "0.2", features = ["std", "xxhash"] }

The crate is dependency-free and allocation-free in every configuration. Feature selection does not change digest values.

Streaming input

Call update when the application already receives byte slices. With the std feature, every incremental state can also be the destination of std::io::copy or another producer that accepts std::io::Write. Bytes written to the state become hash input: write accepts the complete buffer, and flush has no work to perform. Obtain the digest separately after the producer finishes.

use std::io;

use hashcrew::xxhash::Xxh3_64;
use hashcrew::xxhash::xxh3_64;

let input = b"hashcrew";
let mut state = Xxh3_64::new();
io::copy(&mut input.as_slice(), &mut state).unwrap();

assert_eq!(state.digest(), xxh3_64(input));

Complete and incremental hashing

Hash a complete byte slice with a free function, or feed the same bytes to a reusable state:

use hashcrew::xxhash::Xxh64;
use hashcrew::xxhash::xxh64;

let expected = xxh64(b"hashcrew", 42);
let mut state = Xxh64::with_seed(42);
state.update(b"hash");
state.update(b"crew");

assert_eq!(state.digest(), expected);

Modules

cityhashcityhash

CityHash 1.1.1 one-shot APIs.

fnvfnv

FNV-1a one-shot and streaming APIs with standard or custom offset bases.

md5md5

MD5 one-shot and streaming APIs for compatibility with existing digests.

murmurmurmur

MurmurHash3 x86_32, x86_128, and x64_128 one-shot and streaming APIs.

xxhashxxhash

xxHash one-shot, streaming, hash-table, and XXH3 kernel APIs.