Blog | LF Decentralized Trust

Meet Chaguar: High-Performance Ledger Infrastructure for Every Application Stack

A New LFDT project contributed by IBM Research and supported by Sign.Global and Kaleido 

Today we’re excited to introduce the LF Decentralized Trust project Chaguar: a distributed ledger technology that unlocks the full spectrum of the digital assets vision. Chaguar brings today’s most popular programming models together on one shared ledger at unprecedented scale, preserving security, speed, and transparency as we move into the post-quantum era.

The name is the design brief. Chaguar has the speed of a jaguar, adapts to new programming models like a chameleon, and takes its resilience from the chaguar, the hardy Gran Chaco plant whose fibers are woven into cloth that lasts. Five properties set it apart:

  • Speed at horizontal scale. Execution scales horizontally as the resources of the system participants grow, reaching 400,000 transactions per second (TPS) with 0.5 seconds latency under full Byzantine fault tolerance.
  • Programming-model agnosticism. Chaguar separates business logic execution from performance-critical consensus and ledger update operations, allowing for modular integration of various programming models/stacks, and interoperability mechanisms.
  • Execution sovereignty. Each application decides who governs its smart contracts, including what is being executed, and where (i.e., in which jurisdiction or infrastructure).
  • A wide spectrum of privacy-enhancing mechanisms. Trusted hardware, expensive zero-knowledge proofs and multi-party computation are all made feasible by Chaguar's horizontal scalability and execution sovereignty.
  • Composability across trust domains or programming stacks. EVM/SVM contracts, interactive programming models, privacy layers and token frameworks share one ledger and settlement layer.

Let’s look closer into the why and the how ☺

1. The question changes as the market matures

Tokenized deposits, regulated stablecoins, central bank digital currencies, and on-chain securities have all left the lab. Permissioned ledgers on Besu and Hyperledger Fabric, federated ledgers synchronized through Daml and Canton, and public networks like Ethereum and Solana are all becoming core market infrastructure.

So the industry is no longer asking whether a DLT can handle a digital asset. It is asking whether one ledger can carry a whole ecosystem of them, privately and in compliance. That means many institutions, applications and asset classes on common settlement rails, with people, corporations, and AI agents submitting transactions at very different paces. 

The foundation is not up for negotiation. Many parties build one shared ledger, and Byzantine fault tolerant (BFT) consensus makes it immutable: nobody can rewrite history, and everyone sees the same thing. Regulated markets cannot trade away resilience, governance, or auditability.

That promise has been expensive to keep as network participation and transaction loads grow. BFT consensus across independent organizations is costly, and conventional DLTs serving institutional needs typically top out around 1,000 transactions per second (TPS). Privacy adds its own bill: the models built on advanced cryptography are still held back by computational cost and performance overhead.

Chaguar's goal is to keep every one of those guarantees and remove the ceiling.

Figure 1. Overview of Chaguar's three transaction processing phases: execute - order- validate. The execute phase executes smart contracts, assuming a variety of programming models. The second runs high-performance BFT consensus to order executed transactions, while validate runs highly parallelizable validation process. Finally, a shared immutablele ledger is composed, with transcations staying within or speading across trust domains. Migration of Besu smart contracts and ledger state to Chaguar, as well a connection of Paladin and Daml/SVM programming models with Chaguar is work in progress.

2. Why speed matters now

A shared ledger has to carry far more than any single application asks of it, and five pressures are arriving at once.

Consolidation. DLT initiatives increasingly bring many applications onto one ledger, and that ledger has to meet all of their performance needs at once.

Cross-domain operations. Many operations span applications, trust domains, or jurisdictions. A cross-border payment is one example: depending on the payment path, it moves money through several payment systems and ledgers. One such payment results in 2 to n + 2 ledger transactions, where n is the number of hops in the path. A five-hop payment results in roughly seven ledger transactions, so a 1,000 TPS ledger settles about 140 payments per second. The same capacity still has to serve every domestic application on that ledger.

Agentic payments. As AI agents buy, sell and settle on our behalf, payments become a continuous machine-to-machine stream: small, around the clock, and bursty when thousands of agents react to the same signal. Ledgers built for human-paced activity were not designed for that volume.

Expensive privacy operations. Privacy is mandatory for regulated assets. Whichever way a ledger provides it, whether through trusted hardware, zero-knowledge proofs, or multi-party computation, it adds computation to every transaction, and that overhead comes out of the performance of the whole system.

Post-quantum cryptography. Post-quantum signatures are tens to hundreds of times larger than today's. A payment instruction can grow by up to two orders of magnitude, and consensus throughput on a conventional ledger falls by as much. In the cross-border example above, such a ledger would crawl along at around two payments per second.

Conventional DLTs cannot meet these pressures by adding capacity because their limit is architectural. In most designs every validating node re-executes every transaction, in sequence, as part of reaching agreement. Full transaction payloads travel through the consensus protocol. Execution, ordering, and validation are single-node processes. Adding nodes therefore adds redundancy, not throughput: the network runs at the pace of a single node, and each new participant makes consensus more expensive.

To summarize, speed is not a luxury. It is the headroom that keeps a ledger useful as applications, payment paths, and cryptography all get heavier, and it has to come from an architecture that scales horizontally.

3. Why programming-model agnosticism matters

It is very likely that no single programming model is going to win, and a ledger should not bet on one. AI is accelerating how software gets written, programming models evolve faster than ever, and porting an application to a new stack now takes a fraction of the time it used to. Institutions should not have to rebuild their ledger infrastructure every time that happens.

Different stacks are also good at different things:

  • Traditional, general-purpose languages bring hardened cryptographic libraries and decades of compiler and runtime optimization, as well as a higher degree of flexibility in operations supported.
  • Solidity and other DLT-native languages make many contracts simple to write, backed by a vast developer community, mature tooling, and well understood patterns for digital assets.
  • Stacks enabling interactions across parties and off-chain communication, (e.g., Fabric Smart Client {referred to as Go Views} or Corda Flows) come with their own advantages in representing traditional business flows.
  • Programming models and languages still to come will bring optimizations nobody can predict yet.

Most ledgers wire one virtual machine into consensus, so choosing a ledger means choosing a language/programming model, a toolchain, and a talent pool for years. The ideal ledger treats its execution engine as pluggable: something to leverage as needed, swap, and extend while the ledger itself stays put. 

4. The privacy challenge, and why composability

Privacy on shared ledgers is only partly solved. Some models are settled. Those built on advanced cryptography, such as zero-knowledge proofs and multi-party computation, promise stronger guarantees but are still looking for their way to adoption, held back by computational cost.

On most ledgers, every validating node pays that cost inside the critical path, so one application's privacy choice becomes everyone's performance problem. In addition, a ledger conventionally tends to ship with one privacy model, while different use cases (e.g., a retail payment, a wholesale settlement and a securities trade) come with different trust models and privacy optimizations.

Given the above, and the fact that financial workflows cross boundaries, composability becomes crucial. Delivery versus payment joins a securities application to a cash application, and payment versus payment joins two currencies. If every programming model and every privacy mechanism needs a ledger of its own, the result is thousands of isolated ledgers stitched together by bridges.

A shared ledger has to let different stacks and privacy mechanisms coexist and settle against each other atomically. It has to do so without asking any institution to give up control of its own contracts, data, privacy mechanisms, and standards.

5. How Chaguar works

Chaguar separates smart contract execution from consensus and from ledger updates. Where a conventional node executes, orders, and stores everything in one process, Chaguar splits the work into three stages. Each stage is a set of independent services that scales on its own, and a transaction passes through them in order.

Figure 2. Chaguar architecture: clients, endorser groups with gateways, ordering, committers. Endorsers individually or jointly execute smart contracts, sign execution results, and promote the latter to the consensus nodes. Consensus nodes order signed execution results using Arma and deliver blocks of transaction to the committers of the system, which check signatures and referenced state freshness, ultimately committing ledger state changes accordingly. 

Stage 1: Execute. A client sends a transaction proposal to the endorsers named in the application's policy. The endorsers run the smart contract against the current ledger state and then record what it reads and what it intends to write. Each endorser signs that read-write set, and the client assembles the signatures into a transaction. Nothing has touched consensus yet, so execution stays off the critical path. It can take the time it needs, call a zero-knowledge prover, or wait on an external system without holding up the ledger.

Stage 2: Order. The ordering service, based on the Arma protocol (see Androulaki et al., 2026; Sec. 4), splits the job of a classic BFT orderer into parts. Routers validate incoming transactions and spread them across shards. Within each shard, batchers group transactions into batches and disseminate them to all parties. Consensus nodes then run BFT agreement over compact digests of those batches, never over the payloads. Assemblers combine the agreed order with the stored batches and emit blocks. Dissemination scales with the number of shards, and consensus carries only a few bytes per batch, so consensus bandwidth stops being the bottleneck.

Stage 3: Validate. Committers receive the ordered blocks and validate them as a pipeline of services. Signature verifiers check each transaction's endorsements against its namespace policy, in parallel. A coordinator builds a dependency graph over the read-write sets, so transactions that touch different keys proceed concurrently and only real conflicts wait for each other. Validators then confirm that every value transaction read is still current before writing it to a distributed database using a two-phase commit. A transaction that reads stale state is marked invalid and changes nothing. Every committer reaches the same verdict for every transaction. Reads take a separate path. Endorsers and clients query committed state through a dedicated query service, so read load scales independently of the commit pipeline.

The Chaguar core (Order and Validate) never runs application code. It checks who signed a state change and whether that change conflicts with another one. Three things follow from that. Throughput is bounded by signature checks and key-value writes, which parallelize well, and never by the slowest contract on the network. Each stage can be sized, upgraded, and operated independently. And the ledger is indifferent to how a read-write set was produced, which is where the properties below come from.

6. How Chaguar delivers on all fronts

Performance. Chaguar reaches 400,000 TPS with eight ordering shards at around 500 ms latency. It gets there by scaling execution horizontally: each application adds endorsers for its own load, more shards raise ordering throughput, and more committers raise validation throughput. That is the range of centralized payment and trading systems, delivered under BFT consensus across independent organizations.

Figure 3. Performance evaluation of Chaguar core

Programming-model agnosticism. Chaguar's only contract with an application is a signed read-write set. Any runtime that produces one can serve as an execution engine, and several are available or on the way:

Programming model /
app stack

What it brings

Status

EVM

Unmodified Solidity bytecode on a standard EVM behind an Ethereum-compatible JSON-RPC gateway, so existing wallets, SDKs, and testing frameworks work as they are

Available

Go Views

Applications in general-purpose languages using Corda-style flows, free of the determinism constraints smart contracts usually face

Available

SVM and others

Further execution engines for more developer communities

Work in Progress

Paladin

Programming model for privacy-preserving applications and EVM ledgers

Work in Progress

Panurus

Token infrastructure with privacy levels from cleartext to zero-knowledge, plus auditor support

Available

Privacy. Chaguar does not prescribe a privacy model. Heavy cryptography runs at endorsement, in a horizontally scalable manner and before ordering, on capacity the application sizes for itself. The commit path checks signatures and state dependencies only, so one application's privacy choice never slows its neighbors. Trusted hardware, multi-party computation (including privacy groups) and even expensive zero-knowledge proofs become practical, and several mechanisms can run side by side.

Composability and sovereignty. Each application lives in its own namespace, governed by its own endorsement policy, which the committers enforce on every transaction. The application decides who runs and governs its smart contracts and on which infrastructure, and the rest of the network sees only the signed result. All namespaces share one ledger and one settlement layer. Because execution happens before ordering, endorsers can also call external systems or other smart contract’s endorsers, DLTs and oracles, which opens the door to atomic delivery versus payment and payment versus payment across platforms.

7. What comes next

Paladin connectivity. Many strategic institutional ledger initiatives already build on Paladin's privacy layers. Connecting Paladin with Chaguar lets those initiatives bring their privacy model and applications with them, and gain throughput and resilience along the way.

Besu migration option. Many institutional ledgers in production today run on Besu. With fabric-x-evm, their Solidity contracts can run unmodified on Chaguar behind an Ethereum-compatible JSON-RPC gateway, so existing wallets, SDKs and tooling can carry over. This e migration path also covers the ledger itself: the state built up on the Besu ledger moves to Chaguar’s, so migrated contracts pick up the balances and records they already hold and do not restart from an empty ledger. Those networks keep their applications, their state, and their developer experience and gain throughput, resilience, and per-application sovereignty along the way.

Chaguar version 1.1. features. Chaguar is already in version 1.0, offering high throughput transaction processing and byzantine fault tolerance across the transaction processing stages. Chaguar offers crash fault tolerance across the individual orderer and committer service components, and ability to reconfigure ordering service manually. Chaguar’s post v1.0 core roadmap runs from storage efficiency to an optimized quantum-safe architecture and includes advance checkpointing and pruning capabilities.

When

Milestone

Q4 2026

Committer storage optimization (snapshot, checkpointing, and pruning)

Q1 2027

Post Quantum Cryptography (PQC) Integration

Q2 2027

Full-stack (orderer and committer) storage optimization (snapshot, checkpointing, and pruning)

Q4 2027

Optimized architecture for high throughput using PQC

8. Where Chaguar comes from

Chaguar is not starting from scratch. It is the codebase previously known as Fabric-X, developed under the Hyperledger Fabric project at LF Decentralized Trust. However, its programming-model agnosticism puts it on its own development and adoption path. It is, therefore, time for the project to have a home of its own.

Chaguar is based on research and development work by the decentralized trust team at IBM Research, proven experts in the fields of applied cryptography, system security, and distributed systems. Members of the team co-designed the original Hyperledger Fabric architecture as well as the interactive client-based programming model on top of Fabric (aka Fabric smart client).

Among other protocols, the team invented Fabric Token SDK cryptography suites, now in the LFDT project Panurus. That technology is a key component in the digital currency systems of various central banks and commercial banks/financial institutions, including ECB’s project Pontes, which recently entered its pilot phase.

Chaguar’s architecture and its performance evaluation are described in Fabric-X: Scaling Hyperledger Fabric for Asset Exchange, published at SIGMOD 2026. The Arma consensus protocol is described in Section 4 therein.

9. Come build with us

We believe the future of digital assets is not thousands of isolated ledgers. It is shared infrastructure that supports many asset classes, institutions, and programming models. Chaguar is being built as that foundation.

Chaguar is open source, and we would love your help shaping where it goes. Join the conversation on LFDT Discord and follow along on LFDT's GitHub.