Python bindings for the
official Rust implementation of BLAKE3
, based on
. These bindings expose all the features of BLAKE3, including extendable output, keying, and multithreading. The basic API matches that of Python's standard
module.
Examples
fromblake3importblake3# Hash some input all at once. The input can be bytes, a bytearray, or a memoryview.hash1=blake3(b"foobarbaz").digest() # Hash the same input incrementally.hasher=blake3() hasher.update(b"foo") hasher.update(b"bar") hasher.update(b"baz") hash2=hasher.digest() asserthash1==hash2# Hash the same input fluently.asserthash1==blake3(b"foo").update(b"bar").update(b"baz").digest() # Hexadecimal output.print("The hash of 'hello world' is", blake3(b"hello world").hexdigest()) # Use the keyed hashing mode, which takes a 32-byte key.importsecretsrandom_key=secrets.token_bytes(32) message=b"a message to authenticate"mac=blake3(message, key=random_key).digest() # Use the key derivation mode, which takes a context string. Context strings# should be hardcoded, globally unique, and application-specific.context="blake3-py 2020-03-04 11:13:10 example context"key_material=b"usually at least 32 random bytes, not a password"derived_key=blake3(key_material, derive_key_context=context).digest() # Extendable output. The default digest size is 32 bytes.extended=blake3(b"foo").digest(length=100) assertextended[:32] ==blake3(b"foo").digest() assertextended[75:100] ==blake3(b"foo").digest(length=25, seek=75) # Hash a large input using multiple threads. Note that this can be slower for# inputs shorter than ~1 MB, and it's a good idea to benchmark it for your use# case on your platform.large_input=bytearray(1_000_000) hash_single=blake3(large_input).digest() hash_two=blake3(large_input, max_threads=2).digest() hash_many=blake3(large_input, max_threads=blake3.AUTO).digest() asserthash_single==hash_two==hash_many# Hash a file with multiple threads using memory mapping. This is what b3sum# does by default.file_hasher=blake3(max_threads=blake3.AUTO) file_hasher.update_mmap("/big/file.txt") file_hash=file_hasher.digest() # Copy a hasher that's already accepted some input.hasher1=blake3(b"foo") hasher2=hasher1.copy() hasher1.update(b"bar") hasher2.update(b"baz") asserthasher1.digest() ==blake3(b"foobar").digest() asserthasher2.digest() ==blake3(b"foobaz").digest()Installation
The blake3 package is installable from PyPI like most other Python packages. For folks using a package manager like
, that's:
uv add blake3 Or the "old school" way:
pip install blake3 This package uses the Rust implementation of BLAKE3 internally. There are binary wheels
for most environments, so most users don't need a Rust compiler. But if you're building the source distribution, or if a binary wheel isn't available for your environment, you'll need to
first.
C Bindings
Experimental bindings for the official BLAKE3 C implementation are available in the
directory. These will probably not be published on PyPI, and most applications should prefer the Rust-based bindings. But if you can't depend on the Rust toolchain, and you're on some platform that this project doesn't provide binary wheels for, the C-based bindings might be an alternative.