A Brief Introduction to Urbit

What is Urbit?

It's perhaps how you'd do computing in a post-singularity world, where computational speed and bandwidth are infinite, and what's valuable is security, trust, creativity, and collaboration. It's essentially a combination of a programming language, OS, virtual machine, social network, and digital identity platform.

The basic concept is that Urbit is a global computer combined with a global filesystem. Each physical hardware component on the network is represented as a 'ship'. These ships range from carriers (the largest, only 256 in existence) down to submarines (the smallest, effectively infinite). Ships are used to run computation locally, and to send and receive encrypted messages with other ships.

1. Carriers are 8-bit ships. There are 256 total carriers and each can create 2^24 destroyers.
2. Cruisers are 16-bit ships. There are 65,280 cruisers and each cruiser can create 2^16 destroyers.
3. Destroyers are 32-bit ships. There are 4,294,901,760 total destroyers. Each destroyer represents a unique reputation in Urbit, for either an individual or an organization. A destroyer is not controlled by the carrier or cruiser that created it; the main perk of owning a carrier or cruiser is being allocated a fixed number of destroyers to create, an asset like land that hopefully appreciates over time.
4. Yachts are 64-bit ships. Each destroyer can create up to 4,294,901,760 yachts. Each yacht is controlled by its destroyer. Whereas each destroyer is an independent reputation, each yacht might be a device associated with that reputation. For example, if a university had a destroyer then each yacht might be a laptop or cellphone belonging to a student.
5. Submarines are 128-bit ships. They are ephemeral, have no reputation associated with them, and can be created or destroyed without a carrier or cruiser. One use case for submarines is participating in digital spaces that allow (or encourage) anonymity.

The sine qua non of Urbit is destroyers, because they are the backbone of the decentralized reputation system. The theory is that destroyers are very inexpensive at first, but get increasingly valuable as their availability decreases. Availability decreases as destroyers are purchased by others, and also as they get banned from sections of the network for spamming or other bad behaviour. This baked-in reputation system is one of the main value propositions of the network.

Some background:

• Urbit is a global computer. You write software by chaining together programs that reside on different ships from across the Internet. Urbit has 'typed piping', so you can safely pipe the output of one program to the next.
• Programs are written in a language called Hoon, which compiles into something called Nock. Nock is basically like JVM code, except for that the entire spec is designed to fit on a t-shirt. The hope is that because all Hoon code gets compiled down into this tiny Nock spec, this will make the system easy to secure.
• The OS does two things: program execution and blocking. To execute a program you simply give the OS the name of the ship that it's on, followed by the path to the program. If the program at that path doesn't exist yet, the OS simply waits until either the program gets created or you cancel the request.
• The entire global computer is stateless and referentially transparent.
• Versioning is built into the OS. So you have paths that basically take the form of ship/directory/version/file, where version can be 1, 2, 3, 4, etc. Alternatively, versions can be tagged with names like 'release', so that you're always subscribed to the latest stable version. Again, if you specify a version that doesn't yet exist, the OS simply blocks and waits for it to be created.
• Similar to how bitcoin keeps a log of every transaction ever conducted, your OS keeps a log of every computation you've ever run. If your computer crashes then you simply replay every computation you've ever run to get back to your current state. I'm not sure how this is supposed to be scalable or useful.

Many of these ideas aren't new on their own, but are remixed in an attempt to create some sort of a cyberpunk-libertarian-transhumanist metaspace. The whole user experience feels very much like being a character in some sort of Neal Stephenson novel.

C.f. also this HN thread from their accidental launch, as well as this YouTube video of their co-founder.

What are the downsides?

• Right now the project is only about 25% of the way toward minimum viable documentation, meaning that it's currently impossible to teach yourself the system no matter how much time you're willing to invest.
• It's unclear how much computation speed, bandwidth, and storage are needed to make this viable. E.g. when your computer stores a log of every computation you've ever run, how much storage space is needed per year? Similarly, when your computer crashes, how much time is needed to replay your past transactions to get back to your current state? And how much bandwidth is needed to make it viable to run software that's chained together from code modules across the Internet?
• There are some vague ideas about how this platform is supposed to be completely secure, but it's all very handwavy and it doesn't seem like they've actually thought this out very much.
• Despite messages between ships being encrypted, the founders state that they've purposely designed the network to make it as easy as possible for governments to regulate and control. It's not entirely clear why this is supposed to be a good thing.
• The founders have done as much as they can to make learning Hoon as counterintuitive as possible for anyone who already knows any other programming language. Literally even 0 is true and 1 is false.

The verdict:

With any project as groundbreaking and ambitious as Urbit, it would be stupid not to bet against them.

But at the same time, the unique mix of ideas and people underlying Urbit makes it seem like it could be the foundation of something really interesting. Many of these ideas are only half implemented, but since this is a work in progress I don't hold that against them. What I do worry about are many of the seemingly arbitrary design decisions, for which no explanation is given.

That being said, the project has almost 250 developers on their mailing list in only a few weeks since launch, and they also have some serious angel investment. More importantly, this world seems compelling enough that one could easily imagine many people getting quickly sucked in and spending decades of their life playing, developing, and connecting. Because of this, no matter how improbable success may seem, it's difficult to bet against them.

Comments

[Chris]

"Literally even 0 is true and 1 is false."

Not exactly unprecedented:

$ true
$ echo $?
0
$ false
$ echo $?
1

[jedahan]

Great, succinct summary of Urbit. I have a hard time articulating why I found/find Urbit interesting, now I can just link people to this post.

[Aaron Beckerman]

Thanks, Alex! You have some justifiable concerns about efficiency. I wrote a bit about Urbit's approach to this on my own blog:

http://www.agoraremora.com/2013/12/07/urbits-approach-to-efficiency.html

[JGP]

I don't have much of a technical background, but I've been interested in urbit and enjoyed your summary. Maybe you can tell me what prospect I have to understand your six bullet points, after "some background." For example I'm interested in the concept of a "spec" (short for specification?) of a compiler, but it sounds like it might be the start of a long story. Do I have to know what a compiler is, to understand the answer? Or take your first bullet point:

"Urbit is a global computer. You write software by chaining together programs that reside on different ships from across the Internet. Urbit has 'typed piping', so you can safely pipe the output of one program to the next."

What does a typical computer, or network of them, do differently? It's not routine for the output of one program to be input into another?

The vocabulary gets harder from there, but it's not boring.

[ASDF]

Yeah, returning 0 for success is common in C also, where more than one error code could be returned from a function.

[kitblake]

This was an illuminating article, thanks.

I think there's a minor error in the first ordered list item:
1. Carriers are 8-bit ships. There are 256 total carriers and each can create 2^24 destroyers.

That should probably be:
1. Carriers are 8-bit ships. There are 256 total carriers and each can create 2^24 cruisers.