Introduction
BLAKE3 is a modern cryptographic hash function designed by Jack O'Connor, Jean-Philippe Aumasson, and Samuel Neves and published in 2020. It is derived from BLAKE2 and the Bao tree mode, runs a Merkle tree in parallel for speed that scales with cores, and supports arbitrary-length output plus a keyed MAC mode. On modern hardware BLAKE3 is several times faster than SHA-256 and BLAKE2 while offering comparable security. This tool generates BLAKE3 hashes entirely in your browser using a WebAssembly implementation from hash-wasm.
What this tool does
- Generates BLAKE3 hashes from any text input in real time as you type.
- Supports configurable output length of 128, 256, 512, or 1024 bits.
- Supports the keyed MAC mode with a 32-byte (64-hex-character) key.
- Uses a WebAssembly implementation for near-native speed.
- Processes all data locally in your browser with no network requests.
How this tool works
Type or paste text into the input field. The tool converts the text to UTF-8 bytes and feeds them through the BLAKE3 WebAssembly module from hash-wasm. The output length selector controls how many bits of digest are produced (BLAKE3 supports arbitrary-length output by treating the hash as a XOF). The optional key field enables the keyed MAC mode, which requires exactly 32 bytes (64 hex characters). The hash updates instantly as you change the input, length, or key. All computation happens client-side.
How BLAKE3 works
BLAKE3 was announced in 2020 by O'Connor, Aumasson, and Neves (paper: 'BLAKE3: one function, fast and simple'). It combines the BLAKE2 compression function with a binary Merkle tree mode inspired by the Bao project. Each 1024-byte chunk is hashed independently, then the chunk hashes are combined up the tree, which lets BLAKE3 scale linearly with the number of CPU cores and supports verified streaming (you can verify a chunk before receiving the rest). The default output is 256 bits, but BLAKE3 is a XOF: it can produce any length by extending the output. The keyed mode derives a MAC key from the input key and the BLAKE3 context string, giving a secure MAC without a separate HMAC construction. BLAKE3 is used in IPFS, the Bao tool, Apple's sealed system hash, and several Rust crates.
How to use this tool
- Enter the text you want to hash in the input field.
- Select the output length: 128, 256 (default), 512, or 1024 bits.
- Optionally paste a 32-byte (64-hex-character) key to enable keyed MAC mode.
- The BLAKE3 hash appears instantly in the output field as a hex string.
- Use the Copy button to copy the hash to your clipboard.
Real-world examples
Hashing a simple string
Input: `hello` with 256-bit output. The hash is a 64-character hex string. The same input always produces the same output.
Extended output
Input: `hello` with 1024-bit output. BLAKE3 produces a 256-character hex string by extending the XOF, which is not possible with BLAKE2 or SHA-2.
Keyed MAC mode
Input: `hello` with key `00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff`. The output differs from the unkeyed hash and serves as a message authentication code.
Comparison with similar methods
| Method | Complexity | Typical use |
|---|---|---|
| BLAKE3 | O(n) — parallel Merkle tree | Fast hashing, content addressing, verified streaming |
| BLAKE2b | O(n) — 12 rounds per 128-byte block | Argon2, WireGuard, file integrity |
| SHA-256 | O(n) — 64 rounds per 64-byte block | Digital signatures, TLS, blockchain |
| SHA-3 | O(n) — sponge construction | NIST standard, post-quantum readiness |
Limitations or considerations
BLAKE3 is not a password hashing function. For password storage, use Argon2, bcrypt, or PBKDF2, which incorporate salting and work factors. The WebAssembly module is loaded lazily on first use, so the first hash may take a few hundred milliseconds. The keyed mode requires exactly 32 bytes; other key lengths are rejected. This tool does not expose the context-string (KDF) mode or the tree mode directly, only the standard hash and keyed MAC modes.
Frequently asked questions
Is BLAKE3 standardized?
BLAKE3 is specified in its 2020 design paper and has a reference Rust implementation, but it is not yet an IETF RFC. It is widely deployed in production systems including IPFS and Apple's sealed system hash.
Why is BLAKE3 faster than SHA-256?
BLAKE3 processes 1024-byte chunks in parallel using a Merkle tree, while SHA-256 processes 64-byte blocks sequentially. On multi-core hardware BLAKE3 can be 5-10x faster than SHA-256.
Can BLAKE3 produce arbitrary-length output?
Yes. BLAKE3 is a XOF (extendable output function): the standard hash is 256 bits, but you can request any length by extending the output stream. This tool supports 128 to 1024 bits.
What is the keyed mode for?
The keyed mode produces a message authentication code (MAC) using a 32-byte key, without needing a separate HMAC construction. It is useful for authenticating messages when both parties share a secret key.
Conclusion
The BLAKE3 hash generator provides a fast, modern cryptographic hash with configurable output length and a keyed MAC mode, all running in your browser via WebAssembly. For password hashing, use the Argon2 or PBKDF2 tools on this site instead.