cloudparts

Hyperledger Fabric

A permissioned ledger for a group of known organisations: each runs its own peers, smart contracts are written in Go, Java or JavaScript, and an ordering service puts transactions in one agreed order, with no cryptocurrency.

LFDT · Graduated
What it is
Distributed ledgers
Type
Open source
Made by
LF Decentralized Trust
Foundation
LF Decentralized Trust, graduated. Part of the Linux Foundation
License
Apache 2.0
Facts checked
28 October 2026
Website Source code

What it is

Fabric is built for a consortium, a few or a few dozen organisations that know each other but don’t want any one of them to own the shared records. Every participant has an X.509 identity issued by its organisation’s certificate authority, and each organisation runs its own peers. Smart contracts, called chaincode, are ordinary programs in Go, Java or Node.js. A transaction goes through three steps, which the project calls execute-order-validate. The client sends a proposal through the Fabric Gateway to the peers whose signatures the contract’s endorsement policy requires (say, one peer from each of two banks); each runs the chaincode against its copy of the state and signs the keys it read and the values it would write, without changing anything yet. The ordering service then puts endorsed transactions in a strict order and cuts blocks, without looking inside them. Finally every peer checks each transaction in a block against the endorsement policy and checks that the versions of the keys it read haven’t changed since; valid ones update the world state, and invalid ones stay in the block, marked invalid.

Data is split by channel: each channel is a separate ledger shared only by its members, and private data collections let a subset of a channel’s organisations keep values to themselves while the ledger stores only a hash. The current state lives in LevelDB inside the peer, or in CouchDB when values are JSON documents to be queried; the choice is fixed before a peer goes into production. Ordering used Raft, which survives crashed nodes, from 1.4.1; Fabric 3.0, released in September 2024, added a Byzantine fault-tolerant orderer based on the SmartBFT library and removed the old Kafka and Solo orderers. The current release is 3.1.5 (June 18, 2026), while the 2.5 line remains the long-term support release. Beside it, IBM Research contributed Fabric-X in 2025: a re-architected implementation for digital assets with a sharded BFT orderer called Arma, which reached 1.0 in May 2026 and which its maintainers say sustained more than 100,000 transactions per second in their own tests.

Why teams pick it

  • Every participant is known and every transaction is signed, so access control, audit and legal agreements can sit on top of real identities, and there is no token, gas or mining
  • Channels and private data collections keep data away from organisations that shouldn’t see it, with a hash on the shared ledger as evidence
  • Smart contracts in general-purpose languages, and endorsement policies that say exactly which organisations must agree to each kind of change
  • Pluggable ordering: Raft when the ordering nodes are trusted not to lie, and BFT since 3.0 when up to a third of them might be malicious

Watch out for

  • Heavy to run: every organisation operates certificate authorities, peers and its share of the orderers, and chaincode upgrades need approvals from enough organisations on each channel
  • Transactions that touch the same keys at the same time conflict, and the later one is marked invalid at commit and has to be resubmitted, so hot keys such as a single counter need redesigning
  • Far slower than a single database, and CouchDB rich queries are not guaranteed stable between execution and commit, so the docs say not to query and update in one transaction
  • Managed hosting is shrinking: Amazon Managed Blockchain stops taking new customers on October 29, 2026 and shuts down on September 29, 2027

Alternatives

What all distributed ledgers have in common →Compare side by side →
BesuOpen sourceAn Ethereum client in Java, formerly Hyperledger Besu, that runs a node on public Ethereum or a private, permissioned network of your own with proof-of-authority consensus.PostgreSQLOpen sourceThe open-source relational database that most new projects start on, extensible enough to grow into many niches.+2 Citus, Omnigres

How it fits with other technologies

Chaincode: endorsing peers run this, then every peer checks what it read at commit · go

package main

import (
	"fmt"

	"github.com/hyperledger/fabric-contract-api-go/v2/contractapi"
)

type Shipments struct{ contractapi.Contract }

// Transfer reads one key and writes it. The read version and the new value
// go into the signed endorsement; nothing changes until the block commits.
func (s *Shipments) Transfer(ctx contractapi.TransactionContextInterface, id, newOwner string) error {
	owner, err := ctx.GetStub().GetState(id)
	if err != nil {
		return err
	}
	if owner == nil {
		return fmt.Errorf("shipment %s does not exist", id)
	}
	return ctx.GetStub().PutState(id, []byte(newOwner))
}

func main() {
	cc, err := contractapi.NewChaincode(&Shipments{})
	if err != nil {
		panic(err)
	}
	if err := cc.Start(); err != nil {
		panic(err)
	}
}

See it in a real stack

No architecture uses Hyperledger Fabric yet. Drop it into the playground and wire it up yourself.Open playground →
Where it came from2016–2026

Fabric began as a merger of code proposed to the Linux Foundation’s new Hyperledger Project in early 2016: IBM’s OpenBlockchain, together with work from Digital Asset and Blockstream’s libconsensus. IBM and Digital Asset contributed it. After a year in incubation it became the first Hyperledger project to reach “Active” status, in March 2017, and version 1.0 followed on July 11, 2017, with contributions from 159 engineers at 27 organisations.

Version 1.0 introduced the design that sets Fabric apart. Earlier blockchains, including Ethereum and Fabric’s own 0.6 preview, ordered transactions first and then had every node execute them in sequence, so contracts had to be deterministic and every node saw every transaction. The 1.0 architecture, described by Elli Androulaki and colleagues at EuroSys 2018, executes first on a few endorsing peers, then orders, then validates, and reported more than 3,500 transactions per second in some configurations. Version 1.4 in January 2019 was the first long-term support release, and 1.4.1 brought Raft ordering. Fabric 2.0 (January 2020) made chaincode deployment itself a decision that several organisations approve, and 2.5 (March 2023) added purging of private data history.

Fabric was the platform behind many of the consortium projects of the late 2010s, including TradeLens, which IBM and Maersk launched in 2018 for container shipping and shut down in early 2023 after failing to bring in enough of the industry. Development carried on: Fabric 3.0 in September 2024 added a BFT orderer and dropped Kafka, Solo and the system channel, and in 2025 IBM Research contributed Fabric-X for high-volume digital assets.

Why it’s built this way

Execute, then order, then validate
Running contracts on a few endorsing peers before ordering lets them be written in ordinary languages, run in parallel, and stay hidden from organisations that don’t need to run them; conflicts are caught later by checking read versions.
Permissioned identities instead of mining
Members of a consortium are known legal entities, so the network can use certificates and signatures to decide who may act, and needs no proof of work or token to deter fake participants.
Pluggable ordering
Ordering is separate from execution, so the project could go from Kafka to Raft to SmartBFT without changing how contracts are written.
Channels for privacy
Businesses on one network often can’t share everything with each other, so each channel is its own ledger, and private data collections share only a hash where even a channel is too wide.

Timeline

  1. 2016

    IBM and Digital Asset contribute the code to the new Hyperledger Project

  2. 2017

    First Hyperledger project to reach Active status, in March; 1.0 on July 11

  3. 2018

    EuroSys paper describes the execute-order-validate design; IBM and Maersk launch TradeLens on Fabric

  4. 2019

    1.4, the first long-term support release, in January; Raft ordering in 1.4.1

  5. 2020

    2.0 adds decentralised chaincode governance in January

  6. 2023

    2.5 LTS in March; TradeLens goes offline

  7. 2024

    3.0 adds a SmartBFT ordering service in September

  8. 2026

    Fabric-X 1.0 on May 20; Fabric 3.1.5 on June 18

Sources12 · facts checked 28 October 2026

Improve this page on GitHub