Why Urbit?
Blockchains are the most exciting piece of peer-to-peer (p2p) technology that has come about in the past two decades. Entire ecosystems and billions of dollars of value have come out of seemingly nowhere thanks to the initial innovations of Satoshi Nakamoto.
Given that there is so much promise and potential in blockchain tech, developers are jumping on board and eagerly working towards finding out how far blockchains can be pushed. For many this is their first experience with p2p systems, and as such many projects try to use the blockchain as the one all-purpose server to meet all needs.
Whether they are building an on-chain game, invoice system, performing complex multi-party computation, or trying to use addresses as persistent identities, these developers are often trying to fit a square peg in a round hole by attempting to use blockchains in directions that they don’t excel in. Generally all of these different use cases/projects are based around:
- Blockchain as a P2P messaging medium.
- Blockchain keys as an identity.
- Blockchain as a world computer.
In the following sections we’ll take a look at why blockchains are not the ideal solution for these, but in fact only a marginally more decentralized step with a number of key pitfalls.
Blockchain As A P2P Messaging Medium
Due to the fact that everyone is watching the blockchain as a source of truth, it is in effect a source of global coordination. As such everyone from full nodes, exchanges, to light wallet users are all able to have access and read data which gets posted inside of the latest blocks.
This realization inevitably leads to many new blockchain developers coming up with a simple conclusion; if everyone is watching the chain, why don’t we use it to send messages to each other? Everyone already has asymmetric crypto keys and wallets/tooling which can be used to encrypt and/or sign messages which can be posted directly on-chain where the recipient will be watching.
This seems like an exciting innovation, because suddenly not only do we have our financial assets on the ledger, but now we can in fact programmatically combine them with messaging which opens a whole host of use cases. This opens up potential for invoices, gaming, decentralized messaging protocols, and much more.
However, even though so much potential appears to be unlocked, it is a short lived excitement because blockchains are in fact a very sub-par messaging medium. The reasons for this include:
- Users must pay transaction fees for every single message that gets sent, which adds up to a significant chunk of change. This is to prevent DoS attacks, meaning that if there were no transaction fees then anyone could send millions of spam transactions at no cost and cause serious problems. Transaction fees act as a very crude form of sybil resistance for messaging, which can be improved on as we will see later on.
- Messages can range from taking seconds to hours or even days (if you want to pay low tx fees) to be accepted in a block. This inconsistency and extremely long wait times (from a messaging perspective) are major negatives when trying to build robust use cases on top.
- Users must fight for space in blocks to post their messages with other people who are using smart contracts, sending money, etc. Often messaging use cases for blockchains require a reasonable amount of throughput in order to function, however they will have to pay transaction fees rivaling DeFi dApps with potentially millions of dollars on the line to get included into blocks.
- Messages on blockchains aren’t actually p2p. The messages first go to the mempool where miners can choose to censor/ignore them before they get included onto the blockchain for the recipient to actually see the message.
- Every message that is submitted to the blockchain is publicly visible to everybody which considerably degrades privacy. Even if the messages are encrypted, there is significant metadata leakage; we know Alice sent a message to Bob, how large the message is, and whether or not Bob replied (in basic on-chain messaging schemes). Depending on the specific use case having this metadata publicly available and forever written into the blockchain history can be a major negative or even break certain protocols entirely.
Given that we are not dealing with a technology that was originally designed to be a robust p2p messaging protocol, it should not surprise us in the end that blockchains do not do well for this use case.
Blockchain Keys As An Identity
After stumbling upon the idea of blockchain as a messaging medium the next conclusion people tend to arrive at revolves around the fact that every user has an asymmetric keypair. If a crypto wallet already consists of a crypto keypair which has the ability to sign and/or encrypt off-chain in addition to being used to act on-chain, what if we allowed individuals to build their identity around their blockchain keys?
Users could link their on-chain financial identity with various off-chain website accounts, profiles, and more. In a sense we could combine the user’s entire online identity under one keypair that they can take with them everywhere they go on the internet.
This however falls into several problems:
- Keypairs have no metadata attached to them nor one standard of where this metadata is supposed to be stored, nor how to access it. You might be able to put some of this on a specific blockchain, but users often use multiple blockchains/sidechains/rollups meaning that this data needs to be easily available no matter the context that they are in.
- Crypto keypairs are not sybil resistant. In other words anyone can create an infinite number of keypairs, and thus have an infinite number of identities. This is a major failure of any identity system due to the fact that it encourages spamming, DoS, and bots with no disincentive to stop them. This is one of the reasons half of the internet today requires you to fill in CAPTCHA codes, and crypto keys as identities would suffer the same fate.
- Due to HD wallets becoming the standard in the crypto space, users may have multiple addresses/keypairs rather than just one. This is especially compounded in UTXO-based blockchains which generate new addresses to send change to in every transaction.
- Cryptographic public keys are not designed to be human friendly. No one can remember their own public key, let alone 5–10 close friends like they can with phone numbers or emails. This makes sharing one’s identity with others very challenging and also makes it easier for scammers to trick unsuspecting users due to the fact it is not trivial for a human to double check the pubkey off the top of their head.
- Because crypto key identities are not directly integrated into a messaging protocol, there is a constant coordination problem for end users. In the user <-> user case, even if you know someone’s identity (public key/address) you have no way of actually communicating with them directly besides mindlessly searching through a bunch of centralized services hoping to find an account linked to the pubkey. For user <-> service, each of these websites/services have no default standard for interacting with the user. Furthermore once the user closes off the web page, there is no ability to use the identity to contact/notify the user if something of vital importance is happening (ex. You can’t send emails to a pubkey).
All of these issues compound together and make blockchain keys unsatisfactory as a default form of identity. They have a few nice properties over phone numbers and email addresses, however they suffer from too many negatives to truly shine for this purpose.
Blockchain As A World Computer
Lastly we come to the age old vision of blockchain as a world computer. I think we have all heard this pitch many times before, so let’s jump straight into the clear lessons that have become painfully obvious over the last few years:
- Blockchains are extremely inefficient as a world computer because every node has to repeat the same computation.
- This cannot scale infinitely to all computation on earth, and barely is managing to keep up as is with a tiny fraction of earth’s population using cryptocurrencies today. This is due to the fact that the state of every application is unified in one place (on the ledger) and the limits of the speed of light/data transfer prevents this model from working at scale.
- Fees are extremely high, as can be seen currently on Ethereum where performing basic actions in dApps can cost over $500 USD.
- All computation and data used within the computation is publicly accessible and recorded forever into the history of the blockchain. For countless use cases this is unacceptable, enterprise being one of the most obvious.
- Front-running/MEV means that miners can take advantage of the fact that all of your data/transactions are public on the ledger and attempt to benefit at your expense from it.
- Miners have the ability to censor/ignore your transactions, meaning you are at their whim for being able to perform computation in the first place.
- You are fighting for block space with every other dApp whenever you try to perform a single bit of computation. In a truly p2p networked computing environment, you would simply execute your part of the protocol and send data directly to the person/set of people who you want to interact with.
These are well known problems that all us who are part of the blockchain space today have felt at one point or another.
Why Urbit Is The Solution
After reading through the previous sections it should be painfully clear that while blockchains are an amazing piece of technology, they are not the panacea which will solve every problem in sight. Many of these problems which people are trying to address are truly hard problems which cannot be taken care of by simply duct taping a bunch of random pieces on top of a blockchain.
If we are going to be serious about coming up with solutions then we need to start with first principles again and design a system which is up for the task. Urbit is in fact the one project which has already done this.
In short, Urbit is a network of p2p nodes (called ships) which combine identity, computation, and p2p messaging cleanly in one. The entire node is designed to be a self-contained computing environment which treats identity and p2p messaging as essential primitives rather than an afterthought.
In practical terms what that means is that you cannot even launch an Urbit ship (p2p node) unless you already own an Urbit identity. It is so tightly integrated into the system that the node itself must know who it is in order for it to run. Thanks to this tight integration this provides us with countless benefits such as being able to instantly message or start performing p2p computation (which is all e2e encrypted) with anyone else on earth by simply knowing their Urbit ID .
Urbit ID’s are NFTs with auto-generated avatars (called sigils) and names. For example the image below is the sigil of the Urbit ID named ~watsup:
The owner of the ~watsup NFT is the one who has the right/ability to boot an Urbit ship as ~watsup, and thenceforth everyone else on the Urbit network will be able to interact with them directly.
These Urbit ships are turing-complete, meaning that they have the ability to perform any computation one desires. Thus at this very moment, users have access to a live and running network of p2p nodes with first class identity/messaging/computation that can seamlessly integrate with existing blockchains and solve every single one of the problems we covered earlier on in this article.
Messages are end to end encrypted, fully p2p, have 0 transaction fees, are sent out instantly, require no fighting for block space, and once peer discovery has taken place no one else even knows the two of you are talking with each other.
Urbit IDs are human-friendly with memorable names and sigils, offer as much metadata and profile information as desired by talking with the running ship, provide best-in-class sybil resistance removing all existing problems of spam/bots currently on the internet, and are fully integrated with the p2p messaging layer thereby being numerous steps ahead of any other existing identity solutions in either the crypto and non-crypto worlds.
Urbit ships provide a full-fledged computing environment which attempts to succeed Ethereum’s failed vision of a world computer with a novel and more realistic vision. A distributed network of p2p nodes which can perform computation of arbitrary complexity with identity/messaging directly baked in allow for off-chain state channels, multisig coordination, rollups, and other p2p protocols to be cleanly implemented. In other words Urbit is the only project currently out there which has the ability to pick up the slack for the areas that blockchains fail to excel in, and it is already live and running today.
When we founded dcSpark we jointly agreed not to just work on blockchains themselves, but pursue building on top of the most promising p2p/decentralized tech in general. Blockchains are clearly a major part of that vision, but after many of years of experience in the space it had become painfully obvious that they weren’t the solution to all problems.
Through this article I have laid out many of the conclusions we have come to ourselves after significant time devoted to this space, and to answer the all too common question “Why Urbit?”.
TL;DR: Urbit is the off-chain p2p messaging/identity/computation solution that we all wish we already had integrated into our blockchain ecosystems, even if most of us haven’t realized it yet.
Post writing this piece, we have also put out a video presentation explaining many of the above points in a more easily digestible form:
