Urbit runs as a VM with a translation layer for things like networking, file system, etc. Using a host OS is expedient to build a working OS that the user actually wants to use, since hardware support is an uninteresting implementation detail. Eventually, one could write a native hardware kernel in Nock/Hoon, and do networking without TCP/IP/DNS between Urbit computers.
"Urbit OS is a completely new, carefully architected software stack: a VM, programming language, and kernel designed to run software for an individual. Urbit OS is a program that runs on almost any cloud server, most laptops and many phones: anything with Unix and an internet connection.
The main thing to understand about our ‘overlay OS’, as we call it, is that the foundation is a single, simple function. This function is the Urbit OS virtual machine. We call it ‘Nock’. The entire Urbit OS system compiles down to Nock, and Nock is just 33 lines of code.
Nock is similar in spirit to WASM or the JVM: it’s a uniform machine code for every Urbit ship. A frozen foundation makes for some nice features:
The state of your Urbit OS is a pure function of its event history. It’s auditable, inspectable, repeatable. You can actually trust it. Writing decentralized apps becomes vastly simpler than in the old world, since every node computes exactly the same way. The entire Urbit OS stack, from programming language to applications, is upgradeable over the network. For ordinary users, this makes for almost no system administration.
Since Nock is a protocol for computing itself, any two nodes on the Urbit network can easily share data, communicate and connect their software."
House is an OS in a very different sense than Urbit - the "boots on bare metal" sense. The core of House is a monad which represents the hardware state of a common Intel box.
Urbit is intended to run virtually in the cloud and is an OS only in the sense of "stores your data and runs arbitrary programs". As a cloud computer its "function" is simply (old state, packet in) -> (new state, packets out). For communicating with the host OS this generalizes to "event in" and "actions out." Eg, I got an HTTP connection so I send an HTTP response. So not only isn't it done, it isn't even very smart... but it is a function and it is an OS.
We want to get to native, but you don’t replace the hardware in a day. It doesn’t make sense to build a custom nock cpu until it’s necessary.
For a new system to succeed it has to run on the hardware people have. That’s why there’s a runtime. It is an OS, but there’s an interpreter for the machines of today. If urbit succeeds then running it directly would be the ultimate goal.
"Urbit OS is a completely new, carefully architected software stack: a VM, programming language, and kernel designed to run software for an individual."
Even solving an impossible problem shouldn't require all of that.
Surprised to see no mention of Urbit, which sits somewhere between Uxn and Linux. Holding Urbit's OS in your head would certainly be more challenging than Uxn, but it's still doable. When something breaks, you can actually fix it yourself (I have). That's a refreshing feeling.
Urbit is a program you can run on Linux or MacOS intended to provide a complete personal computing experience on its own. It runs as a virtual machine for now, although it could run as a unikernel on bare metal (good project for a contributor who's interested!).
This VM acts like an operating system, in the sense that it loads and runs other applications within itself, and in the sense that it presents an application switcher and overall system management tools to the user.
This VM is designed from scratch to be as simple as possible, based on the thesis that the reason everyone has thought of a personal server but nobody runs one is that it's too complicated to do your own sysadmin.
Why is it complicated to do your own sysadmin? Because Linux is 15 million lines of code, and then there are tons of layers on top of that. What percentage of programmers even know how the internet works? A fair number of programmers have a decent sense for some corner of the modern computing world, but even seasoned professionals don't usually know the full structure of the digital world. How does BGP interact with the IP protocol? How do you make sure fsync() actually did what you wanted it to do? How does Linux overcommit_memory work? etc.
Urbit is weird, but that's mostly because it's a parallel universe of computing, not because it's inherently crazier than the alternative. We all have Stockholm Syndrome about 'ls -alH', and don't tell me 'grep' is an intuitive name.
In fact, there are very few basic building blocks in Urbit: binary trees of integers, the idea of a persistent event-log-based computer, and cryptographic identities. Pretty much everything is constructed out of those components.
And it's designed for a modern world with billions of users who might not all be completely trustworthy, so whole categories of complexity go away -- such as NATs.
So there's no standard industry term for describing this system, because there are no direct analogs or competitors.
It’s a personal server OS. MS-DOS was emulated on mainframes before it was run directly on hardware. Urbit wants to do the same, starting by being emulated on traditional computer OSes, and eventually moving to bare metal.
> Each user runs their own node completely independently. Everyone using Urbit OS owns their own identity and data. ... over an encrypted and authenticated network.
Interesting note about OS 1 in particular:
> One really critical thing about OS 1 is the pattern of ‘groups sharing modules’. This pattern makes it perfectly clear how a virtual computer can outcompete a bunch of different services. ... quickly outruns the messy, disconnected world we’re currently stuck in.
A server could use either service for storage (and sharing). You can't run Urbit's operating system on top of either, the part that executes code is missing.
> Blatant plug: Urbit (urbit.org) is a general-purpose OS built on the event-sourced model.
I've looked through its documentation, and while I couldn't make heads or
tails of it, Urbit seems to be everything but an operating system. Espeically that
it needs unix system to run.
Urbit “planet” is like a VM, but running an OS developed completely independently from existing computing words. There is a custom language, a custom network layer, a custom cryptography and custom identity system. There are even custom words for common terms. This has no GUI, but it does has a web interface that you can connect to.
From the practical standpoint, you have a linux process running from a data directory. You run it, and the you can access it via CLI and via web interface (which also has a terminal-like webapp). It then uses regular IP to talk to other urbits in P2P fashion.
From what I could find, the whole thing is full of magic and pretty opaque - you are only supposed to interact with it by running it and typing commands there. In particular, you’d probably want to back it up. The only instructions I could find is to stop it and tar it up, and back up manually. Better do it often if you want your “digital life” to be safe.
Please identify one concrete computing action that I cannot do with Linux/Windows/Mac that Urbit enables.
In other words, what is Urbit's "Killer Feature"? Cause I'm not seeing one.
And a runner up question: Is Urbit still heavily dependent on unreleased root node code? In other words, is this distributed computing just a load of hype covering over a overly complicated star topology?
"An Urbit" is a tiny VM with its own network protocol. It allows you to run apps written for it which can communicate over the Urbit network (By far the most used one is an instant messaging app).
Every Urbit has a permanent address which persists even if you move it around between computers. Each Urbit fully encapsulates its own state, so it can be zipped into a single file, unzipped 20 years later on a different computer, and it'll still work, still be able to connect to the network, and still contain all the data you had.
Urbit apps are fully decentralized, users own all the data and control what and how they wish to share it via the Urbit network.
As it contains a high-level Turing-complete programming language named Hoon, it could be used for anything which regular computers are used for.
There are actually some very interesting ideas in Urbit. Unfortunately it's all hidden below many layers of obfuscation and weird naming.
yes. I've read some of low-level technical VAX/VMS and Solaris articles, and they were mostly comprehensible. Connection Machine stuff is impractical but _fascinating_ (despite being much farther from Linux than Urbit ever was)
Urbit is really an outlier, with jargon/innovation fraction far exceeding anything else I have seen.
For the vast majority of users the OS is just a way to get to the web.
The web (browser) is the OS, but the apps are centralized, incompatible, and primarily SaaS subscriptions (or worse, ad based). Desktop operating systems are primarily thin clients to these services. Native apps on the existing stack are dead outside of a few niche applications. It's why I think Urbit is cool, if you built an OS from first principles to take into account the web what would it look like? It's basically moving the API layer up the stack to include auth and application distribution.
In summary: Urbit is a functional/deterministic VM. That's mostly it. It runs a bytecode called Nock. The only language that really compiles to Nock is a weird language called Hoon. Because the VM is functional and deterministic, it is (in theory) also portable – you pick up the (ever-evolving) VM image and move it somewhere else, and it should act the same. Since the VM may move around there's also an identity/networking layer so you can talk to the VM wherever it is.
Right now Urbit is a program called u3 (runs on Linux or whatever) that runs Nock programs. OS 1 is such a program that does a couple things. It's unclear to me if they've really built an OS or just a library of routines that can be used to build a single multipurpose application.
"Just running your own server" is the proper meaning of "decentralized" [0].
Urbit has a literal operating system named Arvo built on top of a virtual machine named Nock. The terms are used technically; it's not trying to compete with Windows.
reply