MurmurHash3 Generator
Compute MurmurHash3 hashes for any text or hex input. Supports the x86_32, x86_128, and x64_128 variants with a custom seed — entirely in your browser.
Input
Hash
Enter text or a hex byte string on the left, choose a variant and seed, and the MurmurHash3 hash will appear here.
About MurmurHash3
MurmurHash3 is a fast, high-quality, non-cryptographic hash function designed by Austin Appleby. It is the default hash in many systems where speed and good distribution matter more than cryptographic security — for example, in HashMap implementations, Bloom filters, HyperLogLog, Cassandra, Elasticsearch, Spark, Redis, and many database query planners.
There are three official variants: x86_32 produces a 32-bit hash optimised for 32-bit machines, x86_128 produces a 128-bit hash also optimised for 32-bit machines, and x64_128 produces a 128-bit hash optimised for 64-bit machines. The 128-bit outputs are not compatible across the two variants — pick the one that matches your downstream system.
This tool implements all three variants in pure TypeScript and runs entirely in your browser. Inputs and seeds never leave your device.
How to Use the MurmurHash3 Generator
- Pick an input mode: Text hashes the UTF-8 bytes of your
input; Hex hashes the bytes you provide as a hexadecimal string (e.g.
48656c6c6ffor "Hello"). - Type or paste your input into the Input textarea, or click Sample to load
"The quick brown fox jumps over the lazy dog". - Choose a variant from the dropdown.
x86_32is the default if you just want a 32-bit hash;x64_128is the typical choice for 128-bit hashes on modern systems. - Set a seed as either a decimal number (e.g.
42) or hex (0xDEADBEEF). The seed lets you produce different hash families from the same input. - The hash updates immediately. Use the Copy buttons to grab the hex output or, for the 32-bit variant, the unsigned decimal form.
Variants at a Glance
| Variant | Output | Best For |
|---|---|---|
| x86_32 | 32-bit unsigned integer | Hash tables, partition keys, fingerprint shards. The "default MurmurHash3" most libraries expose. |
| x86_128 | 128 bits (4 × uint32 lanes) | 32-bit platforms or interop with code that uses the x86 128-bit constants. |
| x64_128 | 128 bits (2 × uint64 lanes) | Low-collision IDs, Bloom filters, perfect-hash construction. Default 128-bit on 64-bit platforms. |
Frequently Asked Questions
Is MurmurHash3 cryptographically secure?
No. MurmurHash3 is a non-cryptographic hash. It is fast and has good avalanche behaviour, but it is not collision-resistant against a motivated adversary. Never use it to hash passwords, sign messages, or generate security tokens. For those use cases, use a dedicated cryptographic hash like SHA-256 or a password-hashing algorithm like Argon2 or Bcrypt.
Why are the x86_128 and x64_128 outputs different?
The two 128-bit variants use different mixing constants and a different block layout — x86_128 processes four 32-bit lanes in parallel, while x64_128 processes two 64-bit lanes. They produce different hash values for the same input. Always pick the variant your downstream consumer expects.
What does the seed do?
The seed lets you generate independent hash functions from the same algorithm. Two
inputs that collide under seed = 0 will (almost certainly) not collide under seed = 1. This is essential for Bloom
filters and Cuckoo filters where you need k independent hashes.
Why is my output different from mmh3 in
Python?
Most likely the input encoding or seed differs. Python's mmh3.hash(s) hashes the UTF-8 bytes of s with seed 0 and returns a signed 32-bit integer; this tool returns the unsigned form. mmh3.hash(s, signed=False) matches the
"Unsigned Decimal" field exactly. For 128-bit results, use mmh3.hash_bytes(s) (which is the x64_128
variant) or compare hex.
Does the hex input mode interpret 0x prefixes?
Yes. A leading 0x or 0X is stripped, and any whitespace is ignored, so 0x48 65 6c 6c 6f hashes the same five
bytes as 48656c6c6f.
Is my data sent to a server?
No. The implementation runs entirely in your browser as TypeScript / WebAssembly-free JavaScript. Your input, hex bytes, and seed never leave your device, so it is safe to hash internal identifiers, API responses, or anything sensitive.
How can I verify this implementation?
Use these reference vectors to confirm everything matches Austin Appleby's canonical
implementation. With x86_32 and seed 0: hashing the empty string yields 0x00000000, hashing "Hello, world!" yields 0xc0363e43, and hashing "The quick brown fox jumps over the lazy dog" yields 0x2e4ff723.