A couple of months ago, after announcing the formation of the SDK Working Group, we released version 7 of the Aragon CLI. As discussed in that post, the v7 release consisted mainly of leveling the terrain for great things to come in 2020. That wasn’t just a promise.

We’re happy to follow up on that story with a release that might be the beginning of an entirely new way to develop Aragon apps: the Aragon Buidler plugin.

This new tool allows developers to go straight into development without any distractions whatsoever. Developers only have to perform a couple simple actions to spin up a fully working Aragon app that automatically reloads itself as they modify its code. The learning curve for developing Aragon apps becomes dramatically lower, and the tool’s minimalistic interface practically eliminates all points of failure. Not only will existing Aragon developers be able to focus on what matters without constantly popping open the hood to see why the car isn’t starting, but new developers won’t be scared away from building on Aragon.

With the Aragon Buidler plugin, what was previously a complicated workflow for developing Aragon apps has now become as simple as pressing a button. Come see for yourself.

Saying goodbye to the old ways



Before the Buidler plugin, not only was setting up a development environment for building Aragon apps difficult, but caused people to resolve the issues that pop up in different ways. Even within teams like Aragon One, not every developer set up their projects in the same way. Put in simple terms, developing Aragon apps was hard, fragile, and there was no single correct way to do it.

Albeit, the situation was hardest for newcomers. Many who developed an itch for playing with the Aragon stack, and eventually decided to give it a shot, were quickly intimidated by the complexity of its stack. One would find a tutorial, follow it, and realize that something broke along the way, without the faintest idea of what it was. This forced people to postpone experimentation, and developers would walk past our door, shyly looking in.

Even experienced Aragon developers often found themselves wondering why their application was not showing up on the Aragon Client, or if they were doing everything they were supposed to. After some hours of debugging, usually with more than just a single pair of eyeballs, and addressing all the gotchas in the book, someone would finally find a typo in an ENS domain or a missing permission. After some fixing, voila! It worked, only to forget what they were initially working on, or losing the motivation to continue.

The process was complex and brittle, and would make developers think twice before starting a new experiment on an Aragon app.

Those days are over.

Enter the Aragon Buidler plugin

So, how does this new tool solve all that? It’s quite simple. We’ve split our existing tools into two families of tools: one for power users and another for developers.

aragonCLI is an extremely powerful tool, for sure, but it was designed for too much: you’d use it to build, develop, publish, inspect and maintain applications and organizations, covering all the possible use cases from a single choke point. Something as flexible as that is understandably prone to complexity and failure.

The Buidler plugin is the opposite kind of beast. A tool built for a single purpose and heavily optimized for that single purpose. It only focuses on development use cases and does its job really well. For example, it does not support IPFS for serving an application’s front end—it doesn’t even know what IPFS is. Instead, it uses HTTP directly. This is just one of the shortcuts to minimize the possible failure points that may appear while developing an app and reach the objective by traversing the critical path.

When using this tool, you’ll notice that things just work, and oh boy, do they work faster!

If you’re a developer and would like to dive into the experience and start using the plugin, check out our technical post in the forum, “Aragon Buidler plugin - beta is out!”. There, you should find all you need to hop on board.

A new philosophy for Ethereum development

What exactly is Buidler? Buidler is “a task runner for Ethereum smart contract development”, and it promises to “turn a mess of tricky Solidity tools into a smooth workflow”. It’s extremely modular, allowing you to do things like choose which Ethereum Javascript API to use e.g., Web3.js or Ethers. Every component is a plugin, people develop plugins for Buidler, and they all harmoniously converge into a single, unified workflow.

There are many other great tools out there, but too often would developers be excited about how tool One has this feature A, only to find out that tool Two has this great feature B, but that they can’t use feature A and B together. Well, with Buidler, you can, and this is slowly becoming a trend in the general Ethereum ecosystem. Tools are starting to be designed in ways that allow you to exchange components, granularly pick what set of features you’d like for your project, and not be subject to the opinions of others about what libraries you should be using. Buidler started this trend back in 2018 when it launched, and now tools like Truffle and OpenZeppelin are beginning to adopt similar philosophies.



You can read about an example of this modular setup in "The New Solidity Dev Stack: Buidler + Ethers + Waffle + Typescript [Tutorial]."

A developer may be using the Aragon Buidler plugin, and hear about a great new feature that just came out. It’s as simple as grabbing the new feature and plugging it into the workflow.

Alternatively, someone might have started writing a smart contract, only to realize it could fit well into an Aragon organization. Now they can easily fork their old application and enhance it to become an Aragon app in a few simple steps.

So, not only is development becoming way easier, it’s becoming way more powerful.

Envisioning a future with many more plugins

From the beginning of the development of this plugin, we envisioned that multiple plugins for Buidler would start appearing within the Aragon sub-ecosystem, allowing us to extend this first Aragon plugin with functionalities that we can’t even imagine right now.

Someone could, for instance, develop another Buidler plugin that allows developers to include Aragon Black’s Fundraising apps in their development environment, or even applications that interact with Aragon Court. Someone else could develop a plugin to serve an application’s front end with IPFS locally.

The possibilities are endless.

Conclusion

Our dream of changing the perception of the Aragon stack from something complicated and unapproachable, to something simple and practical is becoming a reality, and this plugin is the first major step in that direction.

Thanks are in order for the SDK Working Group (especially Mesh and the Aragon One team), and special thanks to the Buidler team that worked very closely with us to make this happen.

Check out Aragon Buidler Plugin on Github

