When I was younger I would dream grandiose concepts and ideas that would make the world tremble. I think we all have a bit of that ideal inside of us as humans; the desire to build, to grow, to do something great. To not be like our parents, to bring our own fresh ideas to the table, and to try and change the world in whatever crazy way we imagined it. Of course, part of growing up is the ability to reconcile your inner child with the adult that you must be. The world can’t run on dreamers alone; someone has to get down in the pits and help build that dream. In a more biblical sense, Corinthians contains the ever-famous quote:
When I was a child, I spoke and thought and reasoned as a child. But when I grew up, I put away childish things.
This kind of struggle is often won out by the “real world”. When we’re young we learn to think for ourselves, and take that at face value to create our own mental constructs and concepts. As we grow older, we learn the concept of accretion – that the wisdom of the older generation and their predecessors often contain the solutions to the present day problems of our world. We learn that, instead of reinventing the wheel, to take what already works and gradually improve on that. It’s a much better way of achieving success in business, relationships, and just about everything else. That’s why a project like Urbit, when looked at from a technical, philosophical, and pragmatic angle, simply doesn’t make sense. Reinventing the wheel sounds great on paper, but in practice you often get led to the same problems that others have already solved.
…So why is Urbit so interesting?
The dysfunctional tech stack
The “tech stack” as it were, is essentially what allows you and I to interact over the Internet. It’s what lets us communicate on forums, write review posts on WordPress, or post silly cats on Twitter.
But the problem is that in order for any of these things to happen, many computers have to do synchronized work together. They have to do so in a compliant way to whatever API is being utilized, and they have to hope that no one gets their net cut out during the process.
The problem we face today is that we have a massively complex tech stack for relatively simple things. An app like Facebook or Twitter uses many different services, APIs, and unnecessary computing power that cuts down on the overall marginal cost of the entire system, when conceptually you could write these apps much simpler (if the infrastructure was there). The reason the Internet and the tech stack is in the state it is today is because no one actually knew this was what the Internet would eventually become.
Essentially, what we as users have done throughout our years on the Internet is create a facsimile of a personal server – with our data sharded (lol!) across a plethora of online services. Instead of directly owning and using our data, we have circuitously made a network that simulates a personal server. So, how did we arrive at this solution in the first place?
An example is the horse. We didn’t make faster horses, we just replaced it with the car. And the Internet is like a horse from the 1970’s that’s been genetically engineered and outfitted to run really really fast instead of scrapping it and going with a car. Sometimes, throwing out the wisdom of the ancients make sense.
But what does it do?
In very simple terms, Urbit is a personal server that can be run on anyone’s computer over the web or even your own personal computer. It’s an operating system, a coding language, a universal API, a storage system, and a decentralized computer all in one. You can install Urbit on any Unix system and have your server (called planets by Urbit) up in moments. You can build an app like Twitter or Facebook on Urbit, where your data is completely private, in a matter of days and weeks instead of months and years. The gains lie in the simplicity of the software stack that Urbit has rebuilt from the ground up to support the infrastructure of the Internet.
Solutions like this do currently exist today – but they don’t go as far in scope as Urbit. If you want your own personal server, you can buy one for a few dollars a month on Amazon Web Services, or even host your own by buying a Unix box. The problem with that of course, is that not everyone is a Linux administrator. Sure I could buy a server for a few dollars a month and configure all the settings myself, but I’d rather pay WordPress a few hundred a year so that they can handle all of that work for me. Urbit essentially gives you the power of your own personal server with the usability of non-techy offerings.
A lot of people would tell you that a market doesn’t really exist for these kind of services, so why would anyone ever think of this as an interesting investment? Well, imagine if everyone in the future suddenly has their own Urbit that they actively use for simple things – maybe sending images to friends, playing nerdy games, or just running it as a WordPress alternative. How quickly do you think a market would suddenly pop up for this kind of thing? And the gains compound, like everything in tech.
You do end up with the problem that every great idea has, though; that of finding a seed user base to actually buy into this kind of thing. It has to make sense for the very first user today, not tomorrow. And that’s the real challenge for Urbit – thankfully, they’ve already solved this with their self-hosted content publishing feature.
The owners of WordPress are valued at a little over a Billion dollars – Urbit takes that out in an instant, and that’s not even what it’s trying to do. Afraid of big brother Facebook creepily selling your data or keeping all of your family photos on some weird server that you don’t have access to? Boom, another usecase for Urbit. Need a website or server that can easily withstand DDOS attacks? Another win for Urbit, and another billion dollar company destroyed. But how DOES it withstand DDOS?
The secret is in the way Urbit is actually designed. See, Urbit doesn’t use TCP/IP as its communications interface. It uses UDP. What’s UDP?
UDP is essentially another method of communications between computers over the IP protocol. While TCP is nice and safe, UDP can be more unreliable. TCP performs many checks to see whether the recipient has received all of the packets of information, and if it hasn’t, it throws a massive error. UDP, on the other hand, just quickly sends the packets once and it’s done. Naturally, Urbit itself is built in such a way that if a packet of data is lost or even if some server that is necessary for a service to function cuts out Urbit can easily re-build its state at the time of the interruption. To explain how it does that, we need to talk about coding languages.
See, most coding languages today are a far cry from actually interacting with the computer itself. Most coders will create a line of code that tells the computer what it wants it to do, but not what it will do. That’s usually left for the processor itself to creatively come up with a solution. But that introduces a lot of technical debt and unstable results – the deterministic OS of Urbit means that it takes direct order from the code, and you can always reach where you last left off by following the code and instructions from the last time Urbit was running. Lost your data connection? Don’t worry – when it comes back up Urbit can easily continue running as if nothing ever happened.
Urbit is wacky
There are so many things about Urbit that just scream out “this isn’t going to work”. You have: a technical project that completely throws out the very underpinnings of the Internet, a deterministic Operating System (Arvo) with not one but two brand new languages (Hoon and Nock), a decision for UDP over the standard TCP/IP, and a main developer who, when not working on his fever dream idea, is spending his free time debating the suitability of certain cultures for slavery and being depicted as an alt-right extremist.
The scope of the project is also so huge that it’s extremely difficult to properly explain exactly what this thing does and why it could be so huge. But this is also exactly what makes this such an interesting project. The creator, Curtis Yavin, started work on Urbit in 2003 – nearly 6 years before the Bitcoin whitepaper and network came into existence. Clearly, the idea of decentralization and other cypherpunky concepts were something that was entering the conscience of the public. And while Bitcoin and Urbit are completely different beasts, they tackle many of the same problems from the same conceptual angle. As the Urbit team describes it best – Bitcoin is digital money; Urbit is digital land.
One thing that impresses me about the Urbit team is their honesty and sincerity regarding the project itself. In the introduction video, Galen mentions that “we may not yet know what Urbit is most useful for.” Those are powerful words for a project that has been in the works for over 10 years, and it reminds me of the scene in The Social Network where Sean Parker tells Mark and co. the exact same thing:
A Federated Internet
Up until now I’ve focused my discussion on some of the technical aspects of Urbit. It’s inherently decentralized, but one interesting factoid that should be made apparent is that it’s not a blockchain. Urbit does have a governance model though – and it feels like it’s ripped straight out of some cypherpunk novel.
We already know an Urbit is basically your own private server – in the Urbit system, these are called Planets. Now, every planet can run independently, but if you want to offload some of the work you would do yourself (for example, updating the software), you can choose to tie your planet down to a Star. A Star is essentially a large entity that does managerial tasks like the aforementioned system updates for its underlying planets – each Star can manage around 65’000 Planets. Stars themselves are also governed by even larger system administrators – these are called Galaxies, and it’s where Urbit gets really cool. Galaxies can basically set the terms and conditions under which the Stars operate which then set up the ground rules for each individual Planet. In total, there will only ever 256 Galaxies, each controlling 256 Stars, who then control the 65’000 planets. In total, that’s 4 billion Planets – enough that everyone in the world who would have need of a Planet could get one, but limited enough that spammers can’t freely buy Planets for low cost.
A crucial difference between Urbit and other networks is that planets are scarce. Even when the network is fully populated, there are only 4 billion. Early in Urbit’s life, most stars and galaxies are not yet operating, so far fewer are available. No one will ever be able to get planets trivially and for free.
Urbit is a friendly network: a network on which you can assume that a stranger is nice until proven nasty. Friendliness is a direct consequence of scarce, individually owned identities. We’re not changing human nature, just creating the right economic incentives.
Most forms of network abuse are “Sybil attacks”: they rely on an infinite supply of fresh identities. Scarcity makes reputation work. Spam is a business; if the cost of a new planet exceeds the amount of money you can make by spamming from that planet until its reputation is trashed, there will be no spam.
Shady stars and galaxies that sell blocks of planets to spammers will also develop reputations as “bad neighborhoods,” damaging the value of the whole block. Abuse at any level is designed to be counterproductive and economically self-terminating.
In general, Stars will be able to choose which Galaxies they’d like to “live” under, and Planets can choose which Stars they’d like in turn. You can imagine a scenario where some Stars are better than others, either for their reputation, services, or pricing. Therein lies the economic incentive that will drive future Stars and Galaxies to provide great service and build reputation, both for themselves and for the entities under them.
But will it work?
Urbit is a clean slate global computing platform; a complete redesign of programming. Urbit is a protocol, a language, an OS, a database, and a digital identity. No one has ever tried to build anything like Urbit before, and Urbit is completely open source and patent free. Urbit as a tool is designed to be a personal cloud server. A personal server is a complete redesign of the cloud user experience. Instead of running apps on the developer’s machine, you’ll run the apps on your own virtual computer. You’ll own and control your own data, code, and identity.
The big idea here is that Urbit will be the personal computer that’s your home base for interactions with the Web 3 world. I don’t know that they have real competition for this–even Blockstack, which is the most similar project, is basically complementary. Even Blockstream’s Simplicity programming language takes notes from the Urbit Whitepaper.
ETH heads like Joey Krug and Juan Benet love Urbit, as do Bitcoin maximalists. Arthur Breitman is involved; Founder’s Fund, Draper and Peter Thiel are all involved. The main concern these people have is that the project is too ambitious and esoteric-seeming–why try to do everything at once when you could rebuild the stack piecemeal? But that’s also why they’re attracted to it. If it works, it works big.