AxHash

AxHash is a high-performance deterministic hashing family for Rust and native systems languages.

If you only need AxHash in Rust, start with the axhash crate from this workspace. It is the simplest entrypoint and re-exports the core engine with a friendlier import path.

AxHash is optimized for real-world HashMap workloads, concurrent systems, cache-heavy applications, and high-throughput native runtimes.

Ecosystem

Features

• Deterministic hashing
• Seeded hashing support
• Streaming API
• Fast HashMap integration
• no_std support
• Cross-language FFI
• Concurrent-friendly design

Performance Highlights

Benchmarked with Criterion.rs on Apple Silicon (release mode).

Real-world HashMap Comparison

Concurrent Scaling

See full Criterion benchmark reports for detailed graphs and methodology.

Pick The Right Package

• Rust: axhash
• C / C++ / Go / Zig / Swift / Kotlin Native: axhash-ffi
• Low-level engine / no_std: axhash-core

Rust Quick Start

Add the simplest Rust package:

[dependencies]
axhash = "0.8"

Hash raw bytes:

use axhash::hash;

fn main() {
    let digest = hash(b"hello axhash");
    println!("{digest:016x}");
}

Hash raw bytes with a seed:

use axhash::hash_with_seed;

fn main() {
    let digest = hash_with_seed(b"hello axhash", 0x1234_5678);
    println!("{digest:016x}");
}

Hash any Rust value that implements Hash:

use axhash::hash_value;

#[derive(Hash)]
struct SessionKey {
    account_id: u64,
    region_id: u32,
    flags: u32,
}

fn main() {
    let key = SessionKey {
        account_id: 42,
        region_id: 7,
        flags: 3,
    };

    let digest = hash_value(&key);
    println!("{digest:016x}");
}

Use the streaming hasher:

use axhash::AxHasher;
use std::hash::Hasher as _;

fn main() {
    let mut hasher = AxHasher::new_with_seed(0x4444);

    hasher.write(b"hello ");
    hasher.write(b"world");

    println!("{:016x}", hasher.finish());
}

Use AxHash with HashMap:

use axhash::AxBuildHasher;
use std::collections::HashMap;

fn main() {
    let mut map =
        HashMap::with_hasher(AxBuildHasher::with_seed(0xfeed_beef));

    map.insert("status", "ok");
    map.insert("runtime", "fast");

    println!("{:?}", map.get("status"));
}

Inspect the active backend:

use axhash::{runtime_backend, runtime_has_aes};

fn main() {
    println!("{:?}", runtime_backend());
    println!("{}", runtime_has_aes());
}

Workspace Layout

• axhash-core: low-level Rust core and no_std engine
• axhash-ffi: stable C ABI

License

MIT