An Opinionated Introduction to Urbit
January 17, 2021 | 30 min. read
Given the events of the first few weeks of 2021 and the ensuing discourse regarding online communities, decentralized platforms have become something of a hot topic. None of these are mainstream in any sense outside of the privacy/FOSS/developer community, but some of the more popular ones include Mastodon, Pleroma, and PeerTube. All of these have in common the fact that they are part of the "fediverse", a community of self-hosted platforms that can interact with each other via the ActivityPub protocol. Via ActivityPub, you can see PeerTube videos from Mastodon, people on different Pleroma servers can follow each other, your self-hosted blog can allow comments via Mastodon, etc. I think these are fantastic projects and a step forward for the Internet, but a different project caught my eye recently - Urbit.
Urbit is one of those things that is surrounded with so much I mean, just look at that aesthetic on their homepage and blog. Minimal, enigmatic, and eyecatching. A+ job to the designer. and promises so much that it is guaranteed to be either revolutionary or a complete scam. The project aims to be not only a peer-to-peer network but also include an operating system, virtual machine, not one but two (functional!) programming languages, and an identity system. These kinds of clean-slate, from-the-ground-up reimaginings of computing rarely leave the ground, and when they do they're often pretty unusable. I just had to see for myself.
Nine Lightyears Away, Just Outside the Kepler Solar System
Urbit is trying to be what the Internet was supposed to be, according to the ideals of the 1980s. In that prehistoric era, people imagined that the Internet would be a peer-to-peer network of individuals freely sharing information, unhampered by existing centralized systems or physical borders. This, as we now know, never came true. The Internet of today is incredibly centralized, and looks more like the computing environment of the 1970s - individuals hook up terminals (now phones, tablets, laptops, etc.) to giant corporate-owned mainframes (now servers run by Google, Amazon, etc.) that store and own all of our data and do the actual computing behind the applications we use. Part of why Urbit is such a radical project is because it realizes that we can't reverse this process of centralization given our current computing infrastructure. If you're tech savvy and willing to front the costs you can certainly buy a VPS and host your own stuff, but your elderly relatives aren't going to swap out Facebook for an EC2 instance anytime Urbit definitely does not solve the necessity for technical competency that's endemic to these kinds of alternative platforms, as you'll later see. I suppose the creators left it up to the end-users to build comfortable clients. Instead, Urbit is a truly personal OS built from the ground up that runs in a virtual machine on any Unix system.
Urbit is not only an OS - it's an identification system. Each Urbit
instance exists as a unique member in a hierarchy. In the Urbit universe,
there are 2^8 galaxies, each galaxy has 2^8 stars, and each star has 2^16
planets. This gives approximately 4 billion unique IDs, each of which are
stored as Ethereum tokens. As you might have noticed there's 7 billion
people in the world at the moment, but only 4 billion IDs for a "personal
OS" to go around. This is intended to create scarcity, making IDs less
likely to be abused and give users skin in the game when it comes to Urbit
as a platform. The IDs themselves are all serialized via a pretty quirky
syllabic naming convention, with rarer entities having shorter names:
~zod is the name of a galaxy,
~taglux is the name
of a star, and
~rovnys-ricfer is the name of a planet. If you
don't have an identity yet you can also boot up a free and disposable
instance called a "comet", which will have a super long 128-bit name like
can do so right now after installing the Urbit binary and
urbit -c comet-name-here. Once you boot up (it'll take
a while) you should see a prompt appear.
Beyond the Horizon of Sanity
Urbit, in terms of software, is composed of several tightly coupled projects.
The entire inspiration behind building an entire software stack from the
ground up, and what makes the OS truly peer-to-peer, is the fact that it's
built entirely of pure functional code. This allows for interesting stuff
like totally deterministic behavior, the ability to serialize and then
deserialize the entire machine state, sending and executing code over the
wire, and its snappy tagline: "An operating function." The actual core OS of
Urbit is named Arvo, the
assembly code of which is called Nock, which runs on the Vere runtime/interpeter.
Nock is incredibly low-level but distinct from typical RISC/CISC assembly in
that it's purely functional so there's no registers, pointer poking, or
syscalls going on - it's all just S-expressions and operations on
Don't get your hopes up, it's nothing like Lisp. Just similar data
I have to say, all of these sleek monosyllabic names get a little tiring
after a while and do a very poor job of hinting at their purpose for
newcomers. Imagine if everything on Unix was named the same way -
systemd? Oh, you mean Sarp?
libcurl? Yeah, that's
called Clon now. At least we're already used to Gimp.
Much like how basically everything in Unix is written with C and compiled down to assembly, everything on Urbit is written in Hoon and then compiled down to Nock. Hoon is, as you can probably guess by now, a pure functional programming language. When I read this on the tin I got pretty excited, and was looking forward to checking out an entire OS written from the ground up in something like Haskell or ML or a Lisp dialect.
This was not the case. Abandon all hope, ye who enter.
It's truly like nothing I've seen before, and I'd like to think I've been around the block when it comes to programming language design. The primary ingredient in Hoon is schizophrenia. It makes Terry Davis look like Brian Kernighan. To illustrate, let's take a look at literally the first example in the docs:
|= end=@ =/ count=@ 1 |- ^- (list @) ?: =(end count) ~ :- count $(count (add 1 count))
What does this do? Oh, isn't it obvious? It takes a number
and returns a list from 1 to
n. No, none of those symbols are
comments or decorators; every single character above is semantically
significant. I can deal with complexity where it's necessary, but a short
look at the docs requires learning a whole new lexicon. The tutorial jumps
around from concepts like "gates" to "arms" to "runes" to "molds" in such a
way that it seems deliberately obscure and frustrating. What could possibly
be so insufficient or broken about, say, functions (after all, it calls
itself a functional language) that they had to be reinvented? Also - this is
a minor nitpick, but somewhat representative of the language in general - in
Hoon, 0 is true and 1 is false .
Because I have yet to do more with the language than go through the tutorial and its exercises a few times, I probably haven't earned the right to be too scathing. Who knows, perhaps Hoon is a joy to work with once you pass the event horizon and become one with the bits. There's a couple resources besides the official tutorial that I'll likely check out in the future: there's the Hoon School online course (again, if a language requires a six-week online course just to learn the fundamentals that should really tell you something) and the community-managed Hooniversity tutorial. I'll leave it at this - it's a real achievement that Arvo kernel modules are called Vanes, and there are quite a few. There's modules for an HTTP client (separate from the server module?), peer-to-peer networking, a filesystem, a terminal, and a build system to name a few. Not sure what the userspace is like, though. has been written in the language so far.
Alright, we've decided we're ready for the future of the Internet and want to buy in. Where do we start?
Most people just start out with buying a planet. Stars are fairly expensive at around $4,000 when I checked at the time of writing this, and galaxies are even more expensive and only available via private sale since most of the 256 have been given out to contributors/friends of the project. Stars and galaxies also represent quite a responsibility because of their dual role as infrastructure in the Urbit network, so if you don't want to make any kind of commitment then buying a planet is the way to go. There are a few places you can buy one - urbit.live, urbit.me, and planet.market are the first few Google results.
I decided to get mine on urbit.live. I just chose the first
None in particular really caught my eye and seemed to define "me",
but while writing this I saw someone with the hysterical (and likely
very expensive) name of
that popped up, since all of the listed names were the same price at 0.025
ETH ($33). The actual purchase was a little annoying because the store
insists on transacting via a browser extension called Metamask. I'm a noob when it comes to
actually buying things via crypto so I'm not sure if this is just the
standard (this was actually my first transaction with ETH) but I already own
wallet that I'm happy with and would rather use for all my transactions.
After shuffling around some funds (and having to foot the transaction fees)
I purchased my name
and set to work on claiming it.
To claim a planet, all you have to do is head over to Bridge, log in using your Metamask, and accept the incoming transfer. I wanted my Urbit tied to my hardware wallet, so I decided to transfer the point yet again to my hardware wallet's ETH address. After some more transaction fees, I was now the proud owner of my own Urbit planet. All I had left to do was actually get Urbit up and running. I downloaded the Arvo keyfile that's used as input for the binary that boots up your instance and got started. Here came the hard part.
I blame the following mostly on myself for misreading or skimming the docs too quickly, as in my
hubris I assumed it'd be as simple as running a few commands. After starting
up my ship with a simple
urbit -w <planet-name> -k
<keyfile> I was up and in a prompt. I noticed a message saying
my neighbor galaxy
~zod was unreachable, and when I tried using
the Landscape app (we'll talk more about it later) I was also unable to
connect to anything. I perused around Bridge and noticed some greyed out
options referring to a missing "Master Ticket". Because I was using my
hardware wallet as my actual Urbit ownership address I didn't need a Master
Ticket, which is just a long passphrase that's used in lieu of external
authentication. I was unaware of this and just assumed that was causing the
networking problems, so I generated a Master Ticket and unknowingly
transfered my ownership out of my hardware wallet and into the Master Key. I
knew that generating a Master Ticket required resetting the Networking Keys,
so I did that too. I was then very confused when I saw that the ownership
address had changed, at which point I had to re-transfer back to my hardware
wallet and re-reset the Networking Keys. Now that I was back to square one,
I decided to just wait it out and see if I eventually connected, which I
did. This discovery only cost me about $50 in ETH of transaction fees. Go
So, now that we have an Urbit, what can we actually do? Well, the flagship app is called Landscape. You can find it at port 8080 of your Urbit instance and check it out (go ahead, boot up a comet if you haven't already).
It's a chat app. It's basically a clunkier Slack (which is itself a clunkier IRC) without some of the features. The first thing I noticed was a rendering bug where the screen jitters while scrolling, which makes it pretty hard to actually browse through messages. There are also separate apps for personal notes/blog posts, DMs, and a forum feature where users can create posts and others can comment on them. The cool thing is that users can create their own channels and truly own them since they're hosted on their Urbit instance. This is all useful stuff, but I have to admit that I'm a tiny bit disappointed after the considerable hype I tricked myself into.
Let me start my concluding thoughts with this - I think it's a very lame thing to criticize radical ideas simply for being radical. Urbit is trying to address the very real problem of digital centralization in a way that few projects are really capable of. I'd previously mentioned the Fediverse as a step forward for the Internet, but that's all it is - a tiny step forward. Nothing is stopping the unrelenting phenomena of centralization from reappearing in the Fediverse. Mastodon instances, for example, still need hosting, DNS registration, payment processors, etc. and users of an instance are always ultimately beholden to the interests of its administrators. That said, Urbit is essentially throwing away the past 40 years of hardening, research, and adoption that comes with the x86/C/Unix stack. Whether it will be able to address some of the fundamental problems of those technologies or just create new problems, only time can tell.
Urbit as a project was started in 2002, received funding in 2013, was largely rewritten, and then released "OS 1" in 2019. I'm sure the majority of contributions and development momentum has come about in just the past two years (I only started hearing buzz about it around the end of 2020), but I think many would really expect an almost 20 year old project to have more to show for itself. I'm not going to call it vaporware though, and after doing a deep dive on the project I think it's unfair to call it such. There might not be a lot going for end users, but considering the groundwork that's been laid I'd say it's comfortably in alpha.
I listened to a podcast featuring some of the engineers who work at Tlon, the company building Urbit. The host asked a pretty provocative question, suggesting that Urbit might become the digital equivalent of Esperanto: a technologically brilliant invention, but forever a small novelty compared to the previously existing and far more popular alternatives. I think that this is basically inevitable for Urbit - even if someone makes a killer app that's not reproducible anywhere else - unless it seriously reimagines its stack. Not to beat a dead horse, but Hoon is absolutely ridiculous. It's practically impenetrable without serious effort and previous experience with niche functional languages, and the project will never be able to cultivate enough contributors to gain real maturity until it either massively invests in accessible educational resources (the official tutorial sucks, sorry) or rewrite the Another alternative would be to add support for compilation of another functional language like a domain-specific Lisp or ML dialect to Nock, which I think would have a huge amount of interest for beginners and gain some interest from those language's respective communities. Even a higher-level "glue" language similar to Perl's role in Unix would be welcome. such that the bulk of the semantics are not represented by arcane symbol combinations.
Overall, I would say that my time with Urbit has been pretty fun. Every now and then you start to feel like you've finally seen most of the things there are to see, and something totally alien like Urbit comes along to drag you down the rabbit hole. It's also rare to see this kind of genuine and unabashedly idealistic project, and even more rare to see one with real products and a growing community. The community has been very welcoming and fun to chat to, although the identity system is perhaps concerning for those who are very wary about their digital privacy. There are some very exciting apps that are on the horizon for Urbit, like a Bitcoin wallet that will essentially allow people to send money directly to you via your Urbit name and interface with other Urbit apps. It's easy to imagine things like a totally self-hosted Substack, where other Urbit users can directly send money to your instance, automatically get access to view content hosted on your instance, then send comments/DMs to you directly via your Urbit ID byline - all integrated within Urbit. No censors, no hosts, no banks, and no platforms. I could almost shed a tear.