New technology is tough to explain sometimes. But Holochain isn’t reinventing the wheel. Rather, we are inventing the bicycle when all you have ever seen or used are wagons.

Holochain is built from familiar technical components and best practices, just as a bicycle is built from wheels, gears, frames, and steering mechanisms which all previously existed as basic forms or principles in other contexts.

Sum>Parts: The key components of Holochain already existed, but we put them on a new frame

Our back wheel is the Distributed Hash Table, similar to the ones used by BitTorrent or IPFS to revolutionize peer-to-peer file sharing. This is the database structure that allows data to be transferred in the context of a distributed app.

Our front wheel is built on a lot of the same principles as Git which pioneered local-first version control as we know it today. While our local-first tools are built out of slightly different materials, the principle remains: Agents can always make local changes which then update the network when connected online. Not dissimilar to how the front wheel determines the direction of the bike.

These wheels are powered by a familiar device, the bike chain. Holochain’s source chain uses an implementation of hashchains, which were popularized by blockchains, to connect one action to the next, every action containing the hash of the last. Each agent has their own bike and so they each update their own source chain, independent of the actions of other cyclists. This provides mobility compared to the wide wagon of a single central chain. The beauty of bikes is their independence, the ability to act without everyone needing to be in the same wagon.

The handlebars that steer this contraption are also familiar. Public/private key cryptography used for cryptographic signatures is a staple of most processes on the web, from HTTPS, to the Signal Protocol, to SSH which is used by devs everywhere to access remote machines. Alongside encryption, these keys act as the identity tools which connect the user, the human riding the bike, to their actions on the digital road. Every action they take is signed, controlled through those handlebars, and only the rider is able to steer.

Holochain pulls together all of these time tested tools and reconfigures them to do something none of them can do alone.

We’ve been talking about Holochain from the perspective of the agent — the rider and their bike. But Holochain is an application framework. In this analogy, every application is a unique path that controls where a rider can go, what actions can be taken, and how data is formatted. We talk about this from the perspective of the rider because they get to determine which paths they ride. Riders bridge between paths, connecting them into personalized neighborhoods. Each new app increases the area that the rider can travel and grows an ecosystem of potential routes. Different paths take you to different places, but Holochain lets you move between them seamlessly.

The affordances of each road dictate what can be done on it. Wide roads let many ride together, small curvy paths mean you slow down, etc. In the same way, the application rules are baked in. Changing them would be the same as changing roads.

As a framework for peer-to-peer applications, Holochain is taking on some of the toughest challenges of distributed computing. Ensuring data is validated and secure without central servers, allowing for asynchronous action across a network, and keeping agents honest, are all hard tasks. But each individual piece of this puzzle already exists, we are just recombining them to offer new possibilities.

Holochain is built to allow any group to come together, develop a bike path, and each with their own bike traveling at their own pace, ride the path together. Many different bike paths can overlap and intersect, and riders get to choose their route through them — traveling freely and at their own will.