Urbit can be thought of as a new internet, but what does that mean? Urbit is a secure peer-to-peer network of personal servers, built on a clean-slate software stack. A whole new operating system a whole new functional language and a whole new way of networking between computers and it's built on top of the present internet.
Now you might be asking yourself: we already have an internet, it's already kind of a pain , why on earth would we want a new internet?
What I'm going to propose to you is that the problems that exist with our current way of networked computing are technical problems that need technical solutions. They are not merely a matter of policy or of bad actors. This is the central contention on which Urbit rests.
Let's take a look at three problems that exist with our current computing infrastructure and think about what we would do to fix them, if we could rethink them from scratch.
All Access and No Control
If you think about computing as all of your data and all of the operations that you can do with your data, then you start to understand that computing as it exists nowadays is not just the devices that you have in your hands or on your desktop but also includes Dropbox, Google Drive, Instagram, Twitter and whatever other thing the kids are using nowadays. In all these cases, you are generating all this data and you can do operations on them. Unfortunately the reality is that you can access that data, but you don't control it. A good way to think about this dichotomy it is that the person who actually controls that data can do operations on that data that the person with access cannot. You cannot, for example delete your Facebook account. Facebook controls your account data, so can keep it around as long as it would like.
The reason that the network assumed this centralized configuration, from an Urbit point of view, has to do with the technology that we use to run these systems. We have UNIX boxes that are wired together using http. The Urbit solution is to get rid of both of those things. Let's replace http, let's replace UNIX and let's replace it with an integrated system. What we have now is complex, partially because of historical reasons. We are trying to patch together 70's era software to do things that it was never meant to do. And that's always going to yield a complex blob that needs to be administered by a professional. The idea against that is to give everyone an Urbit-based system that they control and those can network together as a P2P system as opposed to a whole bunch of different silsos.
The internet is, at present, a very unfriendly place. There's a lot of reasons behind that and there's a lot of resources that go into making it friendlier, but one of the core reasons for this unfriendliness is the ability to generate new identities esesentally for free. If I'm sending abusive messages to Jeff and he reports me and gets me banned from Twitter, I can just remake a new identity for free essentially. This is the problem behind spam email, it's the problem behind trolling on Twitter any number of sybil adttacks where you have multipe identies under the control of a single person. Urbit gets around that by having a fixed identity, essentially the pronounceable equivalent of an IP address, that goes with your Urbit system. These take the form of names like ~mastyr-tonteg and ~fopwep-bindev.
This leads to you would hope behavior like the real world where I don't just abuse people in public because I'd have social repercussions. We can get rid of spam by having immutable identities of which there are a finite number. The idea is to make the purchase price more than you'd make from the spam. If each email address costs 10 dollars, and it's going to be worthless after you attempt some scame, whatever you're trying to pull of better get you more than $10, otherwise you're losing money.
We are all constantly using things that are breaking all the time. The more internet enabled they are, the more they break. Part of this has to do with the fact that you're trying to build a house on shifting sands. One of the ways that Urbit gets around this is to use Kelvin versioning where you count down to zero, as opposed to counting up infinitely a la Semantic Versioning. In Kelvin versioning, you give yourself a few hundred integers and you count down on each release. You're approaching a state where the software is frozen and will never be changed ever again. Right now there are a few elements of the Urbit system that are approaching zero. The goal is for the software should be so boring and so straightforward that you can build on top of it, but the software itself wouldn't have to be changed. Hopefully that would yield systems that are less precarious and don't expose the myriad security and usability problems related to constantly updating fundamental software.