MurmurHash Generator: MurmurHash3 32-bit and 128-bit

How to use the murmurhash generator

1. Type or paste your text into the Text to hash field.
2. Set the Seed value (an integer between 0 and 4294967295). The default is 0.
3. The MurmurHash3 32-bit and 128-bit x64 results update automatically as you type.
4. Copy the hexadecimal hash values for use in your application.

How MurmurHash3 works

MurmurHash3 processes input in 4-byte blocks for the 32-bit variant and 16-byte blocks for the 128-bit x64 variant. Each block is multiplied by a constant, rotated, XORed into an accumulator and multiplied again. After all full blocks are consumed, the remaining tail bytes are processed similarly. Finally, a mixing step called fmix ensures avalanche properties so that changing a single input bit flips roughly half of the output bits.

The 32-bit version uses two constants: c1 = 0xcc9e2d51 and c2 = 0x1b873593. The 128-bit x64 version uses c1 = 0x87c37b91114253d5 and c2 = 0x4cf5ad432745937f. Because JavaScript bitwise operators work on signed 32-bit integers, the implementation must carefully handle unsigned overflow using techniques like splitting 32-bit multiplications into 16-bit halves.

Verification vectors

These MurmurHash3 32-bit reference values come from the SMHasher test suite and cover the empty string and the largest seed.

For the 128-bit x64 variant with seed 0, the empty string gives 00000000000000000000000000000000 and "The quick brown fox jumps over the lazy dog" gives e34bbc7bbc071b6c7a433ca9c49a9347. The 128-bit result is printed as h1 followed by h2, each as 16 big-endian hex digits, which is the order most JavaScript libraries use. Libraries that return raw bytes show each half byte-swapped.

When to use MurmurHash

MurmurHash is designed for speed and excellent distribution, not security. It is commonly used in hash tables, database sharding, bloom filters, consistent hashing rings and checksums for internal data pipelines. Systems such as Cassandra, Elasticsearch, Hadoop and Guava use MurmurHash variants for partitioning, routing and hash tables.

Because it is a non-cryptographic hash function, it is vulnerable to deliberate collision attacks. Never use murmurhash for password storage, digital signatures or message authentication. For those tasks, use a cryptographic hash like SHA-256 via the SHA-256 hash generator, or keyed constructions like HMAC via the HMAC-SHA256 generator.

32-bit versus 128-bit x64

The 32-bit variant returns a single 8-character hexadecimal string. It is fast and sufficient for hash tables with fewer than a few hundred million entries. Collision probability follows the birthday bound: around 50 percent chance after roughly 77,000 random inputs.

The 128-bit x64 variant returns a 32-character hexadecimal string. It processes data in 16-byte chunks optimized for 64-bit arithmetic, producing two 64-bit words, h1 and h2, that are concatenated. This variant has a vastly lower collision rate and is preferred when hashing large datasets, generating unique identifiers or building distributed hash rings. Note that the x86 128-bit variant exists but produces different output due to different constants and rotation amounts; this tool implements the x64 version.

Common mistakes with seeds

The seed initializes the hash state. Using the same seed for every hash in a hash table is normal, but changing the seed changes the output completely. A frequent mistake is passing a negative number or a floating-point value as the seed. The seed must be an unsigned 32-bit integer between 0 and 4294967295.

Another issue arises when hashing UTF-8 text. MurmurHash operates on raw bytes. If your system encodes strings differently before hashing, the output will not match. This tool encodes input as UTF-8 bytes before processing, which matches the behavior of most modern libraries.

Worked examples