This tool computes the BLAKE3 cryptographic hash of any text and shows it live in hexadecimal. BLAKE3 is a modern, very fast hash function designed by the authors of BLAKE2 and released in 2020; it is suitable for content addressing, deduplication, integrity checks, and key derivation. The default digest is 256 bits, but because BLAKE3 is an extendable-output function (XOF) you can also request 128 or 512-bit outputs from the same computation.
How BLAKE3 works
BLAKE3 hashes input as a binary Merkle tree — an approach that allows large files to be hashed in parallel, which is why it is significantly faster than SHA-256 on modern multi-core hardware.
The message is split into 1024-byte chunks, and each chunk is compressed block-by-block (64 bytes at a time) using a 7-round mixing function built from the ChaCha-style g quarter-round. Each chunk produces an 8-word chaining value. Chunk chaining values are then merged pairwise by parent nodes — the left subtree always covers the largest power of two of chunks strictly less than the total — until a single root remains.
The final block (for a single chunk) or the root parent node is compressed with the ROOT flag set. To produce output, BLAKE3 runs that root with an increasing output-block counter, which is what lets it emit any number of bytes (the XOF property). This implementation reproduces that whole tree, so it matches the official test vectors for single-chunk, multi-chunk, and extended outputs.
What makes BLAKE3 different from BLAKE2
- Speed: BLAKE3 is designed for parallel hardware; on multi-core CPUs it can saturate memory bandwidth for large inputs. For short strings in a browser (single chunk), the difference is not measurable.
- Tree structure: BLAKE3 uses a Merkle tree; BLAKE2 is sequential (like SHA-2). The tree enables both parallelism and verified streaming.
- Fixed 256-bit internal state output: the 128 and 512-bit options here are XOF extensions from the root node, not separate internal widths as in BLAKE2b.
- Unified design: BLAKE3 replaces the BLAKE2b/BLAKE2s split — there is one algorithm that targets all platforms.
When each output size makes sense
| Output | Use case |
|---|---|
| 128-bit (16 bytes) | Compact fingerprint where collision resistance at 64-bit security level is acceptable |
| 256-bit (32 bytes) | Standard integrity check or content address; matches SHA-256 slot sizes |
| 512-bit (64 bytes) | Extended key material or when you want extra margin |
Reference values and practical notes
The empty input hashes to af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262 (256-bit default), and the string abc hashes to 6437b3ac38465133ffb63b75273a8db548c558465d79db03fd359c6cd5bd9d85. These are well-known reference values you can use to confirm any BLAKE3 implementation is correct.
BLAKE3 is a cryptographic hash designed for speed — it is collision-resistant and safe for integrity verification, but it is unsalted and very fast, which means it is not suitable for hashing passwords directly. Use a slow, salted password hash such as bcrypt, scrypt, or Argon2 for that. Everything here is computed locally in your browser; nothing is uploaded.