Proposal: Memorable immutable names

While wandering on the internet I found this system, What3Words, that converts any lat/long coordinate into 3 memorable words.

For example, the statue of the liberty is “planet.inches.most”. It’s fun to discover what’s the name of your own home address.

So, I was thinking: what if we apply the same principles to immutable names? For example, instead of memorizing that funny meme as “h7234673uksdjl…”, you can easily memorize it as “plucky.impound.posts”.

How will a 512-bits immutable name fit on a word based coding?

Let’s say we have a 256-word dictionary (8 bits) and the final code has 4 words. Then we have 32 bits. If we get a CRC32 (or whatever 32 bits hash) of the immutable name, we can convert it to this system.

How to convert the 32-bits name back to the 512-bits name

When saving named objects on the network, we generate a mutable that will be named as the 32-bit hash and will contain the 512-bit immutable name. If you want to access “plucky.impound.posts”, you just need to open this mutable, check if the 512-bit name matches the 32-bit hash and read the immutable. If it doesn’t match (attack), we jump to the next version which is a 512-bit hash of the 32-bit hash.

What about collisions?

Collisions happen when 2 or more objects have the same 32-bit hash. If is already a valid mutable using the same name, we use its next version.

Final considerations

I think this memorable immutable names can be particularly useful with the “safe-obj” viewer proposed here: SAFE Browser proposal: link to immutable objects.

Are you a whistleblower that want to share that file? Just spread the “kicks.pasta.steer” word. It’s easier than a long 512-bit string. You can even tattoo it as in a spy movie :smiley:

With it, you can memorize memes, viral videos, or even objects like PDFs. It’s a bookmark system that uses your memory. A memorable name can help to manage public resources on your page, it can help to bookmark files (using your own memory), and much more.

PS: What3Words is a proprietary system, that charges royalties for its use. Mongolia’s government is replacing their zip codes with this system, which is being very controversial. But please, this is not the focus here. Let’s not discuss this on this topic.

EDIT: immutable names are 512 bits, not 256.


One concern I would have is that 32 bits is way too small. Its not if a collision occurs but how many for each 32 bit value. Chunk size can be 3KB to 1MB and lets say probability of a collision is 50% then storing just 6.4TB to 2147TB will result in a collision. A collision is more likely than 50% but lets run with that as an average

SO after 6 to 2000 TBytes there will on average be a collision for each chunk stored. I think we can safely say that there is going to be many times more data than this stored on SAFE after even just a little while. I could put up a few useful TBs of data myself.

Basically I am suggesting that you need to increase the number of words and perhaps increase the size of the dictionary to 512 or 1024.

Also what happens for non english speaking people? Do you use a different dictionary? or must the name be the same whatever the language.

Can I suggest that the lookup mutable objects have a number of addresses stored. The number of fields should be much greater than 4 when the network is live. I would think 1024 fields should be possible. This way you need around 2^22 objects for no collisions and add collision MDs as needed.


Good points. My idea is that not all immutables would be memorable, only DataMaps. People can register each chunk, but it will cost a lot of money.

And I agree that 32-bits is a too small number. It means only 4 billion unique files on the network. It’s at least 4 Petabytes (4,000 Terabytes), but still, it’s too small.

A collision itself is not a problem since we just need to use the hash of the hash until we find a free mutable name. For translating to the 512-bit name it will always take only 1 get. The problem is when we have more files than addresses.

A solution for the address depletion would be to add new words whenever a collision happens. For the first collision, it uses 5 words, then 6, 7 - I don’t think we would ever have more than 6 words as this would be 2^60 files (considering a 1024-word dictionary). And yes, increasing the dictionary is also a good approach.

PS: by the way, I wrote it wrong: an immutable name has 512 bits (64 bytes), not 256.

I would say that this is a kind of an immutable DNS. It has a human meaning, it can be memorized, but at the same time is based on the contents and cannot be freely chosen and so it’s verifiable.

And going further, this could also be an alternative for a non-squashable DNS system. If we think in our home addresses as some kind of DNS of the real world (which translates to the not-so-easy-to-memorize lat/long coordinates), this would work in the same way.

What if Google site is not on “” but rather on “kicks.pasta.steer”? It’s weird but in the real life, Google headquarters are not at “Google St, 1” - for ages we used a system where the company name is not related to their address names and this has never been a problem.

PS: I know I’m going too far here with this alternate DNS. For now, even I wouldn’t be comfortable with a DNS like this. Consider this more a random thought than an actual serious proposal.

sounds good, but sounds like something that would exist on the app layer instead of the network layer, right?

but maybe that’s what you’re proposing. Haven’t read the whole thread yet

1 Like

Some natural law I expect reads: That which does not need to be network, should be an app…

There would be any number of answers for resolving a complex string into a few words; so, I’d expect it would be app - and the better one wins. First word could be to note the application even, and they all win.

Was it Alexander Pope that suggested something along the lines of “That which can be said, can be said simply.”


No, you wrote it right. A name has 256 bits (be it of an immutable data, a node, a mutable data, …). The length was changed about one year ago from 512 to 256.


I also like the What3Words mnemonic concept, but they’re keeping everything pretty tight.

BitCoin also developed a mnemonic for memorizing a 12 word seed to represent 256 bit private key hashes. Unlike What3Words, it’s all out there are open source. They also support a number of languages.

Here is an example with wordlists in 6 or 7 languages:

I haven’t seen where the community posts their word lists authoritatively, but the word lists seem to be consistent across bip 39 compatible software.

1 Like