xxHash Generator: Compute XXH32 and XXH64 Digests

How to use the xxhash generator

1. Type or paste your data into the Input field. Pick Hex bytes to hash raw bytes instead of text.
2. Set the Seed (default 0). XXH32 accepts 0 to 4,294,967,295 and XXH64 accepts 0 to 18,446,744,073,709,551,615.
3. Choose XXH32 for a 32-bit hash or XXH64 for a 64-bit hash.
4. The xxhash result updates as you type, as a big-endian hex digest (the form the reference tool prints) and as a decimal number.

How the xxhash algorithm works

The xxhash family uses prime multipliers and bitwise rotations to mix input bytes rapidly. For XXH32, four 32-bit accumulators are initialized from the seed and five specific primes (PRIME32_1 through PRIME32_5). Input is processed in 16-byte stripes; each stripe updates all four accumulators by multiplying, adding, and rotating bits. After all full stripes are consumed, the accumulators are merged, remaining bytes are folded in, and a final avalanche step ensures every output bit depends on every input bit.

XXH64 follows the same structure but operates on 64-bit words with 32-byte stripes and its own set of five 64-bit primes. It processes more data per loop iteration with wider registers, so it is usually faster on 64-bit processors and produces a longer digest with fewer accidental collisions.

Reference values for common inputs

Use this table to check your own implementation. All values use seed 0 and are shown as the canonical big-endian hex digest.

When to use xxhash instead of cryptographic hashes

Cryptographic functions like those in the SHA-256 generator or MD5 hash generator are designed to resist deliberate collision attacks. They are computationally expensive by design. The xxhash algorithm trades that resistance for raw throughput, making it ideal for hash tables, database indexing, file deduplication, network packet checksums, and build-system caching.

If you need to verify data integrity against an active adversary, use a cryptographic hash. If you need to map millions of keys to buckets per second, xxhash is the better choice. Other fast non-cryptographic options include MurmurHash, FNV, and Adler-32.

Understanding the seed parameter

The seed initializes the internal state of the hash. The same input hashed with different seeds gives unrelated outputs. This is useful for hash tables, where a random per-process seed makes hash-flooding denial-of-service attacks harder without changing the algorithm.

In this tool the XXH32 seed is a 32-bit unsigned integer (0 to 4,294,967,295) and the XXH64 seed is a 64-bit unsigned integer (0 to 18,446,744,073,709,551,615), matching the reference implementation. Decimal and 0x hex notation both work. Record the seed with the hash, because the same input will not match without it. For example, "abc" with XXH32 and seed 1 gives aa3da8ff instead of 32d153ff.

Common mistakes and edge cases

A frequent source of mismatches is byte order in the printed result. The canonical digest of xxHash is big-endian, which is what the reference xxhsum tool and this page print. A library that returns an integer and a tool that prints its bytes in memory order on a little-endian machine can look reversed. The decimal row shows the plain integer value.

Another pitfall is the input encoding. This tool hashes text as UTF-8, so an accented letter is two bytes. A UTF-16 string, as used internally by JavaScript and .NET, hashes differently; enter those bytes as hex instead.

What this tool does not do: it implements the classic XXH32 and XXH64 functions only, not the newer XXH3 and XXH128, which give different values. It hashes pasted text or hex rather than files, and very large pastes use browser memory. Never use xxHash for passwords or signatures, as it offers no resistance to deliberate attacks.

Worked examples