Aragon OSx: The Unix of Ethereum
DAO technology is still in the early adoption phase. Through experimentation, we are still discovering which governance models and best practices will be successful and sustainable for the long term.
One of the biggest challenges for DAOs is that the blockchain is an immutable record, which can make it difficult to adapt and experiment. To solve this, many DAOs have resorted to running more operations off-chain, relying on a trusted group of actors to execute decisions. But we believe that for DAOs to be truly unstoppable, they must run on blockchains.
Building adaptability into a DAO framework is the solution for DAOs wanting to run onchain and be able to adapt their governance as they learn and grow. That’s why we deployed a new DAO framework: Aragon OSx. It was built to be lean and modular, so that organizations could easily customize and adapt their governance.
By following the Unix philosophy and building simple, composable building blocks that can be mixed and matched, organizations can find the solution that works for them—and change it later when their organization evolves.
Let’s dive into Aragon OSx: the operating system for DAOs built with the Unix philosophy.
What’s an operating system?
First, let’s cover exactly what an operating system is, so we can share how it works with DAOs.
An operating system makes your computer run. Mac OS, for example, is the operating system that all Mac computers use. The operating system acts as the intermediary between the hardware and software of your computer. Essentially, an operating system is a permission management system, allowing programs (apps you install on your computer) to run by granting permissions to them. You can have multiple apps on your computer at once, and when you don’t need an app anymore, you uninstall it.
An operating system works like this: there is a trusted kernel at the center with unrestricted resource access to tools like the camera, microphone, screen, and disk. The kernel is the central component of the operating system and has full control of hardware systems.
Then, there are several external, untrusted programs that request access to the shared resources. A program might be Google Chrome, the Mail app, Discord, or any other application you install on your computer.
Every app you install needs permission from the operating system, and, depending on the permissions you have set up, it succeeds or fails.
In short: operating systems manage permissions to untrusted apps.
For example, when you install Discord, you need to give it permission to access your camera and microphone. However, you can choose to block access to these tools.
There’s one key element of operating systems that makes them so efficient: With an operating system at the core, there’s no need to reinstall the entire OS to make one update in an app. You simply update the app itself. This is the primary difference between the original AragonOS and the new Aragon OSx.
This means the operating system itself doesn’t have to change—just the apps, which are small modular pieces and therefore easier to change. This makes updating and changing things significantly easier than if you didn’t have a permission management system at the center.
Before we cover how our operating system for DAOs works, let’s look at the philosophy behind it.
What’s the Unix philosophy?
When building our new operating system for DAOs, we needed a few guiding principles to help us stay on the right track. So, we looked to the Unix philosophy.
The Unix philosophy is a set of norms and practices established by developers working on the Unix operating system in the 1970’s. The philosophy became so influential that it spread beyond developers in that ecosystem to builders across multiple industries. Here are some key aspects of the Unix philosophy that we applied to building OSx:
Simplicity
Write programs that do one thing and do it well. Rather than build one monolithic program that handles many things and is hard to change, each program should do one thing well.
Modularity, Composability
Write programs to work together. Since we’re not building monolithic programs, all the small pieces need to work together into one larger system.
Flexibility
Allow a feature to be reused in different contexts. The same program, if flexible enough, can be reused in different contexts so you don’t need to build something new every time.
Everything is a file -> Everything is a permission
In Unix, everything is a file. This makes it easy to reuse the same tools and utilities, because you already know what everything those tools and utilities need to interact with is.
In Aragon OSx, everything is a permission. Like the concept of “everything is a file,” classifying things as permissions makes it easier to reuse the same tools and reduces complexity.
Here are a few more guiding principles of Unix that we applied to OSx:
- One correct way of doing things: This standardizes best practices, so builders aren’t confused by different styles of doing things.
- Be explicit about what you do: There’s no hidden magic. Everyone can use, understand, and audit this protocol.
- Only pay for features you actually use: There’s no hidden bloat. You just pay gas for the features you use, rather than paying for everything.
- Easy to understand, verify, and reason about: This contributes to the security of the protocol, because it’s not convoluted or complex.
Now, let’s look at how the concepts of an operating system and the Unix philosophy came together to create Aragon OSx.
DAO core at the center, plugins at the edges
When building OSx, we took the approach of trusted kernel at the center plus plugins at the edges—just like the operating system that revolutionized the computer. And we applied the Unix philosophy on top.
We do this through the DAO core on the inside and the plugins on the outside.
DAO Core: managing permissions to outside programs
The DAO Core, or vault, holds the DAO’s assets and acts as the trusted kernel. The DAO Core’s main function is to grant permissions: it needs plugins to perform complex actions. Keeping the core of the DAO lean is much more secure, because simple programs are more secure than complex ones.
But for plugins to interact with those assets—such as to withdraw, swap, or stake—they need to be granted permission. This setup is just like a trusted kernel with outside plugins.
In the image below, you can see the assets in the DAO’s treasury, like ETH and DAI. A layer of permissions separates those assets from the plugins below, which need to request access from the DAO to interact. So, in order for the “withdraw” function to execute, it needs to go through the permission layer.
Plugins: external programs solving small, custom problems
What’s on the other side of the permissions? Plugins.
A plugin is a smart contract external to the DAO that can do things on behalf of the DAO only when permissions are granted. Plugins are small, composable building blocks that can be rearranged into many different types of organizations. DAOs will mix and match plugins to build any type of logic their organization needs.
Some examples of plugins:
- Token voting plugin: Allows the DAO to make decisions based on token votes, as long as they meet the governance thresholds.
- Uniswap plugin: Allows the DAO to swap tokens in Uniswap.
- Governance token streaming plugin: Allows the DAO to stream governance tokens to contributors based on certain qualifications.
Think of plugins as apps you install and uninstall on your computer. They solve small, custom problems. If you need a new solution, you can iterate fast—install, uninstall, and upgrade the apps—without needing to reinvent the wheel every time.
The plugins can be untrusted, meaning it doesn’t matter who builds them or what they contain. This is because the plugins aren’t baked into the DAO itself with full permissions to the core: they’re external to the DAO’s core treasury, just like applications are external to a computer’s operating system.
This also means the plugins can also be “unplugged,” or have permission revoked. This is similar to uninstalling an app on your computer. Governance evolution just got easier.
Developers are in control of their own plugins—just like they are in control of their own apps
Developers can choose how they want to design their plugins. The plugins can be upgradeable, making it easy to change and install new versions. Or, they can be non-upgradeable, so they’re not changeable later on.
Much like the apps you use on your computer and phone, developers are in control of how they design plugins.
We’re providing the operating system and the plugins for basic functions that DAOs need to operate, but builders like you are expanding applications and functionality on top!
Aragon OSx enables mutable organizations on an immutable blockchain
The DAO Core plus the plugins—Aragon OSx—come together to enable mutable organizations on an immutable blockchain. Want to start out as a multisig DAO, but a year down the road you onboard another 100 members and need to launch a token and change your governance? Simply uninstall the old governance plugin and install the new one. Want to try a new treasury management strategy? Install a plugin, see if it works for your team, and uninstall it when you’re done.
Building a mutable organization on an immutable blockchain has never been easier. Instead of deploying a new DAO every time they need to evolve, DAOs just need to install, uninstall, and upgrade their plugins to easily adapt their organization.
We believe this will help launch incredible new experiments and truly enable anyone to experiment with governance at the speed of software.
Anyone can build a plugin: here’s how to get started
Already imagining what unique governance modules you can build for DAOs? Thinking about unique ways to define membership, manage finances, and hold votes? You’re in luck, because anyone can build a plugin—and in fact, many developers like you already have! You can check out the projects in the ecosystem page.
Building a plugin is simple, especially with our quickstart guides and boilerplates. To get an overview of how to build a plugin, check out this guide and video. If you’re interested in receiving more content like this, join our developer community to stay in the know.
We can’t wait to see what you create!
Want to see the talk that inspired this article? Watch here, starting at 3:00 minutes: