MurmurHash3 Calculator (32-bit)

Calculate the MurmurHash3 32-bit hash (the x86 variant) of any text or hex input, with a seed you can set. MurmurHash is the fast, well-distributed, non-cryptographic hash behind many hash tables, Bloom filters, and data-sketch libraries. Results are shown in hexadecimal, unsigned decimal, and signed 32-bit decimal, computed live in your browser.

How to use the MurmurHash3 Calculator (32-bit)

Type or paste into the input, choose whether it is Text or Hex bytes, and set the seed. The seed accepts a decimal number or a 0x-prefixed hex value and defaults to 0; changing it produces an entirely different hash, which is exactly how libraries derive several independent hash functions from one algorithm. In hex input mode, bytes may be separated by spaces or commas.

The cards update live and show the 32-bit result three ways: hexadecimal (eight digits), unsigned decimal (0 to 4294967295), and signed decimal (the same bits read as a two\'s-complement integer, the form some languages such as Java or C# return). The default input hashes to 776992547 with seed 0, a value you can use to confirm the implementation. An empty input always hashes to the seed\'s finalised value — and to exactly 0 when the seed is 0.

Everything is computed in your browser, so the hash is instant, works offline, and nothing you enter is uploaded anywhere.

What MurmurHash is and why it is everywhere

MurmurHash is a family of fast, non-cryptographic hash functions created by Austin Appleby in 2008; the name comes from the two basic operations it leans on, multiply and rotate. Its job is not security but distribution: given arbitrary input it produces an integer that is spread evenly across the output range, with small changes to the input scattering the result unpredictably. That makes it ideal for the places that need to turn keys into bucket indices quickly — hash tables, Bloom filters, count-min sketches, HyperLogLog, partitioning schemes, and feature hashing in machine learning. It is deliberately not collision-resistant against an adversary, so it must never be used for passwords, signatures, or anything where someone might craft inputs to collide on purpose.

The version computed here is MurmurHash3, x86 32-bit, the most widely used member. It processes the input four bytes at a time as little-endian 32-bit blocks. Each block is multiplied by a constant, bit-rotated, multiplied by a second constant, and mixed into a running hash that is itself rotated and combined with the magic value 0xe6546b64. Any leftover tail bytes get a similar but truncated treatment, the total length is folded in, and finally a finalisation step (a sequence of shifts and multiplications known as fmix32) avalanches the bits so that even one-bit input differences flip about half the output bits. The whole thing is just integer arithmetic, which is why it runs so fast on ordinary CPUs.

A defining feature is the seed. MurmurHash takes a 32-bit seed that initialises the running hash, and changing it yields a statistically independent hash function. Libraries exploit this constantly: a Bloom filter that needs k hash functions, or a sketch that needs several, can simply call MurmurHash with k different seeds rather than implementing k separate algorithms. Because the algorithm is fully specified down to its constants, two correct implementations always agree, which is why a check value is so handy — hashing a known string with a known seed and comparing the number is the standard way to confirm your code matches a reference. There are wider relatives too, MurmurHash3 x86_128 and x64_128, for when 32 bits invites too many collisions; this tool focuses on the 32-bit form that the overwhelming majority of code uses.

Common use cases

  • Hash tables. Reproduce the bucket index a library computes for a given key.
  • Bloom filters and sketches. Generate the per-seed hashes used by probabilistic data structures.
  • Sharding and partitioning. Check which partition a key maps to under a Murmur-based scheme.
  • Verifying implementations. Confirm your code matches a reference using a known string and seed.

Frequently asked questions

Is MurmurHash secure?
No. It is a non-cryptographic hash built for speed and even distribution, not for resisting attackers. Never use it for passwords, integrity against tampering, or signatures — use SHA-256 or a password hash for those.

What does the seed do?
The seed initialises the internal state, so different seeds give statistically independent hashes of the same input. Libraries use this to derive several hash functions — for a Bloom filter, say — from one algorithm.

Why are there signed and unsigned results?
The hash is 32 bits. Languages like C, JavaScript (>>>0), Python, and Go treat it as unsigned (0 to about 4.3 billion), while Java and C# return it as a signed two's-complement integer. The bits are identical; only the interpretation differs.

Which MurmurHash3 variant is this?
The x86 32-bit variant, which is by far the most common. The 128-bit variants (x86 and x64) produce wider outputs for cases where 32 bits would collide too often, but most code uses the 32-bit form shown here.