Grasping Urbit: A Beginner’s Guide to Understanding Its Workings

Understanding what Urbit is can be a daunting task, but it doesn’t have to be. In this article, I’ll explain Urbit in simple terms, assuming you have no prior technical knowledge about networking, virtual machines, or computer programming.

The best way to comprehend Urbit is to first understand the motivation behind its creation.

A Bit of Context

When the Internet was born in the 1990s, there weren’t any large websites or applications. In other words, there were no corporations, only individuals. The basic concept of the internet revolved around computers communicating with each other. Indeed, this principle is what defines the internet (in case you’ve never thought about it). When numerous computers share files over a private network (think of a corporation, for example), they form an intranet. To gain access to this intranet, permission is required. The Internet, however, was developed as a network where any computer could connect, find other computers, and interact with them.

This worked extremely well, but it was inherently limited. What’s the point of finding a random individual’s computer somewhere across the globe to exchange files with? Even intelligent people were skeptical. A Nobel Prize-winning economist stated in 1998, “Most people have nothing to say to each other! By 2005 or so, it will become clear that the Internet’s impact on the economy has been no greater than the fax machine’s“.

Yahoo website – 1994

We can’t really blame him, as no one anticipated that the simple connection between computers would enable the creation of things previously unimaginable. For instance: a newspaper could evolve into a news website! How? Someone writes news articles on their computer, and other people connect to that computer to view these files. However, if a large number of people connect to the same computer, it would have to handle thousands or even millions of requests, demanding substantial computing resources.

That’s when servers became crucial.

A server is essentially a powerful computer, designed to handle numerous requests on the Internet. This is why websites or applications are “hosted” on servers.

When you visit, you are establishing a so-called client-server connection. You, the client, simply make a request to a server to access information. The server maintains all the information stored locally and transmits the requested data as needed.

Requests aren’t necessarily limited to read operations. When you create a post on Twitter, you are making a write request (or a POST request, technically speaking), sending information to a server for storage. The existence of social networks was made possible by this.

However, consider this for a moment: when you send a message to a friend via Instagram, Whatsapp, or any other platform, you aren’t communicating directly with them. Everything goes through a server.

This is what the Internet has morphed into: a few centralized servers control the vast majority of online data.

The issues with this system range from censorship and loss of privacy to the selling of personal information.

However, there are also less apparent problems. For example, each website or application exists on an isolated island. Your account on WhatsApp bears no connection to your Twitter account. If a developer wants to create an application that utilizes data from different platforms, it becomes a headache. Every user who creates a new account has to input all their information again, undergo checks, and start their profile from scratch.

Things could be better. Urbit intends to revolutionize the way computers communicate, reinstating a fundamental principle of the Internet: people in control. Allow me to explain what Urbit is.

What is Urbit?

Urbit is an open-source internet sharing platform where each user has full control over their data and owns a unique identity. These identities are limited and scarce, numbering around 4 billion. Another distinctive feature is the ease with which applications on Urbit can communicate with each other.


In practical terms, while the traditional Internet operates on a client-server architecture, in Urbit, every user is their own server. In other words, rather than accessing the Internet as a mere client with all your data stored by corporations, Urbit allows your data to be stored locally.

When I refer to ‘data’, I mean not just your information, but every application you use as well. A useful analogy is the way applications function on a mobile phone. Whether you have an Android or iOS device, you need to search for applications in the Play Store or App Store to download. Google and Apple own these stores, control the apps available, and charge substantial fees for paid apps.

After you download an app onto your phone, you’re essentially downloading part of a program, while other parts of the application data are stored on centralized servers.

But what happens if the app’s developer removes the app from the store and discontinues its services? The app becomes unusable, and all your data is lost. Any networking or connections that existed within the app vanish.

In Urbit, you also download apps, but the key difference is that there is no Google or Apple exercising control. Instead, it’s an open and decentralized portal.

Some might wonder: If Urbit allows you to install apps, but it’s neither Android nor iOS, does this mean that Urbit has its own operating system (OS)? Yes, it does. The OS is called Arvo. However, I prefer to call it ‘Urbit OS’ to keep things simple for beginners.

Continuing with this line of thought, when you download an application from Urbit, you are downloading the complete source code. This implies that if a developer removes their application from Urbit, you can reupload it yourself. Nothing is lost.

Furthermore, other developers can leverage existing applications to build new ones, utilizing the current data. For instance, if Facebook existed on Urbit, you could create another social network with a different design and purpose. After logging in, a user would already have all their friend connections saved.

Disclaimer: this feature of leaving all code open-source is a developer’s choice, not a requirement of Urbit. However, it has become common practice, forming a sort of culture.

As mentioned earlier, you wouldn’t need to create an account each time you download an application on Urbit. Your account is constant, so you simply download an application and start using it without having to re-enter your data.

The reason for the limited number of identities on Urbit (2^32 identities, or approximately 4 billion) is to implement the concept of digital scarcity. Just as Bitcoin introduced digital scarcity for money, Urbit brings scarcity to digital identities. But why does this matter?

Scarcity adds value and curbs spam. Given the finite number of digital identities and the fact that you access all applications with the same identity, it becomes significantly harder to create bots with fake identities that could spam social networks, for instance.

What does Urbit’s architecture look like?

Now that we have a broader understanding of Urbit’s concept, we can delve a little deeper into its architecture, while maintaining the simplicity and didactic nature of the explanation.

We’ve already established that Urbit is a peer-to-peer (P2P) network, as computers communicate directly with each other without intermediaries. But a common issue with P2P networks is that it’s challenging for a computer to communicate with another one located far away.

For instance, let’s say that computer A wants to communicate with computer Y. For this to happen, computer A would have to ask its neighboring computer B if it “knows” computer Y. Computer B would ask C, and C would ask D, and so on, until it reaches Y. This process could take hours.

P2P networks face this problem because they are horizontal networks. To address this, Urbit incorporates a vertical architecture, comprised of galaxies, stars, and planets.

The concept is straightforward. When I’ve talked about a computer being a unique digital identity, I was referring to a planet. That is, Urbit has roughly 4 billion planets. But to facilitate communication, Urbit also includes stars and galaxies.

Each planet is connected to a star, and every star is linked to a galaxy. In Urbit, there are 256 galaxies and 65,000 stars. So, when a planet needs to communicate with another planet, instead of asking a neighboring planet for directions, it asks its star, which then asks its galaxy. The galaxy knows the galaxy of the destination planet, contacts its star, and then the planet. With this system, it’s possible to establish communication between any two entities in a system comprising billions of entities in just a few steps.

Urbit architecture - galaxies stars and planets
Urbit architecture

In addition to planets, stars, and galaxies, Urbit also has moons and comets. Comets are unlimited entities; you can create as many as you want. Thus, comets are useful for bots or for people who simply want to explore Urbit without committing to a specific identity.

Obviously, comets will have some access limitations, and some applications may not accept them.

Moons, on the other hand, are also finite entities, but each planet can create around 4 billion moons. The idea behind moons is to serve as identities for devices in the Internet of Things (IoT).

How does Urbit Work?

It all begins with creating an identity. This could be anything from a galaxy to a comet – the choice is yours. With your identity comes a unique access key, serving as the key to your own digital castle.

This access key is exclusively yours, representing full control over your Urbit ID, much in the same way a private key provides control over a Bitcoin address.

Within the Urbit community, these identities are known as “ships.” Regardless of your chosen entity’s hierarchy – whether it’s a star, a planet, or a comet – it becomes a ship within the network, akin to a private computer amidst a vast digital ocean of computers.

Once you’ve installed the Urbit software, you’re ready to launch your ship. This crucial step ensures the smooth operation of the Arvo operating system and establishes the Ames communication protocol, enabling your ship to communicate with others in the network.

Urbit comes equipped with its own terminal, known as the dojo, allowing you to send commands directly to the operating system. However, to interact with other ships more easily, you’ll likely utilize applications – much like how one would typically navigate the internet via websites and apps.

These applications can be effortlessly installed and utilized. All the while, data transmission happens seamlessly, adhering to the network architecture principles discussed previously.

Should you choose to disconnect your ship, the link is severed but all your information remains safely stored on the network. At any point in the future, you can re-launch your ship from a different computer using your credentials. The principle is strikingly similar to the concept of wallets in the cryptocurrency sphere. If Bitcoin is the embodiment of digital money, then Urbit is the epitome of digital land.

How can you get started with Urbit?

Now that you understand the basics about Urbit and feel less intimidated, you might consider navigating the system yourself, discovering applications, and using the platform. Check out this tutorial: how to get started with Urbit.

Next steps