What's the difference between BLAKE2s and BLAKE2b?

They're the same design at different word sizes: BLAKE2s operates on 32-bit words and produces up to a 256-bit digest, tuned for 8- to 32-bit CPUs and memory-constrained environments, while BLAKE2b operates on 64-bit words and produces up to 512 bits, tuned for modern 64-bit hardware. On a typical server or desktop, BLAKE2b is usually faster; on a microcontroller or 32-bit embedded chip, BLAKE2s tends to win.

Should I use BLAKE2s on a modern 64-bit server?

Generally no, BLAKE2b will outperform it there since it's built around 64-bit word operations that map directly onto modern CPU registers. BLAKE2s makes sense specifically when you're targeting hardware where 64-bit arithmetic is expensive or unavailable: embedded systems, older 32-bit processors, or certain constrained IoT devices.

Does BLAKE2s support shorter output than 256 bits?

Yes, natively, from 1 to 32 bytes (8 to 256 bits) as a built-in parameter, the same variable-output design BLAKE2b offers at its larger word size. This tool always uses the full 256-bit (32-byte) output for consistency and maximum collision resistance.

Does this tool send my text to a server?

No. BLAKE2s is computed entirely client-side using an audited JavaScript implementation, so nothing you type here is transmitted anywhere.

BLAKE2s Hash Calculator - Calculate BLAKE2s Checksum Online

Overview

Introduction

BLAKE2s is BLAKE2b's smaller-word sibling: the same underlying design, tuned for 32-bit and smaller hardware instead of 64-bit servers.

This tool computes BLAKE2s's 256-bit digest of any text you provide, entirely in your browser, for embedded/constrained-hardware-adjacent work, or wherever a 32-bit-optimized hash is the better fit.

What Is BLAKE2s Hash Calculator?

BLAKE2s is a cryptographic hash function published in RFC 7693 alongside BLAKE2b, sharing the same overall design (descended from the SHA-3 finalist BLAKE) but operating on 32-bit words instead of 64-bit, producing up to a 256-bit digest shown here as 64 hexadecimal characters.

It targets 8- to 32-bit platforms, including embedded and IoT hardware, where BLAKE2b's 64-bit word operations would be comparatively slow or unavailable.

How BLAKE2s Hash Calculator Works

Your UTF-8 encoded text is processed through BLAKE2s's compression function, the same core mixing function (G) BLAKE2b uses, but operating on 32-bit words across 10 rounds per 64-byte block.

The final internal state is truncated to the requested output length, 256 bits by default in this tool, and hex-encoded into the resulting digest.

When To Use BLAKE2s Hash Calculator

Reach for BLAKE2s when targeting hardware where 64-bit arithmetic is expensive: microcontrollers, older 32-bit systems, or embedded/IoT devices.

On modern 64-bit servers or desktops, BLAKE2b will typically outperform BLAKE2s for the same security goals; there's little reason to choose BLAKE2s there specifically.

Often used alongside BLAKE2b Hash Calculator and BLAKE3 Hash Calculator.

Features

Advantages

Optimized specifically for 32-bit and smaller hardware, where it outperforms BLAKE2b.
Natively supports variable output length (1-32 bytes) without needing separate truncated variants.
Shares BLAKE2b's strong security margin, descended from a SHA-3 competition finalist.

Limitations

Slower than BLAKE2b on modern 64-bit hardware, where the larger word size wins.
Shorter maximum output (256 bits) than BLAKE2b's 512-bit ceiling.
Less commonly chosen than BLAKE2b or SHA-256 outside of embedded-specific contexts.

Examples

Hashing a short greeting

Input

Hello, world!

Output

30d8777f0e178582ec8cd2fcdc18af57c828ee2f89e978df52c8e7af078bd5cf

13 bytes of UTF-8 text produce the full 64-character BLAKE2s hex digest (256-bit output).

Hashing the classic pangram

Input

The quick brown fox jumps over the lazy dog

Output

606beeec743ccbeff6cbcdf5d5302aa855c256c29b88c8ed331ea1a6bf3c8812

A widely published BLAKE2s test vector at the default 256-bit output length.

Best Practices & Notes

Best Practices

Choose BLAKE2s specifically for 32-bit, embedded, or IoT targets where it outperforms BLAKE2b.
On modern 64-bit servers, prefer BLAKE2b for the same design's benefits with better throughput.
If your target hardware is unknown or mixed, SHA-256 remains the safer universal default.

Developer Notes

This tool uses @noble/hashes' audited BLAKE2s implementation at the default 32-byte (256-bit) output length, computing the digest synchronously in the browser from the UTF-8 byte encoding of your input via TextEncoder.

BLAKE2s Hash Calculator Use Cases

Hashing on embedded, IoT, or other 32-bit-constrained hardware
Matching a BLAKE2s-specific value from a system that targets smaller word sizes
Reproducing a known BLAKE2s test vector while debugging another implementation
Comparing BLAKE2s's output against BLAKE2b for the same input to understand the family's design

Common Mistakes

Choosing BLAKE2s on a 64-bit server where BLAKE2b would be faster for the same security properties.
Assuming BLAKE2s and BLAKE2b produce related or truncatable-into-each-other output; they're computed independently and won't match.
Expecting BLAKE2s's 256-bit ceiling to support longer output the way BLAKE2b's 512-bit ceiling does.

Tips

On modern servers and desktops, use the BLAKE2b tool instead, it's the faster choice on that hardware.
If you're specifically targeting embedded or 32-bit systems, BLAKE2s is the sibling designed for exactly that case.

BLAKE2s Hash Calculator