Benchmarks

Similar bulk speed at both widths; extra cost on short inputs. These runs measure the current digest on the hosts below. Use them to compare within a run, then measure your own workload.

64 vs 128 bits · WebAssembly · 128-bit comparison · ChibiHash · Reproduce

For a quick check on your machine, run the browser speed test.

Cost of the 128-bit result

Both widths share one pass over the input. Each cell shows 64-bit / 128-bit results: the median of nine calibrated rounds of about 40 ms on one pinned core.

Chained calls feed each result into the next seed and measure latency. Independent calls can overlap. Lower ns is better; higher GB/s is better.

Baseline wasm32 on the M1 Pro

Zig 0.16 compiled all rows into one wasm32-wasi module with -O3, no SIMD, and no wide multiply. The timing loops ran inside wasm under Node 26 / V8, so the JS boundary is outside every measurement.

hayahash128 retains 99% of hayahash64's bulk rate here. All other rows return 64 bits.

SMHasher3 128-bit shootout

The current digest is compared using SMHasher3 commit 51d3cd1a. Speed cells are medians of three independent, round-robin processes on the two bare-metal hosts. Small-key latency is the corrected 1 to 31 byte average; bulk is the fixed 256 KiB average. The full suite ran separately on the EPYC 9655 with 128-bit-wide expectations.

Small-key values are dependent latency, not independent throughput. Their raw process averages are corrected to one call-overhead baseline per host; the raw records contain every process value and the calculation. MeowHash has no M1 row because this implementation needs x86 AES instructions.

XXH3-128 has the highest bulk throughput on both hosts and fails 26 test groups. Among hashes that pass, a5hash has the lowest small-key latency. hayahash128's Zen 5 bulk result uses compiler auto-vectorization.

hayahash128 leads the passing ordinary-scalar implementations in this comparison. prvhash has 187 applicable groups; the others have 188. See the raw records and measurement method.

64-bit coverage

The native 64-bit comparison against wide-multiply and SIMD hashes has not been rerun since the digest changed. Current comparisons are limited to baseline wasm and ChibiHash.

Comparison: ChibiHash

ChibiHash uses the same portable arithmetic, making it a useful baseline. Reproduce this comparison with make -C tests run-bench; both ChibiHash versions are vendored in tests/.

Apple M1, clang -O3 -mcpu=native

hayahash64 is faster than ChibiHash v2 at every size shown. ChibiHash v1 wins some short-input timings but fails SMHasher3. Fixed-size measurements do not capture mixed-size workloads; see dispatch tradeoffs.

AMD Zen 5, GCC 16 -march=native

The 1 MiB result uses AVX-512DQ auto-vectorization. Without it, hayahash64 reaches about 35 GB/s from the same portable source. Both builds produce identical hashes.

Reproduce it

# The ChibiHash comparison. The references are vendored in tests/.
make -C tests run-bench

# SMHasher3, pinned to an exact upstream commit.
make -C tests/smhasher3 run

# The wasm32 shootout and the wasm-against-native bit-exactness check.
make -C tests/wasm run-kat run-bench

See the SMHasher3 guide for the full build matrix and timing corrections. Raw records include hosts, compilers, dispatch shapes, and source checksums.