Open-source project
tendermint/tendermint avatar
tendermint/tendermint

Tendermint replicates your state machine, it does not contain it

⟁ Tendermint Core (BFT Consensus) in Go

5,869 stars2,099 forksGoApache-2.0

At a glance

What is it?
Tendermint Core is Go middleware that agrees on the order of state transitions and replicates your application across machines. The judgment that matters for an adopter is its versioning policy: a MINOR bump can force a new chain, and the feature set on main is frozen for long term support.
Who is it for?
Tendermint fits a team that already has an application to run and treats a MINOR version bump as a migration event rather than a patch. It does not fit a team looking for an application framework, a 1.0 stability promise, or help moving old chain data forward.
Can I use it commercially?
Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 1 day ago.
What is it written in?
Mainly Go, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • tendermint/tendermint5,869 ★ · +5
Star history
Repository2026-09-232026-11-15
tendermint/tendermint5.9k5.9k

5 Stars in the last 53 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The state machine stays yours, Tendermint only replicates it

Tendermint Core is middleware, not a chain. You write a state transition machine in whatever language you like, hand it to a Tendermint node over ABCI, and the node's job is to run that machine identically on many machines while agreeing on the order in which the transitions happen. Nothing about your application has to be in Go, which is why the dependency list in go.mod (protobuf tooling, gRPC, leveldb and bolt drivers, metrics, p2p libraries) is infrastructure rather than application code. The project's own shorthand is state machine replication, and blockchain for short. What the node adds over an ordinary replicated service is agreement about ordering under Byzantine faults, plus the vote rounds, the evidence handling and the peer gossip that keep that agreement standing. What it never adds is a data model. Blocks carry your bytes. How you name them, index them, and reject invalid ones stays in your code, executed identically everywhere or not at all.

Go 1.18, and a version string read out of git

The minimum requirement table amounts to one line: Go 1.18 or higher, matching the `go 1.18` directive at the top of go.mod. Building runs through the Makefile, and the Makefile takes the version from git rather than from a version file, so a checkout on a branch reports its branch and commit hash while a detached checkout, such as a checked-out tag, falls back to `git describe`. That value is injected into the binary through a linker flag against the version package, the binary lands at build/tendermint, the default build tag is tendermint, and CGO is off unless you ask for it. The storage backend is picked the same way, by build tag: cleveldb and rocksdb switch CGO back on, badgerdb and boltdb do not, and nostrip keeps the -trimpath and -s -w flags off the link. There is also a race option that turns CGO on and adds -race, plus a default target that runs check, build, test and install in that order.

bash
PACKAGES=$(shell go list ./...)
OUTPUT?=build/tendermint
BUILD_TAGS?=tendermint
CGO_ENABLED ?= 0
all: check build test install

Those five lines are the whole build contract a first run needs to understand. Change OUTPUT to put the binary somewhere else, or set TENDERMINT_BUILD_OPTIONS to pick a database backend, and everything else in the Makefile follows from those variables.

Four local nodes on one bridge subnet, each with its own port pair

The compose file in the repository root is the quickest honest look at what a node exposes and how several nodes coexist on one machine. It defines four services, node0 through node3, all running the image tendermint/localnode, all mounting the host's ./build directory at /tendermint so the binary you just compiled is the one that runs. Every service receives an ID environment variable and a LOG variable defaulting to tendermint.log, and every service is pinned to a fixed address on a bridge network named localnet, from 192.167.10.2 through 192.167.10.5 on the 192.167.10.0/16 subnet. The port mapping is the detail worth reading twice: node0 publishes 26656-26657 unchanged, and node1, node2 and node3 shift that same pair to 26659-26660, 26661-26662 and 26663-26664, so four nodes fit on a single host without colliding. Note that a range is mapped, not a single port, which leaves room for the second endpoint in the pair.

yaml
node0:
  container_name: node0
  image: "tendermint/localnode"
  ports:
    - "26656-26657:26656-26657"
  environment:
    - ID=0
    - LOG=${LOG:-tendermint.log}
  volumes:
    - ./build:/tendermint:Z

Because the volume is the local build output rather than an image copy, the loop is edit, rebuild, restart container, and the guide for that path is the docker-compose quick start under docs/tools.

A MINOR version bump can mean starting a new chain

Before 1.0.0, semantic versioning here means what it usually means and no more. The stated policy is that anything in the public API can change at any time until 1.0, and that the MINOR version carries the breaking-change signal for 0.X.X users. The definition of that public API is unusually wide: all publicly exposed types, functions and methods in non-internal Go packages, plus the types and methods reachable through the Tendermint RPC interface. An operator talking RPC over the wire, without a line of Go, is therefore inside the blast radius of a MINOR bump and not only a Go importer. The consequence is stated without hedging: breaking changes are not guaranteed to work with existing Tendermint blockchains, so in that case you start a new blockchain or write something custom to move the old data into the new chain. PATCH bumps go the other way and are meant to stay compatible with existing blockchain histories. Breaking changes are written down in the CHANGELOG, and UPGRADING.md is the file to read before touching a live node.

Patch releases only, two minor lines, and a frozen feature set

The freeze is stated at the very top of the file, with an issue number attached: the TendermintCore feature set is frozen for LTS. The line described as the latest stable release used by cosmoshub-4 is 0.34.24, and the former v0.38.xx main branch has been set aside under the name main_backup, which tells you exactly where the tree you are reading sits in that history. Patch policy follows from team size. Because the core team is small, only patch and security updates reach the most recent minor release and the one before it, and the guidance is to keep current rather than plan around an older line. The published versions also show the pace: v0.34.23, v0.34.24 and v0.37.0-rc2 all landed in November 2022, while the last push to the repository is 2026-10-31, so commits still reach the branch even though the release tags predate them. Production guidance is equally direct: do not depend on main as your production branch, take a release instead.

The tree reads as a map of the consensus path

The root listing divides cleanly. consensus/, p2p/, mempool/, privval/, evidence/, statesync/, light/, state/, store/ and blockchain/ are the moving parts of a live node. abci/, proxy/ and rpc/ are the interfaces an application and an operator actually touch, node/ assembles them, and cmd/ is the binary. Beside those sit the support trees: proto/ with the buf configuration for the wire format, spec/ for the protocol description, docs/ for install and quick-start guides, test/ and behaviour/ for test scaffolding, libs/ for shared libraries, networks/ and DOCKER/ for the local cluster, scripts/ for tooling, and config/ for configuration templates. The automation files describe the working style as much as the directories do: golangci for linting, goreleaser for builds, mergify for queue management, codecov for coverage, dredd for API testing, with CircleCI and appveyor as the two CI systems and a Makefile that ties check, build, test and install into one default target.

Boundaries: no 1.0, no data model, no migration help

Several things Tendermint does not do are worth saying before anyone builds on it. It is not an application framework: no wallet, no token, no user model, no transaction format, which is why the listed users (Cosmos Hub, Terra, Celestia, Anoma, Vocdoni) each wrote their own. It has not reached v1.0, and the given reason is continuing breaking changes to the protocol and the APIs, so the protocol itself carries no compatibility promise yet. It does not keep your history readable across a MINOR bump; moving old chain data is work you write yourself. It ships no proof of safety or liveness inside the code: that analysis sits in a separate paper, and the protocol description sits in spec/. Development was led primarily by All in Bits, Inc., and the trademark belongs to New Tendermint, LLC, which is also the contact behind the hiring note for Tendermint2 and gno.land.

Cosmos SDK, tendermint-rs and ABCI Tower sit on three sides of the seam

The neighbours named alongside Tendermint each take a different position around the same boundary. Cosmos SDK is a framework for building applications in Golang, so it is the layer above: it supplies the application and this repository supplies the agreement underneath it. tendermint-rs attacks the same consensus problem from Rust. ABCI Tower, hosted under the penumbra-zone account, is listed as a third library. The five applications listed (Cosmos Hub, Terra, Celestia, Anoma, Vocdoni) are not competing engines but evidence of what has been built on this one. Picking among them is a question about your application language and your trust assumptions, not a scoring exercise.

Editorial conclusion

Tendermint fits a team that already has an application to run and treats a MINOR version bump as a migration event rather than a patch. It does not fit a team looking for an application framework, a 1.0 stability promise, or help moving old chain data forward. Before adopting, read UPGRADING.md and CHANGELOG.md, then pin a release line deliberately, because what sits on main is the frozen 0.34 tree.

Frequently asked questions

What is Tendermint in a blockchain?

Tendermint Core is Byzantine Fault Tolerant middleware written in Go. You supply a state transition machine in any language and the node replicates it across machines while agreeing on the order of transitions, which the project itself calls state machine replication, or blockchain for short.

Tendermint vs HotStuff?

The README's overview does not compare Tendermint with HotStuff. The safety and liveness analysis of the Tendermint protocol sits outside the code, in the paper the README links, and the protocol description itself sits in spec/.

Tendermint vs CometBFT?

The README's overview does not mention CometBFT. It does say that the feature set is frozen for long term support, that 0.34.24 is the latest stable release used by cosmoshub-4, and that the former v0.38.xx main branch now lives under the name main_backup.

Official sources

  1. License: Apache-2.0
  2. Project website
  3. README
  4. Releases
  5. tendermint/tendermint on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/tendermint-tendermint.svg)](https://hysenlabs.com/projects/tendermint-tendermint)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/tendermint-tendermint.svg)](https://hysenlabs.com/projects/tendermint-tendermint)

Was this useful?