git.iko.soy/urbit.org
on master help sign in
Network + OS / Technical Overview copy
209db91Matilde Park
content/understanding-urbit/network-and-os.md+23−1
compare with master
unifiedsplit
@@ -1,4 +1,26 @@
1+++
1+++
2title = "Network + OS"
2title = "Network + OS"
3weight = 5
3weight = 5
4−+++
4++++
5+
6+Our phones are cluttered with apps, ads and notifications. Our laptops are basically just web browsers that connect us to services controlled by MEGACORP. Who knows where your messages, images, contacts and connections live. Let alone how long they’ll last or who is looking at them.
7+
8+The digital world feels like a theme park built to maximize ENGAGEMENT — but we think it’s BORING. What happened to the vision of a computer as a tool that would expand and enrich our lives?
9+
10+While the world has drifted into a fever dream, we built Urbit.
11+
12+Your Urbit ID gets you a name, an address and a crypto wallet — but what about when you want to connect with other people? That’s where Urbit OS comes in.
13+
14+Urbit OS is everything that you need to build and run your own social software and compute with whomever you like. Create a pseudonymous chat group, edit a document together, then split a bar tab and later turn it into a syndicate and start investing. Eventually, maybe you’ll decide to become a microstate that funds everyone in bitcoin — the possibilities are wide open.
15+
16+Since we’ve got a decentralized identity system to build on and everyone runs their own OS, your social software is actually owned and operated by the collective of Urbit ID owners. You can (and should) do whatever you want.
17+
18+We built Urbit OS from scratch. It’s a completely new computing stack. Without getting into the technical details (you can find those [here](@/understanding-urbit/technical-overview.md)), Urbit OS is built to do three things: be a compact and complete system (simple); run forever with no maintenance (durable); and be extensible by anyone (yours).
19+
20+Urbit OS is a completely unified system with no external dependencies. In a single codebase, two orders of magnitude smaller than Linux, you have an entire programming language and operating system. We realize how crazy this is — but it means that a single person can actually understand the entire system. Who is the last person you met that actually understands their entire computer? Urbit OS is like the [1968 Porsche 911](https://cdn.bringatrailer.com/wp-content/uploads/2007/05/1968_Porsche_911_SR_Factor_Race_Car_Engine_1.jpg) of operating systems.
21+
22+At the very bottom of the stack, Urbit OS is just a single, fixed function that we never change. Everything on top is upgradeable over the network. This means your Urbit OS can run forever without you ever having to do any maintenance. Put it on a USB stick, throw it in a drawer for ten years and forget about it. When you plug it in again, it’ll slowly upgrade itself automatically.
23+
24+Since Urbit OS is completely sealed, it’s all run-from-source. All the code to run the system is yours to modify, tinker with and extend. Build your own apps, modules and user experience. Or customize Urbit OS to control your tractor. Even better: collaborate with others on the network to build the experience you’re looking for. It’s entirely up to you.
25+
26+We build Urbit OS so we can finally have a dependable system, that we can commit to and keep far into the future. The modern web already looks dated to us.
content/understanding-urbit/technical-overview.md+31−1
@@ -1,4 +1,34 @@
1+++
1+++
2title = "Technical Overview"
2title = "Technical Overview"
3weight = 6
3weight = 6
4−+++
4++++
5+
6+Owning a computer, especially a server, can feel like a part time job. Urbit, on the other hand, is engineered to be maintenance free. We figure, if people are actually going to use a new computing platform, it can’t feel like work. At all.
7+
8+So we built our whole stack, starting with the VM, to be as simple and compact as possible. Let’s take a look at what the system looks like from a technical perspective and get a feel for how it’s built.
9+
10+Under the hood, Urbit is two parts: an ID system and an OS. The ID system is live and deployed to Ethereum. The OS is a program that runs on top of any Unix machine with an internet connection.
11+
12+Urbit ID is incredibly simple. An Urbit ID is just a pair of an ID and a public key. Some IDs have the ability to issue a finite number of other IDs. Galaxies, the top-tier of Urbit IDs, have the ability to upgrade the Urbit ID contracts by a majority vote. Each Urbit ID also has a cascade of keys that can perform specific actions which make securing your Urbit ID simple and straightforward. For example, the key for booting Urbit OS is separate from the key for issuing children — keep that one in a safe.
13+
14+All of this is implemented as a [suite of Solidity contracts](https://github.com/urbit/azimuth) that are [deployed to Ethereum](https://etherscan.io/address/azimuth.eth) that we call ‘Azimuth’. We’re not wedded to using Ethereum forever — but it works well for now. Someday we’d like to host Azimuth on Urbit itself.
15+
16+As a compliment to Urbit ID, we implemented the [Urbit HD wallet](https://github.com/urbit/urbit-wallet-generator) which lets most people own their Urbit IDs using a simple passkey that’s easy to remember. This means you own your Urbit ID and can log in to Urbit OS with something like `~ravmel-ropdyl`, `~poldec-tonteg-palfun-foslup`.
17+
18+Until Urbit OS is completely secure (in the next year or so, we hope), you can interact with Urbit ID through a standalone, browser-based interface called [Bridge](https://bridge.urbit.org). Bridge lets you securely manage your keys, transfer your Urbit ID, log in to Urbit OS and so on.
19+
20+In the simplest terms, Urbit OS is three things: a file, a key and a program. The file is a log of everything that has ever happened to your Urbit. The key is derived from the same key you own your Urbit ID with.
21+
22+The program is mostly Arvo — our name for the Urbit OS kernel. Arvo is implemented in Hoon, a functional language that compiles down to Nock, our tiny set of opcodes.
23+
24+Arvo’s behavior is completely defined by a transition function that goes from `[event, current-state]` to `[effects, next-state]`. An event might be a keypress, an HTTP request, or a UDP message from another Arvo. An effect might be a command to the Unix terminal, an HTTP response, a UDP message to another Arvo or a move to one of Arvo’s kernel modules or vanes.
25+
26+We currently have vanes for networking (`%ames`), timers (`%behn`), a filesystem (`%clay`), a terminal driver (`%dill`), an http server (`%eyre`), a functional build system (`%ford`), an application server (`%gall`) and a module for managing private keys (`%jael`).
27+
28+The operating system has a runtime called Vere that performs I/O for your OS. Think about it as the way your Urbit can interact with the outside world. It also handles your event log and runs Nock, our machine language.
29+
30+Nock is like a pico-Lisp with no symbols. It's a homoiconic purely functional machine code with 12 opcodes and one universal datatype, the noun: an acyclic binary tree that is either a number (which can also represent an arbitrarily large bytestream) or a cell, which is a pair of nouns.
31+
32+Hoon, the language in which the operating system is implemented is a purely functional, statically typed, strictly evaluated programming language that compiles to Nock. It’s a little quirky, but at its core it’s a macro extension of Nock.
33+
34+Perhaps most interesting: our whole stack (except for Nock and Vere) is designed to be updated over the air. This is what makes it possible for Urbit to be a computer for life — it can grow with you.