Epicenter - Learn about Crypto, Blockchain, Ethereum, Bitcoin and Distributed Technologies - Josh Lehman: Urbit – The Peer-to-Peer Network Re-Decentralizing the Internet

Episode Date: June 29, 2022

Urbit is an exciting new operating system and peer-to-peer network that’s simple by design, built to last forever, and 100% owned by its users. Under the hood it's a from-scratch software stack compact enough that individual developers can understand and control it completely. Urbit deconstructs the client-server model in favor of a federated network of personal servers with built-in, cryptographically-owned identity, each of which is capable of distributing and running their own applications that communicate over the Urbit network. We were joined by the Executive Director of the Urbit Foundation, Josh Lehman, who explained in depth how the Urbit ecosystem was built and now runs, the advantages of the network from user and developer perspectives, the bridge with crypto, and how the roadmap for the kernel is looking going forward.Topics covered in this episode:Josh's background and how he became involved with UrbitAn overview of Urbit and the current state of the systemWhat’s changed about Urbit over the last three yearsUrbit's address space consisting of galaxies, stars and planetsWhat Urbit applications are and how they differ from iphone applications or a dAppsThe advantages of the Urbit user and developer experiencesThe connection between Urbit and cryptoThe projects currently being built on Urbit - Holium, Uqbar, TirrelWhat the roadmap for the underlying Urbit kernel looks likeHow you can get involvedEpisode links: Episode 205 - A Digital Republic Reinventing the InternetUrbitUrbit GrantsUrbit on TwitterJosh on TwitterSponsors: Steakwallet: Steakwallet is your new favorite multi-chain, mobile wallet. Tired of having a different wallet for every chain? Get Steakwallet today and get the power of Web 3 across all chains right at your fingertips: https://steakwallet.fi/ - Gnosis Safe: Gnosis Safe is a smart wallet for securely managing digital assets and allows you to define customized access permissions. - https://epicenter.rocks/gnosissafeTally Ho: Tally Ho is a new wallet for Web3 and DeFi that sees the wallet as a public good. Think of it like a community-owned alternative to MetaMask. - https://epicenter.rocks/tallycashThis episode is hosted by Brian Fabian Crain. Show notes and listening options: epicenter.tv/450

This is Episenter, episode 450 with guest Josh Lehman. Welcome to Episandah, the show which talks about the technologies, projects, and people driving decentralization and the global blockchain revolution. I'm Brian Crane, and today I'm speaking with Josh Lehman. He's the executive director of the Erbitt Foundation. And we're going to talk a lot about, you know, what is Erbitt and what it all means. But just before that, a brief word from our sponsor. So first of all, we have Stake Wallet. stake wallet is your new favorite multi-chain mobile wallet that puts the power of rep three at your fingertips so with just a few taps you can easily stake and manage your assets on over 22 different protocols including major ebms l2s and chains like cosmo salon on near and more they're also recently integrated bnb and harmony one staking and support for nfts so yeah just check it out they're also

So yeah, adding lots of especially NFT support. So go and download StakeWallet today on iOS and Android. Or go to stakewollet.f, and that's stake, spell like the meat. And then also Gnosis Safe. So Gnosis Safe is, you know, the leading security standard for Web3 asset management, reimagining the future of ownership and value coordination. It works basically as a multi-sick-based smart contract account. It's compatible across EVM chains.

It's totally programmable to give you the power to customize permissions and access, set user limits and ensure the stealth security while doing so. It secures over $60 billion in self-custody, maybe slightly lower at the moment, not sure, but a huge amount and caters to DAO's institutions but also individuals. It's available on Ethereum, Polygon, Optimism, BAC, Avalanche, lots of different chains. So go to Gnosis dash, save to IOT to check it out. And third of all, again, wallet, Tally Ho. So Tally Ho is rethinking the wallet kind of like a public goods.

So it's like a community-owned alternative to MetaMask. They also focus a lot on like Metaverse and having, and the first wallet that's kind of like structured, organized as a doll. And their, you know, their commitment to community ownership goes beyond just the wallet. So they're also sponsoring ether.j.S. as an open source JavaScript library and they also pledge to commit 2.5% of their token supply to a Gitcoin aqueduct.

So head over to tallyho.cash. So that's t-a-l-l-l-Y-H-O-Cash to try it out. And with that, let's get into the episode. Josh, thanks so much for joining me. It's great to have you here. Yeah, thanks so much for having me. It is great to be here. Yeah, so maybe a little bit

of context here. So we're going to speak about orbit today and kind of the theme of this episode is sort of building on orbit. Now, we have actually done an urban episode before in this podcast a long time ago. It was five years ago where Meher and I interviewed Galen, who is the CEO of Clon, which has been the main company building Erbit. So go check out that episode. It's actually still pretty current. I, you know, we listened to it recently and is kind of, it's all still, you know, it's all pretty, pretty accurate, you know, because Erbit has actually been sort of conceived a long time ago. And so a lot of the fundamental architectures is unchanged and they're just slowly moving along. It has not pivoted.

Yeah, it's not pivoted. Exactly. Not pivoted. And so I have become, I mean, I've been interested, I guess, in Erbit since then, so for about five years. but then more recently become much more interested because I just felt like it went from this abstract thing because something, okay, there's actual activity, progress, felt like it was going somewhere and going to someplace, that's exciting.

And then Josh here, yeah, so Josh is at the Urban Foundation, but maybe we can just hand it with you at this point. Tell us a little bit about yourself, you know, who are you? How did you get involved in this Erbit thing? Yeah, so I'm Josh. I head up the Erbett Foundation, which is a new entity as of this year. Unlike a lot of projects in the space, Erbitt started first with a for-profit company that worked on the project for a long time and spun off the foundation much later after

kind of a long incubation period and a good amount of watching the space to figure out how to best do a foundation and what it should do. My background's in software development. I did a series of startups in San Francisco Bay Area. They all eventually didn't make it, but they took progressively longer to not make it. Learned a lot from doing that, built a lot of technology myself as a solo founder, always at first and eventually with a team. And I spent a lot of time just kind of in the trenches of classic web tube. programming, building technology.

I started, my involvement with Erbit started as just an enthusiast. I heard about it on Hacker News, which is how a lot of people heard about a lot of things back in the day. Maybe they still do. And whatever it was, I had no clue, but it was certainly really interesting in someone that spent a lot of time naming things. And it seemed like a, you know, it was serious in a different way than a lot of things were that I was familiar with, but I didn't quite get it.

And it took a few years, I think, until about late 2016, early 2017 to when I finally really understood the project because they put some time into explaining it in this like 10 minute long video, interview with Galen and Curtis. And I started going to meetups because they had these in the Bay Area. And I became absolutely fascinated with it because it was stupidly ambitious. You know, I was always into functional programming, had been since college. And I built most of the technology I worked on in closure because I had a hard time rocking Haskell. Closure made a lot of sense to me.

And I always, you know, I loved functional programming, but I was not really, you know, like the thing that blew my mind about Erbit was that it was actually a functional computer, an entire stack built around those ideas. And so what first drew me to it was that. It was as a technologist, as a programming language and a stack. But this was in 2017 at a time when Erbit was barely usable. You know, it existed. It had existed since 2013 as a, you know, real piece of software you could run.

But not for anything useful, really. And so I stayed involved with the project talking to the various people that were working on it that I met at these meetups like Galen and Ted over the course of, I guess, until 2020. So about three years as I was, working on this other startup. And in 2020, I got really into it again and decided to plunge a little bit more fully into the ecosystem as I, you know, found myself increasingly impressed by what

these guys had built that they'd taken this crazy idea to reinvent all of computing. You know, who would do that? And they actually did it and started building real products on it. And it was at that point that, you know, the stars aligned for me and I got to make the plunge into working on it full time. Cool. I think you sort of like touched on, you know, you mentioned like a few things before. You mentioned like functional computer, reinvent computing. But like most people listening to this podcast, they will not have heard of it at all probably

or maybe they heard like. They heard about it and were very confused by it. That's a very common one. Yeah. Maybe there's some of the people who have heard about it and confused. most many people will not have heard about it at all. So yeah, can you explain what is Erbit and what is the vision of Erbit? What is it trying to accomplish?

Yeah, to start and maybe relevant for this crowd, Urban is not a blockchain. It makes use of a blockchain, which it did as of 2019. But that's, you know, probably not the most fundamental component of it. What Erbit is, is. is the recreation of personal computing, sort of as imagined at the turn of the 90s, when the internet was becoming a thing. And there was this dream that people would be running

all of their own software on servers and connecting peer to peer with one another. That was the mentality of the early pioneers of the internet. And obviously it morphed into something very different. The fundamental idea behind Erbit, I think, is that computing is too complicated. The stack that we build on is inherited from the 70s and before, Unix and Linux, which, well, you know, Unix being kind of the main philosophy powering Linux, which powers pretty much the entire internet, which is, in my opinion, the most useful, interesting,

application of computers, which is communication between people, that is all based on technology that predates networks themselves. And so ever since then, we've been bolting on additional layers of software further and further up the stack as we discover the things that we really want to use computers for. And as a developer in the 20 teens, what you find is that building the kinds of applications that we all want to build is insanely. complicated and it's full of what you'd call incidental complexity. The things that are not related to the problem you're trying to solve, but are to satisfy the constraints of the computing

environment that you're in. So you need to build authentication. You need to deal with databases. You need to deal with security and a bunch more. The fundamental idea, you know, returning to urban is if you could redesign computing to be, you know, from the present, looking back in time and going, this is actually what we want to use computers for is communication with other human beings. If we were to build a computer today around the things that we know we want to use computers for, could you build something that was simple enough to where everyone could actually run their own technology without, you know, descending into a horrible web of complexity that ultimately leads people to delegate that to trusted third parties that can do it for them.

And if you can do that, you end up with very different software. You end up with things that are not services but tools. This is a thing that has held up very well about Galen's whole line of reasoning is that software should feel like a tool. It should feel like a thing that you buy or create and then you use forever. And maybe you tweak it here and there over time. But ultimately, it's a thing that you own and it's a thing that stands the test of time. You know, there's a idea to make, you know, as close to eternal software as we possibly can, things that are inherently good and, you know, without an underlying motive to become Google and to own every aspect of, you know, the people that use the system. So yeah, that's really what it's aspiring to be is a system in which a group of people, ideally everybody, runs their own infrastructure and runs the tools that they need to communicate with the people they need to communicate with.

And they are very much using a proper bicycle for the mind, something that isn't trying to harvest their attention for various forms of profits. and not that I'm against profit, but the kinds of things that are harmful to the end user, often in ways that their creators don't anticipate. Now, that's kind of a philosophical pitch. What this thing actually is, it's a new computing stack. It's like you go back to the 1970s, you start over from scratch with what a computer should be,

from assembly language on up to a higher level language, on up to an operating system that uses those stacks. that's you know like I mentioned earlier that's an absurd thing to imagine doing these days nobody goes and says let me just you know start over at assembly language and build a new computing environment because that's just a huge challenge well that's what her bit set out to do and that they actually did and that you can now run software on top of yeah i think that is one of the things that's sort of actually particularly striking about the orbit thing which kind of makes sense if you understand like the scale of the ambition is also sort of the history of the project and just like

how long, uh, this has been going. Yeah, it's like 20 years. Yeah. Can you talk a little bit about sort of what, yeah, what is the history of where it been? So I can, I can talk about it imperfectly because I wasn't there in the early days. Uh, but, you know, I've, I've had a lot of the lore passed down from me through to me through being around all these people. But, um, as legend would have it. The project started in about 2002 as the personal project of a guy named Curtis Yarvin. Much has been said about him. I'm not going to say too much. He worked on this as a personal project and as an idea from about, you know, something that there aren't any public records of until around, you know, screw up the year. I think it was 2010 or 11. There was a Moron Lab. It was a site he ran

blog post that introduced the concept of orbit. And the dark, you know, the, those early period when it was kind of an idea in his mind to when it became public, was, you know, seven or eight years at about the time that you imagine Bitcoin was being created. I don't really know exactly how long that was being worked on, but probably over a similar stretch. It was, you know, announced to the world at about the same time.

And it existed as a, you know, complete. although, you know, not very good working system in 2012, 2013, somewhere in there. And that's when Curtis took that idea and said, you know, I need to, in order to actually build this thing, I'm going to need to recruit a team and I'm going to need to raise some money. And he went out and founded a company called Tlawn with Galen, who became his co-founder shortly thereafter. And the two of them worked on Tlawn from now, from then until the present. And Tlaan, you know, the idea was that, you know, there's kind of two models that Eric S. Raymond outlined in like an early 90s paper called the Cathedral and the Bazaar, where there's

these two models for building software. You have the cathedral, which is the top-down hierarchical. There is a singular point with a vision and everything stems. from that and defines software system by design. And then you have the Bazaar, which is sort of the Linux model of open source, where you have a group of people who build something collectively on merit. And you end up with very different kinds of architectures. You know, the cathedral is very much, you know, rigid and hierarchical and highly specific.

And the bazaar is sort of organic and amorphous and, you know, full of all kinds of different outgrowths. And both are very good. both can be not good also they're just two two models and the idea with erbit was you know for this system to come to exist it has to start as a cathedral it's very much a you know it has a singular vision and a take on the world that has to be defined and done in a setting that gives the creators more or less complete control over that vision until which point that the that vision is sufficiently solidified and communicable to a wider audience.

The principles of the system are defined. And at that point, morphing into a bizarre model is a good thing. So Tuan was that cathedral that would, you know, sort of give birth to the project. And over that period of time, you know, Urban gained something of a reputation as being sort of hostile to open source. That's why they were really not trying to harness open source until a point at which the system was solid enough. That time started happening in about 2020, maybe a little bit before, which is about when I showed up. And that was when Thon was beginning to realize this is the time to begin figuring out how to transition this from being our project and our vision to something that is more widely happening. held by a community and eventually an ecosystem.

Over a lot of that time, the technical, you know, the work that had to happen was that Erbit had to go from something that was an MVP to something that, you know, really embodied its own principles. And at a bare minimum, it needed to work, you know, like it needed to be a thing that, you know, you didn't have to do what we call a network breach on every couple of months, which used happen. That's where you basically reset the entire main net to zero and everyone must start over from scratch with all of their data blown out. It's like a test net that you can just blow out. And that was the state of things. And it was resetting every few months, which made it very hard to actually

use it for anything real. And it was horribly inefficient. And the design of the veins, the parts of the kernel was not really fleshed out. So there was a lot of churn of the code base, which made it very hard to accept open source contributions, even though the code was open source, because you often have sweeping design decisions being made that blow out an entire way of doing things that aren't really communicated to anyone. That's, you know, we're now at this point where that's all changing.

Yeah, no, I think this is a good description. I think a good description of both the history a bit. and sort of where it's at. Yeah, I do think, I mean, yeah, who knows what Satoshi did, right? In like how long he was working on this thing until like it kind of came out. But definitely, yeah, you can imagine something like that, right? Probably like, I think it's a sort of a fascinating thing, right? After some person spent like eight years or just like in a solitary pondering of this crazy idea.

Yeah, just in a rapture with an idea. you know and yeah that's it's a long period of time to be working on a thing alone what is like you mentioned a bunch of stuff right you mentioned sort of the you know the release of this initial orbit system in you know 2012 and then getting to the point where okay it is more it's more something that's like okay solid right and it's going to be kind of like this but can you talk a little bit more about, you know, where's orbit today? Like, what has, what's the current state of, you know, of the system? Yeah, totally. And let me, let me start that by kind of speed running some of the major things that I've been present for over the last couple of years that, maybe last three,

that started to make it really solid and get us to where we are today. And I think one of those big ones, which was about a year before I came on to really devoting my energy to the project, was in 2019 when they went on chain. Prior to that, Erbitt's address space model was stored in a text file in a GitHub repo. There was always this idea that, okay, there needs to be people that cryptographically own parts of the urban address space, but we don't have a system for that. Actually, I think that's maybe something that's worth explaining. What is urban address space? Yeah, so, you know, urban address space is the, it's the network topology.

We have names for these. A running urban node is called a ship, and there are multiple classes of ship. The ones that are important to really talk about for this conversation are galaxies, stars, and planets. galaxies you can think of kind of like root DNS nodes. They are able to spawn stars, which are other infrastructure nodes. They perform peer discovery and packet routing, because this is sort of one of the problems you have with a peer-to-peer network is ultimately you need to be able to establish connection with people throughout the world.

You tend to need certain nodes that are privileged to, and you, you can, you tend to need certain nodes that are privileged to, and usually have better infrastructure capabilities to route your request to somebody else so that you can form a peer-to-peer connection. And that's the main role of, one of the main roles, at least, of the infrastructure nodes in nervous. You have this hierarchical address space,

which is there to enable a peer-to-peer network to actually operate efficiently. So the galaxies, there's a limited number of those, just as there are root DNS nodes. They tend to be fairly valuable because there aren't very many of them. They also form what's called the Galactic Senate, which is the group of people that have the ability to upgrade the rules

that define urban address space. So this was all dreamed up long before Ethereum and Daoos existed, but you can think of the galaxies as kind of a Tao. And that's kind of how they operate today. they vote to upgrade a set of smart contracts that run on Ethereum. And that's what governs the rules of the address space. And so you have these galaxies, 255 of them, each of which can spawn 255 stars. And each star can spawn roughly 65,000 planets.

So 2 to 32. They're 16. Planets are what an individual urban user would use. They are valuable enough to where you would actually want to establish a track record of using one and use it day to day, but they are not so valuable that you have to go through annoying Opsack hoops in order to keep a valuable piece of cryptographic assets safe. And so each of these are NFTs. They all correspond to a number from zero through $4.3 billion, $2 to $32. and they comprise the urban network when running. They largely operate the same with these slight differences

in that stars and galaxies perform packet routing and peer discovery. And they also, one thing I left out is the galaxies perform software distribution. So a galaxy disseminates its software to all of its stars, which then disseminate that to all of their planets. And so you can imagine a fully fledged urban network being a thing. in which the different galaxies start to diverge in which code they actually supply to their section of the network. That hasn't happened.

It's, it could, though. Yeah, yeah, totally. And then basically, right, so you have, you have this, like, scarcity of this outer space. And then in 2019, right, you mentioned basically, it was, like, put on Ethereum. And today it lives on Ethereum, right? So like if... Yep, correct.

Smart contracts turned out to be the right substrate to build this kind of model, you know, rather than trying to invent that ourselves. It's like, oh, yeah, use Ethereum. That works. Yeah, and scarcity, it's worth noting, you know, a thing about scarcity and that it provides an important function because each of these, you know, the urban address space, each one of these NFTs is what's called an urban ID. And it has a human pronounceable and visual

representation that's recognizable. My planet is called Woolref Podlex. You can, you know, it sounds weird, but eventually you get used to it and because you can pronounce it, it becomes a name of sorts. And that's what you use when you run any software on the urban network to communicate with other people. You know, it's like your domain name and IP address rolled into one and persistent, or like your ENS name, you know, is maybe a good way to think about it for this crowd. But it's built into the operating system and every application uses it at a packet level to send packets signed by that identity throughout the network. So this becomes like a primitive identification mechanism for every actor on any piece of software that you build on

the urban operating system. And that's really like the key important thing to get from urban address space is that there's a finite number of those and their scarcity is what makes them valuable and makes it so that orbit creates high trust communities because your reputation is valuable. You had to pay something to obtain that NFT and communicate with people. And if you do anything malicious, it will destroy the value of that in other people's eyes and, you know, ultimately not work out very well for you. So you mentioned, I think, this, you know, big event or this big change that kind of came

with Erbit which was distribution of software, right? So, you know, basically people can write applications, sort of like urban applications. But can explain, like, what are urban applications and how do they differ from, let's say, an application that, let's say, an iPhone application or maybe adapt, like, let's say, an Ethereum decentralized application. So what are the differences? Yeah, that's a great question. So an urban application is server side primarily.

It can, of course, have any number of interfaces. You can interface with an urban application over an iPhone app or over a command line, over a web interface. But the urban part of it is something that runs server side. But the key thing is that it's. your server. And so, you know, when you run an urban application, you're running it on your own node. And so that is your own personal cloud server. It is, you know, an urban application is, you know, the technical name for it would be what's called a desk, which is like a, a package of code. The main unit of code in there is what's called an agent. And this is like a long running

process. You can think about it like a, you know, kind of like a web server or some service that would run on, say, Linux. We call them agents. And they have a specific interface for accepting information, allowing you to read information out of them, and subscribe to certain paths that will produce updates over time. So I think the key things about an urban application is, that are important to get are, you know, any application you build, like I was mentioning before, has authentication and authorization baked into it. Every packet that you send is bound to an identity. So you're not building authentication systems into an urban application. Every application has the ability to talk to any other application, whether that's running on ship or any other person's urban node or ship. Same thing. That, you know,

Erbit defines this peer to peer network that allows these applications to talk to one another and all the information exchanged over that network is typed. This is kind of, this is kind of cool. You don't need to go and read developer documentation for, you know, what someone's JSON API is and then program against it and get everything just right because either you can send information or you can't because it satisfies the type system or not. So the whole network in peer-to-peer, the whole peer-to-peer network is statically tight. And so when you build an urban application that can talk to any other person's application,

you can also distribute that peer-to-peer. So if I build something, anyone else can get it directly from me. So every urban node is its own app store, or at least can be, where those are things that you build rather than submitting them to, say, Apple's app store with an iOS app or the Chrome Web Store for a web extension or some third parties, you know, gated, moderated, you know, distribution mechanism. The application are distributed peer-to-peer themselves, and that means that every person running an urban application is running a full version of it. Urban is also an acid database, meaning all of the in, you know, the, you know, the

the data that an application needs to run is stored on that ship with transactional semantics. So I don't need databases either. So ultimately an Erbit app is like a, it's a server site application that you do not have to build authentication into. You do not need to deploy a database too because Erbit already is one and a peer-to-peer network with static typing. All of that baked in. So what do these tend to look like in practice? well, Erbit can also serve web pages. So you can serve your own website that talks to any, you know, a number of agents packaged

into a desk, Erbit application. And so you have a web interface for talking to your own private server. And that can also talk to other people. So there's all kinds of applications you can build with this, anything social, the current, you know, kind of predominant use case is a Discord-like groups application

where you can form groups of people and you can create chat channels, notebooks, link collections, share information with people. There's a variety of other things that have been built as well. And I think the thing that Urban particularly excels at is any kind of application that networks with other people.

How this differs from ADAP is that you have off-chain state you know, this is one of the big problems of DAPs is that, you know, if you, if you need to do anything other than display information on a blockchain, you have two options. You store that information in local storage or you store it in some other centralized service. And both of those are a problem. You can also store it on a blockchain, but then you have to pay a bunch of money to store it. And there's all kinds of data that you really just don't want to have to put on the blockchain because it's just not important enough.

And it's only yours. You know, it's your private settings or configuration. NOSIS safe is a great example of this where, you know, all the metadata associated with your safes is stored in local storage. So if you ever want to use a different browser, then, well, you kind of have to re-upload your safes and at least the information that identifies them as what they are. And when you sign a transaction, you're relying on a service that NOSS runs in order to shovel those partially signed transactions back and forth.

An urban application would send things directly to the other people that you are trying to talk to and would store all of your information, your annotations and metadata about information on a blockchain on itself, which is private and only yours and not shared with any third party. Cool. I think that's a nice example, right? So like, okay, let's say we, we, the two of us, together have agnosis safe, right? So basically like a multi-sig, we control on Ethereum. And that could be built inside orbit, right? So then it would mean now the two of us want to, I mean, first of all, I guess, right,

would be what you mentioned, right? Okay, so we can have each of some local state that describes maybe labels the transactions or something like that. And that's just in our personal server. And then if you want to make a transaction, you know, I'm like initiating your transaction, it gets sent to you via the urban PEPP network. You know, you can sign the other side and then like broadcast it. And then it's life, right?

Which is doesn't work like that today in Ethereum, right? Because I guess today in Ethereum, people access this via, you know, like the web browser. And, you know, then it's maybe in this local cache, I guess, like what you said. Yeah, they need a way, you know, a NOSSAF, if you and I have a multi-sig, when I sign a transaction, all I'm doing is, you know, I'm not putting anything on the chain yet. I'm creating, I don't know which cryptography they use exactly. This is beyond my pay grade, but what they're doing is creating a part, essentially a partial transaction that's awaiting one more on the multi-sig,

and that's information that you need to sign in order to submit it to chain. but I have to get that to you somehow. And the way I get that to you, if you're using NOSASAFE, is through a service that NOSIS runs that indexes all of the multi-sig addresses along with their recipients. So it knows that when my address signs this transaction, it looks up the other addresses that are on that multi-sig and says, okay, I need to actually provide this information. to the other people that are accessing the NOSIS safe client through those addresses.

So the network routing is through NOSIS. And if that service goes down, then you can't use NOSSA safe anymore. It is not actually a decentralized application. Yeah, yeah. So maybe you can go a little bit more into, like, so, okay, we have to be NOSA as an example, right? I think it's a nice example. But like for most people, they're like, okay, but why do you like care?

Like, why would I want to use like an NERBID application? Like, what's the great benefit for the sort of normal user of, you know, web applications, somebody over the internet today? So I'll come at that a couple of different ways. Like, yeah, a lot of normal users don't really care that they own their information. They just want the thing to work, right? Some people do care that they actually own their information. And a lot of people that do care of noticed that when you own your information and you own the tools you're using, it changes your behavior on the network. When you know that you're using a network in which every person participating is responsible for being there themselves, running their own infrastructure and communicating with one another, it sort of changes the social dynamics.

You know, everyone has kind of like a shared sense of responsibility for keeping whatever that community or application is running because you're all participants on equal footing rather than using something provided by someone else. That's something you kind of have to feel in order to understand. I think this is fairly well-fleshed out with the groups model where, you know, people that participate in urban groups, you know, like the group only really goes down if the people stop using it. You know, the urban network doesn't go down unless everyone decides to actually stop using it. And so the software, like that characteristic of the software, coupled with the fact that developing urban applications is extraordinarily simple compared to building any other piece of infrastructure. And I can talk about why that is in a minute. We probably should.

it brings the accessibility of building applications for you and your community down to a level where people can normally do it. And so, you know, where my mind goes is like, okay, Dow's are a big thing. And Dow is sort of a placeholder for online community that undertakes something with one another, you know, usually with some expenditure of capital or effort, really. for lack of a better word, we'll call that a Dow, but there's a lot of those that don't follow the traditional Dow semantics. Urban applications bring developing software as a small group that is used by that group within reach to just about any of these groups. Like it's actually not, you know, give it a couple years maybe from now to there, but this is where we're going is it's actually fairly trivial for us to build our own chat application

that is tailored to our community exactly as we want it. And it will never change or go down until we actually change it or decide to take it down or collectively stop using it. You know, we can actually build and own our own tools as communities. And so it's much more of like a Cambrian explosion of different kinds of software that are used by the people that create them rather than a monoculture of everybody in the world is on Twitter or using WhatsApp. There are pros and cons to both of those things. And I don't necessarily think that Erbit is a new internet. I think it's an alternative one that works differently. And you're probably going to see these things, you know, operating alongside one another for a long time.

You know, it's nice to have a global town square if you, you know, want to go and troll some people or, you know, get your blood boiling. But it's also nice to, you know, have a place to talk with. your family that is always the same and never changes. And it's just the thing that you're used to. You spoke, you mentioned a little bit sort of the aspect of, okay, it's like easier to like build an application. Can you talk a bit more about, you know, to develop a perspective? Like, you know, what are the advantages from the perspective of somebody, you know, wanting to build an application? Yeah. And I think this is sort of the big, like this is the biggest selling point in my mind. what originally drew me to the project, which is, and I think that, you know, when you

nail this, everything else kind of stems from this because people build, you know, they build a good software. So, you know, if you want to build a web application today, like one of the first questions, you, like, there's a whole bunch of things you have to build, regardless of what it is you're building, there's a bunch of things you have to figure out. How are you going to authenticate your users? How are you going to store their information? Because You need to store their information if you're going to authenticate them, at least some of it. How do you keep that secure? How do you deploy your software and keep it running?

And embedded within those kinds of decisions, there's a whole bunch of other ones. Okay, well, which authentication mechanism do I use? Do I use Oath? Do I use some third-party service, some SaaS service like OTH Zero that I pay for? Do I use Metamask and go full Web3? You know, that's a growing valid option. Do I, you know, what database do I use? Am I using no SQL, SQL, and the many options within those?

How do I keep this information secure? Which you do have to keep secure if you're storing information for other people. And this is still your option. If you want to build any kind of social networked application, you're going to have to build it in some way, where someone is responsible for maintaining the infrastructure that stores user data and relays information back and forth to people, even if it's NOSA safe and those are just signatures.

You have to answer all those questions. and a bunch more, right? It doesn't really stop there. But, you know, I'll focus on some of those, some of the big ones. And you end up with this problem where, okay, well, because someone has to run this thing and they have to answer all those questions and they have to build all this, they got to get paid to do it. They have to be responsible for everybody else's data, which makes the application more complicated because, you know, they're not storing their information. They're storing their information. They're storing. things on behalf of everybody and dealing with the networking involved with sending, you know, with scaling that to whatever level of scale it needs to. On orbit, you don't have to deal with authentication because it's built in. Everyone has one identity. It's built into the operating system. It's something you can just totally take for granted and assume that every piece of

information that comes into your system from the outside world comes annotated with who it came from. And you just know that out of the box. And they must be authenticated and must be the person they say they are to have sent that packet. You don't have to deal with a database because Erbit is already a database. And that's feasible because every person running Erbit is running their own database and is storing all of their own information. So you're no longer responsible for storing anything for anybody else. You're no longer responsible for having to build an infrastructure that can handle load

for a large number of people. It's only your own load. So that's a, you know, for most applications, it's a fairly small number unless you're like, you know, Kanye on Twitter and you have a lot of followers. That's a different class of problem. But for most people, you know, your own traffic and your own information is not,

you know, doesn't really require anything too fancy. So you don't have to deal with databases and you don't have to deal with security that's built in. You don't have to worry about a data breach of your users because you don't have users. You only have you. You don't really have to worry about DevOps or deployment because actually, like, installing an urban application just means putting some files in a place after you run a specific command line to create a package for these, which you can then publish and make available to anyone else if you give them a simple text mnemonic that they can plug in to install your application. So you have a built-in distribution mechanism directly to the people that are going to use your software.

Updating that software is as simple as just changing the code and then it immediately pushes that out to everyone using it. Unless, of course, it was broken, in which case the type system wouldn't let you change it in the first place. You have built-in data, identity, all of these things. These are just not things you have to worry about anymore. All you actually do is focus on building the application that you need. And you can take networking, data storage, security, identity. You can take all that for granted, not to mention DevOps. So when you make it that simple, developers actually get to spend more time building things that are novel

and less time solving the same old problems over and over and over again that come with embedded responsibility on behalf of other people, which creates weird social dynamics. You know, if I'm a Dow and one guy is responsible for maintaining all of our infrastructure, then he's got, you know, a certain amount of power and responsibility and obligation that means that, you know, we're all indebted to him in a way. In this model, you don't have that. We're all peers. Yeah, yeah.

I think that is also one of the things that to me is very interesting about Erbit is the kind of different business models that will come with that, right? Because in the existing world, right, in the sort of Web2 cloud world, right? Like the reality then means that mostly, okay, you're developing an application, you're going to have to run a bunch of servers, right? You have to maintain all this data, do all the security, do all these different things. You must be sass. Yeah. So it's kind of this natural model that then you say, okay, I'm going to charge people, you know, uh, whatever, $10 a month, right, for this. And I have to,

you know, I have all these costs that come with every user. So I, you know, I have to cover those and more and then have to like cover the software to them costs. But then in the urban world, you don't have most of those costs, right? So you could do something very different. I mean, for one, the kind of obvious model of, oh, I'm developing a bunch of software. And I'm going to just sell you the software, right? You can just buy it and then you can use it.

Yeah, it's a return to the days in which you buy a box with a CD in it, and know at your local Costco and or wherever sell software and you install it in that's your. Yeah. Maybe we can talk a bit more about sort of the intersection between crypto and orbit, right? So we talked about the other space, right, so that that's on Ethereum. It also mentioned the example of technosis safe and like how one could basically, for example, integrate that in something like orbit and it would be quite nice.

But what do you see as the, like, you know, what are the synergies? or like how do how does the crypto blockchain world come together with orbit more generally? There's a lot left to explore in the general space of where do you put your off-chain state and where do you run your applications? You know, there's also the idea of, you know, every user can host their own applications. So you, you know, you don't end up being like it's a lot harder to come after Uniswap. if uniswap isn't providing uniswap on uniswop.com for everybody, if it's actually a collective people that are all running it on their own servers,

trivially. So one is just distribution of infrastructure to everyone trivially because it's actually feasible to, you know, run a webpage very simply for only you on pretty much any computer. You know, I think another part is just making, like, at a certain level when you can better normalize that idea of like we actually have a model that aligns with our values of keeping our information private as we transact with one another in this trustless way, you end up with much richer applications.

I can build a lot more social capabilities in that. into things that are directly connected to a blockchain than I can otherwise because I have a layer that lets me talk directly to people. Not only is Erbit off-chain state, but it's also compute. Your orbit is a running server. It is always on. It can do things on your behalf. We've talked a number of times, although we're not quite sure how to do this because we're kind of looking for the right group to come along that knows this space, but algorithmic trading on your behalf with your own programmed algorithms operating on your own crypto, which are stored on your server, at least some degree of keys can be stored for it. Those are things you can start to do with

Erbit. Push notifications and other kinds of automated interactions can happen because it's your server and it can talk to you over any mechanism that a server can talk to a person. So when certain things happen, you can drive all kinds of other programmatic constraints. You know, like imagine if you could get a push notification every time someone requested your signature on going back to NOSUS, you know, you've actually got something they're waiting for you and I don't have to use some other mechanism like signal to tell you that you need to go and sign this thing. Instead, it's something coming directly from the Urban NOSIS Safe application that upon clicking takes you directly to a place where you can actually sign the transaction

and view it or interact with it. So, I mean, I think the biggest thing it really has to offer is just enriching the whole ecosystem with more usable applications that are less fragmented. Like, crypto needs an operating system. It needs something that isn't just a set of disparate tools built into webpages with, you know, augmented with centralized services behind the scenes of whatever company is providing the thing, which they, you know, like to Nosis as credit, they've built it in such a way. that they really don't know anything about you when you're using this.

And that's good, but they're still up against the fact that they have to maintain the service or NOSUS safe doesn't work. And because they don't have a model in which, you know, they can build an application that does know things about you, but without the company NOSUS knowing things about you, they're handicapped in terms of the amount of, like the quality of experience that they can deliver you. You know, they can't give you the ability to annotate your own transactions with private information that is meaningful to you that you don't want to share with some other company. Like, you know, you can't annotate your address book with information about the people that you're transacting with and which addresses are associated to whom without giving that to some other company. And they can't send you push notifications because they would have to have enough information about you in order to send that notification in the first place and they don't want that. So there's just kind of like this global limit to usability that is placed on the, the crypto ecosystem as a whole until they have a platform to build applications that doesn't

involve some major compromise and integrity of what the whole thing stands for. Erbit can deliver that. Fantastic. So let's talk a little bit about sort of, you know, the larger ecosystems. You mentioned the beginning, right? So there was like Clon for a long time as this, you know, main company that was developing, you know, the cathedral. but now we're moving to this world of the bizarre, right, where there's like lots of things going on.

So, you know, what are the most exciting things that are happening in the urban ecosystem? One company, there's a couple of talk. Toulon's doing some exciting things still, but I'm going to save them for, you know, for the end because we talk about them a lot. holium. holium.com.

They are a group that started, building on Erbit at the beginning of this year. They were previously trying to build their product on Pocodot, but quickly realized that the whole off-chain state and lack of, you know, that blockchains couldn't solve everything and they needed something else. And they, you know, the team there, led by this guy named Trent, discovered Erbit and realized that it actually solved a lot of their problems. And what they want to build is a unified computing environment, a solid. space that is collaborative for Dauce. The idea is, you know, okay, I've got my group of people and there's a bunch of things that we want to do very much like we do on Discord, right?

We want to be able to talk with one another. We want to be able to, you know, and talk to one another over text, over video chat, over audio, a variety of different ways. we want to be able to like and this is one of the things that I haven't seen you know they're heavily in the works on but I can only kind of imagine but they're building what feels like a desktop environment in which each Dow defines its own space with its own software that it runs it's customized its look and feel

and then shared cursors are a built-in primitive to the environment so when you are in a space on your desktop, which is earmarked for some specific Dow, they call this a realm. You're seeing not only your software for that group, but you're also seeing the cursors of other people and you can build in applications that have shared cursors amongst all the members of the community as a native primitive, along with, you know, a global audio room or video room or something that this group can talk to. And you can easily switch to another space, another realm that has a totally different layout, totally different applications, and totally different people.

And Urban is really kind of the backbone of what enables all of that to happen. There's a little more to it also. You know, when you instantiate a realm, you can do so with whatever, you know, governance rules you want. And you can tokenize it as well immediately. if you so choose. So, you know, it's kind of like a, there are these Dow builder tools out there, but to my knowledge, none of them also come with a complete suite of tooling that allows those people to all interact with one another in a shared space in software that they collectively decide to use.

Akbar is another one worth mentioning, different company. They've been running since about November of last year. So you'll see a theme with people getting started. right after software distribution hit and it became possible to actually build things on Erbit. Okabar is building its own blockchain on Erbit, starting as an L2 ZK-based roll-up to Ethereum. The idea is Erbit ships all act as validator nodes. Ultimately, their plan is to build an L-1 blockchain that is all natively on Erbit,

that there's still some infrastructure work for Erbit to undergo for that to really be possible. But in the meantime, a ZK-based L2 is what they're going for. And that ZK language is all based on Houn. You know, the fundamental assembly language of Erbitt, you might say, is called K. They've built a parallel to that called Zok, which is the zero-knowledge version of it. And they found that knock being a combinator-based language is particularly well-suited to zero-knowledge proofs. So they've been working somewhat closely with Starkware. they've built Cairo compatibility between Hoon code, which compiles to Knock or Zoc and Cairo.

And so the idea is that you can now, with them, not only can you build a peer-to-peer social application and distribute that peer-to-peer with other people, but it can also distribute smart contracts directly with it, all built in the same language that the rest of your program is built in. So that's pretty cool. You learn one language. You learn one stack, and you have blockchain programming. peer-to-peer software development all in one place. Another group called Terrell. They're building software for creators where you can accept payment either along crypto or Fiat Rails for pretty much anything you list. Your Erbit can become its own storefront. You can list a blog that can be subscription-gated or not.

You can list products. In fact, we're about to, we're working with them. very closely, especially this week, to go live with a pilot of their product store, which will be what we use to sell tickets for assembly or conference. So that'll actually all be, our ticketing infrastructure will be built out by an urban company and sold over an urban company's payments rails. And it's important for us that it's settled into USC because the Irbit Foundation is completely unbanked and crypto-native. So they're mostly working on this space for how can individual people list their own products for sale, how can they actually make either real money or magic internet money for them, whether those be content creators or physical good creators. And of course, Toulon, like one of the big things they're working on is urban onboarding. It's still very difficult to run an urban yourself if you're, you know, unless you're a highly technical person or a moderately technical person. Erbit hosting is their big thing, where they provide hosted urban for you as a service.

And part of the constraints of providing good urban hosting is that, you know, you can take your orbit with you. And this is one of the hard things infrastructurally to build about an urban hosting provider is you need the ability to, you know, basically export your orbit from the hosting provider and shut everything off through them. You know, instead of paying them a monthly fee, you can download that whole orbit. You can then start running it on your local computer. Or you can move it into a self-host. one if you want to take that on yourself. But having an option for, you know, normal people that do not want to spend up their own digital ocean droplet and run an orbit is very important where they can just sort of sign up

for one and let someone else run that infrastructure for them. And that's kind of their, I'd say, the fundamental thing that they're trying to crack, along with a company called Third Earth, which is also building, hosting technology themselves, And they have a totally different architecture for it. So there's a little bit of friendly competition there to see kind of whose architecture is best. One more question sort of in terms of the, you know, the future. So one of the things that I find pretty interesting and like strange about orbit, but like actually it makes a lot of sense.

It's this idea that, okay, the software or at least that the orbit system, the fundamental operating system becomes you know it stops changing at some point right so that you can for example you'd be able to like boot up some planet

30 years from now and it will still run which is of course very different from if you look at any kind of software from like 20 years ago nothing works right because like it's all built on stuff that's changed and upgraded

and like but so if you look at this fundamental elemental urbid kernel, is that finish or like, is there still like a roadmap of changes that are coming? Yeah, the colonel's definitely not finished. There's a lot that's going to change. The thing you flag there is that it will finish. You know, like that's, and that's not, that's a, that's a hard constraint of the way urban is built, which probably bears some elaboration. You know, what Brian's referring to is the idea of, at least if we take it technically, the idea of what's called Kelvin versioning, which Erbit invented as far as I know. Yes, we also invented our inversioning system, which counts backwards to zero and stops at zero.

Yeah, this is in stark contrast to everything else, which counts infinitely upwards with, you know, whatever scheme you want, whether that's, you know, no counting at all. it's just, you know, a hash of the latest version, or it's, you know, Semver or something. The idea with Erbit is that you are gradually, you know, you're the, and this is really only constrained to the kernel, like the most fundamental layers of the stack, right? User space software, applications you build, that can be version however the heck you want it to be. But the kernel, the actual operating system, is Kelvin versioned, which means it starts at a warm state, you know, four or five hundred somewhere in there, and it moves backwards to zero. And once it gets to zero, it can never be updated again. So the mentality that this

enforces is every time I do an update, it needs to be more robust than the last one, because it's getting closer and closer to my last update that I ever get to make. And so where, you know, in our current world, most software is either perpetually changing or it is frozen by accident because it's now become so ubiquitous that it's impossible to change without causing a catastrophe. Like if you imagine what happened if JSON introduced a breaking change, it wouldn't happen. It just can't happen because JSON has become an accidental standard in its current form that you couldn't make backward incompatible or change without, you know,

an unimaginable amount of overhead. Just about everything else changes indefinitely. Or it ends up kind of at whatever state it is until it's too hard to change. The orbit kernel is being designed to freeze to hit absolute zero. That's the name Kelvin version. It's being designed that way, which means that it should perpetually approach this, you know, as close to perfect as as these guys can get it, which means that the software stack simplifies over time. The arc of development is one of contracting, a contracting code base.

There's less and less that is added over time as the group figures out how to make things more concise and elegant, more fundamental, per se. And where is it at today? So the operating system itself, collectively, is it Kelvin, 418? So we've got a long ways to go. Houn, the language, is at Kelvin 4? Or sorry, no. Knock, the assembly language is at Kelvin 4. So there are four more updates that can ever be made to knock.

So knock is not updated very often. Hoon, I think, is in the low hundreds. And then the Arvo Kelvin is at about 400. So there's many more updates that can be made. There's several of the made per year, but that will probably pick up as more developers are added to the project and the changes

become more fine-grained. I think the main things that are on the core developers radar right now are performance-related. Like one of the big current things

is called subscription reform. The subscription mechanic where you subscribe as kind of a pub sub-model to information coming out of Gaul agents returning to urban

applications. The API for that is, you know, after a couple years of working with it, has been shown to be, you know, kind of annoying. And so, and, you know, not very ergonomic from a developer's perspective. And so they're kind of reworking the way that subscriptions work to be both more performant and more pleasant to use. There's a global content addressing scheme called, they call it uncreatively content distribution. But this is a way of more efficiently distributing. information around the network through things like gossip protocols and universal identifiers a la IPFS. This enables it, you know, enables Erbitts to syndicate out information and get it

not necessarily from its source, but from anyone else that happens to have the same piece of addressed content. And that's a big improvement. And another ongoing effort is a complete rewrite of the Erbit runtime or virtual machine. That's all written in C. The current runtime we have is the product of a handful of people's work over the last decade plus. And it's, you know, it's pretty good, but it's amazing that it is as good as it is given, you know, how little resources have been put into it. And there's currently an effort to kind of re-architect the entire way that that works, which will fix a lot of major performance constraints around the like the storage limit back when urbit was first built it was built as a 32-bit system so there's a limit to

you can only have two gigs of data in an urbid that's one of the things that is going to change which enables the storage of much larger files on your ship constrained only by the underlying disk space as well as just the general performance of the system through a different architecture making the AIMS network, the peer-to-peer network, it's called AIMS, making it much more performant. Past that, developer experience needs to be greatly improved. You know, the fundamentals are there, but the day-to-day can still be a little bit rough. There's a lot of work that needs to happen to the terminal, which is close to coming out. We did a developer call on that last week with Pelfin Foslips or showing off the latest work on the terminal.

permissions and security. There's a little bit more, probably a lot more auditing that needs to go into the underlying security model and permissioning between applications model on a given ship. That's kind of the stuff that's in the immediate sites right now. And that's probably going to span the next year, year and a half. But we're definitely, like a lot of the major problems,

you know, the main things like Ames actually working. and, you know, an identity system really working and being scalable. These problems have been solved. And we're now getting into those fine-grained things and closing, narrowing down on the list of big outstanding problems, which, you know, incoming years, all of those will be done and it'll be on to polish and refinement of the experience. Cool. I'm sure a lot of people are like curious, interested. How can they get involved? What can they do for a bit?

Like so, yeah, can you give some pointers? Like if people are intrigued and they want to get involved in some way, where should they go? Anyone that's interested should definitely get on the network. You know, it's not the easiest thing in the world to do, but it's also not the hardest. I'm talking to a Web3 audience. So, you know, we're all accustomed to a little bit of. of UX pain. You can get on for free using a comet.

You can also get on, I mean, a planet is the ideal way, and you can buy them. You can also generally just like ask on Twitter or people will DM you one because it's a very friendly group of people. So you should get on the network and you should, you know, start talking to people and seeing what's going on, usually in the group's application. You should go to our website. If you're a developer, there's a big update coming out in about 10 days. the end of the month is what we're targeted for, which will create kind of a totally reworked

developer portal with content that describes in very succinct terms step by step what you need to learn in order to become an urban developer. We ran a course. We run probably twice a year. We're going to run an instructor-led introductory class. We just ran the last one, graduated about 61 people, actually precisely 61 people. And that was that was a huge hit. It's taught by a wonderful instructor. We have a grants program, unsurprisingly, that awards urban address space

to people that either tackle technical projects or propose their own. We also have an apprenticeships program as part of that where you can kind of learn side by side with a more experienced developer who will mentor you on, you know, some more technical problem. And then finally, we have a, you know, the, I hesitate to call it a conference because

if you've been to an urban event, you won't find it like any other conference. So I've been using the word confluence. We have an urban confluence in Miami in September. Tickets are going on sale for that in the next week or so. It's September 22nd through 25th. That'll be a place where you can meet a whole bunch of people from the. community, go to some, you know, go to some side events, hear some talks, see the things that have, you know, our ecosystem has been working on for the last year. There will be a lot of launches

there and a lot of people with a lot of energy that will be very happy to meet you and get you involved in whatever their project is. Things are very word of mouth under, but so being on the network and talking to people is how most of the work gets done through, you know, direct We're running a hackathon that culminates an assembly. The winning four teams present and will be, you know, voted on as prize winner by the audience using an urban application that Holyum produced called ballot. And that group will win, you know, a handful of stars for the best thing they do. And you have two months. So app school live, the class that teaches you how to become an application developer that does have some prerequisites. So, you know, you've got a few weeks before that starts. So, you know, start reading the docs for sure on urban.org. That kicks off September, July 12th.

The hackathon starts a couple weeks later, culminates at assembly. So if you're a developer, you're listening to this, you want to get involved. Now is a really great time. And you can always reach me at josh aturbit.org or Wolf Podlex on the network. Cool. Thanks so much, Josh. It was really great to have you on. You know, I'm super excited about orbit.

I'm definitely going to be at assembly. And, you know, I've been, you know, probably speaking. Very much. Yeah, absolutely. And I've been very much enjoying, you know, diving into orbit and super excited about what's there to come for the network and for the project. So thanks so much for coming on.

And I'm excited for our listeners to kind of get an update on orbit. And I'm sure some of them will, you know, check it out and get more involved as well. Absolutely. Yeah, thanks so much for having me. This has been a lot of fun. And, you know, enjoy it. Looking forward to seeing you at assembly. Thank you for joining us on this week's episode. We release new episodes every week. You can find and subscribe to the show on iTunes, Spotify, YouTube, SoundCloud, or wherever you listen to podcasts. And if you have a Google home or Alexa device, you can tell it to listen to the latest episode of the Epicenter podcast. Go to epicenter.tv slash subscribe for a full list of places where you can watch and listen. And while you're there, be sure to sign up for the newsletter, so you get new episodes in your inbox as they're released. If you want to interact with us, guests, or other podcast listeners, you can follow us on Twitter. And please leave us a review on iTunes. It helps people find the show, and we're always happy to read them.

So thanks so much, and we look forward to being back next week.