A name in. A glyph out.
Always the same one.

How it works

The seed is normalized, prefixed with a frozen tag, and hashed to a 256-bit digest. Every bit of that digest is drawn into the grid: 256 pixels in mono, or 64 four-bit color cells. Nothing is thrown away, so the glyph is a lossless picture of the hash and reads straight back into its digest.

Pick your hash

The hash decides the glyph; the style only decides how it is drawn. Choose from 17 hashes rendered in 2 styles. BLAKE3 is the default. The digest below is the seed hashglyph under each hash, so you can see how every one lands on a different glyph.

Plain-English glossary

Every option in the studio, explained in one line, with a link to the source so you can read more. The hash fixes your glyph; the style only changes how it is drawn.

Hashes

blake3 BLAKE3

Fast modern hash that can stretch to any output length on its own. HashGlyph’s default; it mints the canonical mark. BLAKE3 spec ↗

blake2b BLAKE2b

Fast 64-bit-tuned hash. The workhorse inside Zcash, libsodium, and the Argon2 password hash. blake2.net ↗

blake2s BLAKE2s

BLAKE2 tuned for 32-bit and smaller devices. Same family as BLAKE2b, narrower state. blake2.net ↗

sha256 SHA-256

The SHA-2 standard that secures TLS, Bitcoin, and code signing. The default “SHA” most people mean. NIST FIPS 180-4 ↗

sha224 SHA-224 (reduced)

SHA-256 truncated to 224 bits. Same engine, shorter digest. NIST FIPS 180-4 ↗

sha384 SHA-384

SHA-512 truncated to 384 bits. Common in TLS certificates. NIST FIPS 180-4 ↗

sha512 SHA-512

The wide SHA-2 variant, faster than SHA-256 on 64-bit CPUs. NIST FIPS 180-4 ↗

sha512-256 SHA-512/256

SHA-512 cut down to 256 bits. Fast on 64-bit machines, immune to length-extension. NIST FIPS 180-4 ↗

sha3-256 SHA3-256

The newer SHA-3 standard (built on Keccak), designed differently from SHA-2 as a backup. NIST FIPS 202 ↗

sha3-512 SHA3-512

The wide SHA-3 variant with a larger security margin. NIST FIPS 202 ↗

shake128 SHAKE128

A SHA-3 “XOF”: like SHA-3 but can emit as many bytes as you ask for. NIST FIPS 202 ↗

shake256 SHAKE256

The wider SHA-3 XOF, with more security headroom than SHAKE128. NIST FIPS 202 ↗

keccak256 Keccak-256

Original-padding Keccak, the exact hash Ethereum uses everywhere. keccak.team ↗

keccak512 Keccak-512

The wide variant of original-padding Keccak. keccak.team ↗

ripemd160 RIPEMD-160 (reduced)

A 160-bit hash from the ’90s, still used to shorten Bitcoin and Ethereum addresses. RIPEMD-160 ↗

sha1 SHA-1 (broken)

The old 160-bit web hash. Broken for security (real collisions exist) but still git’s object id. Here for nostalgia. SHAttered ↗

md5 MD5 (broken)

The classic 128-bit checksum. Broken for security, but fine for non-security IDs and included for recognizability. RFC 1321 ↗

Render styles

mono-16 Mono 16×16

Black & white 16×16 grid. Every one of the 256 digest bits is one pixel, so the whole hash is on the wall and reads back exactly. source ↗

color-8 Color 8×8

An 8×8 mosaic where every 4 bits choose one of 16 colors. The same digest as mono, shown in color. source ↗

Concepts under the hood

Digest = identity

Your glyph is the full 256-bit hash of your seed, drawn pixel by pixel. That digest is the unique id; the picture is just a view of it. how it works ↗

Reversible (decode)

Because no bits are thrown away, a glyph reads back into its exact digest. You still can not recover the original text: hashing is one-way. decode & verify ↗

Collision resistance

With a strong 256-bit hash, two different seeds landing on the same glyph is computationally infeasible. Broken hashes (MD5, SHA-1) can be forced to collide, so they are for fun only. collision resistance ↗

Seed normalization (NFKC)

Before hashing we Unicode-normalize, trim, and lowercase your text, so Acme and acme map to the same glyph. Unicode UAX #15 ↗

Domain separation

We prefix a frozen tag before hashing (hashglyph-v2|name) so HashGlyph digests never clash with the same name hashed elsewhere. determinism contract ↗

XOF (extendable output)

A hash that emits any number of bytes you ask for. BLAKE3 and SHAKE are XOFs, so they produce the 256-bit digest natively. NIST FIPS 202 ↗

Counter-mode expansion

Fixed-length hashes can not stretch, so we re-hash with a rising counter (H(prk ‖ i)) until we have 256 bits. This never adds entropy beyond the hash itself. NIST SP 800-108 ↗

QR mode

Optionally encodes a link as a standard QR code with your glyph centered inside it. QR standard ↗