Should I pick BLAKE2b or BLAKE2s?

BLAKE2b is optimised for 64-bit platforms and supports up to 512-bit output. BLAKE2s is optimised for 8 to 32-bit platforms with up to 256-bit output. Choose 2b on servers, 2s on embedded targets.

Is BLAKE2 cryptographically secure?

Yes. BLAKE2 is a SHA-3 finalist with the same security goals as SHA-2/3. It powers Argon2, libsodium's generichash, and IPFS multihashes, and has no known practical attacks.

Is the hash computed locally?

Yes. Hashing runs in your browser with no network calls.

blake2b / blake2s · noble · live

Generate BLAKE2 digests

BLAKE2b (64-bit optimised, up to 512 bits) or BLAKE2s (32-bit, up to 256 bits). Faster than MD5/SHA on most CPUs. Runs entirely in your browser.

BLAKE2 Hash Generator

Input

43 B

43 chars

Variant

BLAKE2B

256-bit

Digest

—

32/64 B

Status

noble

input · text

output · blake2b hex

—

Quick Start

How to compute BLAKE2

Hashes UTF-8 bytes via @noble/hashes. Output length is configurable up to 64 bytes (b) or 32 bytes (s).

01
Type or paste text
Any UTF-8 input — emoji and accents are hashed faithfully.
Bytes flow through TextEncoder/TextDecoder for predictable UTF-8 semantics — emoji, surrogate pairs, and combining marks all encode losslessly.
inputUTF-8TextEncoderlosslesslive
input · raw bytestext · UTF-8
```
hello
```
loaded · UTF-8MIME · ready
02
Pick variant
BLAKE2b for modern 64-bit CPUs, BLAKE2s for 8/16/32-bit platforms.
Hash and signature operations call crypto.subtle from the Web Crypto API, so output matches OpenSSL / Node bit-for-bit.
variantWeb Cryptosubtledeterministiclive
var · optionsb · live
```
64-byte max
```
options applied · livelive
03
Set output bytes
Match the protocol you're implementing. 32 is a sensible default.
Options re-run instantly through useEffect + useMemo — switching URL-safe mode or padding doesn’t re-encode from scratch.
sizememoisedoptionsinstantreactive
len · encoded32 · ready
```
256-bit out
```
encoded · livelossless
04
Copy or download
One click to clipboard. Download as .txt.
Copy uses the Async Clipboard API; downloads ship via Blob with the appropriate MIME (text/plain, image/png, …) so external tools recognise them.
exportclipboardblobMIME-correctclient-side
ok · copiedready · done
```
Copied
```
shipped · ready to shipsuccess

Pro tips

Encoding without surprises

Always UTF-8 first

Use TextEncoder / TextDecoder for bytes ↔ string conversion. btoa alone breaks on non-ASCII.

URL-safe vs standard Base64

Standard uses +, /, =; URL-safe swaps to -, _, no padding. Don’t mix them.

Hashes aren’t passwords

SHA-256 is fast; that’s good for fingerprints, bad for passwords. Use bcrypt / argon2 for credentials.

Watch padding rules

Some decoders are strict about = padding, others auto-pad. If round-trips fail at exactly 1 or 2 bytes, check padding.

Use Web Crypto for keys

Generate cryptographic keys via crypto.subtle, never Math.random. The latter is predictable.

JWT decode ≠ verify

Decoding a JWT just splits and base64-decodes. Verification needs the issuer’s public key / shared secret.

Use Cases

When to use BLAKE2

A fast modern alternative to SHA-2.

libsodium

Default hash inside many libsodium primitives. Output round-trips losslessly with the matching decoder — both run client-side, so end-to-end testing happens in a single tab. Encoding flows through TextEncoder for predictable UTF-8 semantics.

RFC-compliant

Argon2 internals

Argon2 uses BLAKE2b as its compression core. Web Crypto's subtle.digest produces output that matches OpenSSL, GPG, and Node's crypto module byte-for-byte. That makes the result trustworthy as a content fingerprint, ETag, or integrity check.

OpenSSL-matched

IPFS / content IDs

Some CIDs are built on BLAKE2b digests. Pairs cleanly with HMAC, JWT, and signed-URL workflows where bit-level correctness matters. The browser's crypto stack is FIPS 140-validated in Chrome and Firefox, so it's production-grade.

p2p

Fast checksums

Outperforms SHA-2 on most modern CPUs. Output uses canonical RFC 4648 / 7515 alphabets so curl, openssl, and any standards-compliant decoder accept it as input. URL-safe variants drop padding for tokens that travel in query strings.

byte-identical

Tagged hashing

Configurable personalisation and key inputs. Heavy hashing runs through useMemo so large inputs don't block typing. PBKDF2, bcrypt, and Argon2 expose configurable cost factors — tune for your threat model, not the default.

spec-grade

Test fixtures

Match RFC 7693 test vectors exactly. Same input plus same options always yields identical bytes. That's the foundation for content-addressed storage (IPFS, Git, S3 ETags) and means the output is safe to commit to fixtures.

production-ready

FAQ

Frequently asked questions

BLAKE2b vs BLAKE2s?

BLAKE2b is faster on 64-bit machines and outputs up to 64 bytes. BLAKE2s targets 8–32-bit hardware and outputs up to 32 bytes.

Is BLAKE2 secure?

Yes — it is a modern cryptographic hash with no known practical attacks.

Is it faster than SHA-256?

Usually yes. BLAKE2b often beats SHA-256 by 2–4x on modern CPUs.

Can I hash a file?

For files use the File Checksum Verifier — it streams large files efficiently.

Is anything sent to a server?

No. BLAKE2 is computed in your browser via @noble/hashes and runs locally.

Suggest a tool

Something missing?

Tell us what you need. We ship the top requests every two weeks.

47 in queue·8 shipped this month

Request queued. Thanks!