The blockchains that you know and love have a pretty rigid structure. As a developer, this gives you two options: build applications inside a restrictive environment or fork the code and make your own chain. Creating your own chain isn’t so easy, though – you also need to start a network and figure out what consensus mechanism
Tendermint is open-source software for launching blockchains that allow you to write applications in any language. Better yet, they can communicate with other blockchains.
Creating a cryptocurrency
network takes a lot more effort than just initializing a database. It requires a delicate balance of incentives and trade-offs between security, decentralization, and scalability.
Unsurprisingly, a range of different approaches has been explored by teams looking to build the strongest blockchain ecosystems. In this article, we’ll take a look at one such approach: Tendermint
Much of Tendermint will seem familiar if you know a bit about blockchains. Let’s recap some key concepts before we delve into it further.
Understanding blockchain architecture
Tendermint is a kind of blockchain stack
. Then again, things like Bitcoin
are, too. Remember, it’s not just about the blockchain database itself, but about the peer-to-peer network
, how they interact, and the fun stuff you can do with transactions and smart contracts
as well. The goal here is to have everyone agree on a state
(like a snapshot of the database), even if they don’t trust anyone else.
For the most part, today’s major blockchains have come up with the secret sauce that makes this possible. However, they often rely on monolithic architecture: a software engineering concept that means components are interconnected and interdependent. You couldn’t just take a piece of it and plug it into something else.
Monolithic architecture isn’t great if you want flexibility. In the opposite kind of model (with modular architecture), you can tweak individual components without worrying about breaking anything. With a monolithic structure, you need to ensure that every component remains compatible when you upgrade a single one.
Now that we understand this distinction, we can talk a bit more about the Tendermint protocol.
Byzantine fault tolerance (BFT)
You might know that the big innovation with Bitcoin was that it solved something called the Byzantine Generals’ Problem
. We won’t go into the specifics about the problem (check out our article on Byzantine fault tolerance
if you’re interested). All you need to know is that it details a scenario where participants must communicate in a distributed setting.
These participants don’t know whether others are lying or whether messages sent between them are being modified. A system is said to have Byzantine fault tolerance (BFT) if participants can agree on a set of facts, even with those issues present.
Obviously, in a decentralized setting, getting this right is crucial. Cryptocurrencies that aren’t Byzantine fault-tolerant don’t really work – you’d need some kind of centralized party coordinating, which defeats the purpose. Like many digital currencies, Bitcoin gets around this by using a Proof of Work
(PoW) consensus algorithm.
The three layers of a blockchain
So we know the difference between monolithic/modular architecture, and we know that decentralized cryptocurrency networks need to be Byzantine fault-tolerant. Let’s mention the layers that we typically see in a blockchain: the application layer, the consensus layer, and the networking layer.
The consensus and networking layers are where you have network nodes speaking to each other, and trying to agree on a set of facts. The application layer is where you can do stuff yourself – think of decentralized applications
and smart contracts
in Ethereum or custom transactions in Bitcoin
First, a quick clarification on terminology. We’ll use the terms “Tendermint” and “Tendermint Core” interchangeably here since we’re only focused on the tech.
However, Tendermint is the name of the company (founded by the developer that wrote the original whitepaper, Jae Kwon), while Tendermint Core is the actual software the company works on. More specifically, the software has two primary components: its core consensus engine (Tendermint Core) and its application interface (ABCI).
Tendermint Core is a system that achieves fault tolerance. In essence, it’s a big, distributed computer that shows everyone the same state at the same time. So long as at least two-thirds of the participants are honest, everything works smoothly. But that’s pretty much every blockchain, right? What makes it so special?
Firstly, the consensus mechanism used is a Proof of Stake
(PoS) one. For each period, a random node from a validator set is selected. That node must then propose the next block
(in something called a round-robin
system). If the other validators are happy with it, then the new block is added, and the chain is updated. Finality is instant – unlike with Bitcoin or Ethereum, there’s no need to wait for confirmations
to be sure that your transaction is valid.
But wait, there’s more! Tendermint Core’s architecture is modular, with the application layer divorced from the consensus and networking layers. In plain English, that means that you can plug your own application layer into the stack. No need to worry about pesky incentives or consensus algorithms.
Perhaps this isn’t too thrilling for the end-user. But for developers, the ability to leverage an existing framework means they can dive right into building applications without bootstrapping a whole network. Data from the blockchain can be piped to the integrated layer, enabling devs to write software in any language.
The magic happens with something called the Application Blockchain Interface, or simply, ABCI. Think of this like the GPIO pins you get on a Raspberry Pi computer. You can hook up all kinds of third-party components to those, from LEDs to elaborate sprinkler systems for your plants. In a similar way, the ABCI is what defines the boundary between the blockchain and the applications running on top of it.
What’s so great about Tendermint Core?
The separation of the application interface and the consensus mechanism allows greater flexibility for a range of decentralized applications to incorporate any programming languages into their business logic.
For a tangible example of what can be done, you need only look to Ethermint
: a project that took the Ethereum codebase, removed the Proof of Work mechanism, and bolted the Ethereum Virtual Machine on top of Tendermint.
This made a few interesting things possible. The first is that Ethereum developers could port their smart contracts over to the new engine with ease, or write new contracts in the Solidity language. On top of providing Ethereum functionality, Ethermint acts like a Proof of Stake Ethereum, giving us a glimpse of what a Casper
implementation might look like in Ethereum 2.0
The promise of an “internet of blockchains” is what attracts many to Tendermint-based protocols. Interoperability
is a long-awaited addition to the cryptocurrency space, as it means that hundreds of individual blockchains would become cross-compatible.
At present, a lot of work has been put into the Cosmos SDK
, an open-source framework that allows anyone to create an application-specific public or private blockchain. These blockchains can then be plugged into the wider Cosmos network, via something called the Cosmos Hub, where they can communicate with others.
Numerous popular projects have been built with the Cosmos SDK, such as Binance Smart Chain (BSC)
, Band Protocol
, and IRISnet
As a blockchain engine, Tendermint has caught the attention of numerous stakeholders in the cryptocurrency sphere, from developers to end-users.
If the software continues to gain traction, it could very well serve as the backbone for an internet of blockchains. As we’ve seen, a handful of projects have already launched with the Cosmos SDK to realize this vision.
Got more questions on Tendermint, consensus algorithms, or blockchain technology in general? Head over to Ask Academy
, where the community will answer them.