500,000 TPS. Sustained.
Scalability without compromise.
On January 31, 2026, over 590 community nodes sustained more than half a million real DeFi transactions per second, while preserving atomic composability across 128 shards. Not a simulation: a public, reproducible test on commodity hardware.
Card-network throughput.
Settlement finality in seconds.
Banks can settle tokenized deposits, RWAs and CBDCs with guaranteed atomic Delivery-versus-Payment at internet scale. No partial executions, no counterparty risk, and capacity headroom far beyond global card networks - even at peak volume.
Machines paying machines.
The settlement layer for the agent economy.
AI agents with their own wallets, paying per query through x402 micropayments and transacting with each other millions of times per second. Linear scalability is the only architecture that can settle machine-to-machine volume without fee auctions pricing it out.
Adaptive Sharding and Linear Scalability: The network dynamically activates new shards on demand. The more shards operating in parallel, the higher the total throughput (TPS), always preserving atomic composability in the central consensus.
Half a million TPS,
verified in public
The final Hyperscale public test - January 31, 2026 - closed the interim phase with results anyone can reproduce. Real DeFi swap transactions, community hardware, and atomicity preserved on every single transaction.
Linear scaling, confirmed
Doubling the shard count doubled the throughput - the defining prediction of the architecture. Per-shard performance stayed constant as the network grew.
Real transactions, not transfers
The workload used cross-shard atomic DeFi swaps - the hardest transaction class - rather than simplified token transfers that inflate benchmark numbers.
Commodity hardware
Validators ran on 4-core, 16 GB machines. Community participants joined from datacenter servers and ordinary desktop laptops alike - no specialized hardware required.
Consensus was not the bottleneck
The limiting factor was generating transactions fast enough to feed the network. The consensus layer itself still had headroom.
Open and reproducible
Code, tooling, logs and documentation were published in February 2026 so results can be independently verified - closing the Foundation's interim phase.
From Cerberus research
to Xi'an engineering
A decade of consensus research, validated in public at scale, now being rebuilt as production software by the community. These are the pieces and how they fit together.
One goal, two generations of design
Cerberus (peer-reviewed in 2020) and the 2026 Hyperscale test validated the goal: linear scalability with cross-shard atomicity. Xi'an is a clean-room Rust rewrite - hyperscale-rs - that pursues the same guarantees with a new consensus design: HotStuff-2 shard chains coordinated by the POLARIS leaderless beacon chain. Metrics from earlier prototypes should not be attributed to Xi'an, and vice versa.
Explore the technology in depth at hyperscale.rsCerberus consensus
Braided BFT consensus across a 2²⁵⁶ shard space: only the shards touched by a transaction take part in its consensus, so unrelated transactions never queue behind each other.
POLARIS - leaderless BFT
A prefix-consensus protocol with formally proven censorship resistance (arXiv:2602.02892). No leader means no single point of censorship - committees are drawn by BLS-backed verifiable randomness.
Adaptive sharding
Shards split under load and merge when demand drops - without halting the network. In-flight work is handed to child shards at a certified boundary. First cut completed in June 2026.
Unified global Merkle trie
All state lives in one global Jellyfish Merkle Tree; each shard owns a prefix subtree. Splits and merges are logical operations - no data migration, no reindexing, no downtime.
Radix Engine + Scrypto
Asset-oriented execution where tokens are protocol-native objects that cannot be duplicated or lost. The engine and the Scrypto developer experience carry over intact to the sharded network.
Home-validator economics
Every node has equal consensus weight; stake buys nodes, not votes. A 50 Mbps home connection is enough, penalties are jailing rather than slashing, and post-quantum cryptography is designed in from the start.
How a cross-shard transaction commits
Shards do not trust each other - they independently execute and compare results. A malicious shard cannot corrupt state without a supermajority of every other involved shard.
Declare
The transaction declares upfront which substates it reads and writes, so the shards it touches are known deterministically - no routing table, no coordinator.
Lock
Each involved shard commits the transaction and locks the relevant substates, preventing conflicting access until the outcome is decided.
Execute everywhere
Shards share the locked substates with each other, then each one independently executes the full transaction with identical inputs.
Exchange certificates
Each shard votes locally on the result and produces an execution certificate. Certificates are exchanged between all involved shards.
Commit - or fail cleanly
If every shard reached the same outcome, a transaction certificate commits the results atomically. Any disagreement means no certificate, no commit: the transaction fails cleanly, with no partial state.
Scale that solves
real settlement problems
Tokenized deposits, RWAs and CBDCs only work if the underlying ledger can absorb the volume of real payment systems - without ever splitting a trade into a paid leg and an undelivered one.
Atomic DvP at market scale
Payment and delivery settle as one indivisible event, even when cash and asset live on different shards. At 500,000 TPS the guarantee is identical to a single transaction: full settlement or full revert. Counterparty risk is not reduced - it is eliminated.
Headroom beyond card networks
Global card networks peak at roughly 65,000 transactions per second. The 2026 public test sustained over seven times that with real swaps - and capacity grows linearly by adding shards, so tokenized deposit and CBDC volumes never compete for space.
Deterministic execution for compliance
Transaction manifests declare their outcome before execution: readable by risk teams, auditable by regulators, immune to blind signing. Under load there are no fee auctions that price payments out or reorder them unpredictably.
Resilience measured in decades
Thousands of independent validators on commodity hardware, graceful degradation if a shard loses liveness, and a post-quantum cryptography path designed into the architecture - infrastructure lifecycles that match banking horizons.
Built for transactions
between machines
When AI agents pay per query, per dataset and per API call, transaction volume stops looking like crypto trading and starts looking like HTTP traffic. That is the scale Hyperscale is designed for.
x402: HTTP-native micropayments
The 'Payment Required' status code, finally implemented: AI pays content and data sources automatically at the moment of access, a fraction of a cent at a time. The standard is driven by Coinbase and the Linux Foundation, with Cloudflare backing and an implementation already running on Radix.
Agents with their own wallets
AI Ventures runs live on the Radix testnet: AI agents acting as employees of on-chain companies, with their own wallets, spending limits and on-chain accountability. The application layer is assembling before the scaling layer ships.
A ledger agents can read
Through the Model Context Protocol, AI agents query the Radix ledger directly - balances, transactions, on-chain state - without a human intermediary or a custom integration per model.
Intent that machines can trust
Transaction manifests declare outcomes upfront and execute atomically: no blind signing, no sandwich attacks, no ambiguity. Autonomous agents need deterministic results - exactly what asset-oriented atomic transactions provide.
“If you want to build a layer 1 blockchain that can support 100 million transactions per second - call us.”
Cloudflare handles around 500 million requests per second. No fixed-capacity chain can meet that bar - only an architecture that adds throughput by adding shards can grow toward it.
The road to Xi'an,
milestone by milestone
Hyperscale validated the science in public; Xi'an turns it into a production network. Development is community-led, open source and funded per delivered milestone.
Already achieved
Final public test
500,000+ sustained TPS across 590+ community nodes and 128 shards - with real cross-shard swaps and linear scaling confirmed.
Interim phase concluded
Code, tooling, logs and documentation published for independent reproduction, formally closing the Foundation-led phase.
Community RFC for Xi'an
Proposal to deliver the production network: six milestones, ~$300k in XRD plus a 50M XRD mainnet bonus. The Foundation shifts to a community-led model.
Milestone 1 underway, ahead of schedule
Community vote approved funding. POLARIS beacon chain integrated, and the first cut of live shard splitting and merging completed in June 2026.
Xi'an delivery milestones
Adaptive sharding
In progressLive resharding, validator shuffling, snap-sync and the POLARIS leaderless beacon chain.
Radix Engine integration
PlannedFull Scrypto execution on the sharded network: transaction manifests, WASM execution and cross-shard fee collection.
Gateway & Wallet
PlannedRust gateway rewrite and Radix Wallet connectivity - the first normal-user interaction with Xi'an.
Public testnet + home validators
PlannedAnyone can run a node: public Stokenet, explorer and a home-validator GUI. The network becomes touchable.
Mainnet ready
PlannedMigration tooling, post-quantum primitives, dry-run migrations and an audit-ready codebase.
Dates are community estimates from the Xi'an proposal; funding is released per delivered milestone, so the schedule can shift with scope.
Don't trust the numbers.
Verify them.
Everything - code, research, test logs - is public. The scalability claims on this page can be checked against the repositories and papers below.
To understand how the technology works in depth and dig into its operation, architecture and protocols, visit hyperscale.rs
The Xi'an codebase is Apache 2.0 licensed - a community asset, independently auditable by any institution or researcher.
Run a node,
join the next public test
Hyperscale's public tests are carried by the community: anyone with a commodity machine can spin up a node, contribute real throughput and watch it on the live scoreboard. That is how 590+ nodes reached half a million TPS.
Public test status
- Last public testJanuary 31, 2026
- Throughput reached500,000+ sustained TPS
- Community nodes590+ on commodity hardware
- Next public testTo be announced on radixlabs.net
Minimum node requirements
- 4-core CPU
- 16 GB RAM
- SATA SSD
- 10 Mbps down / 5 Mbps up, wired
How to take part
Install OpenJDK 21
Java 21 is the only software requirement. Linux: sudo apt install openjdk-21-jdk. macOS: brew install openjdk@21. Windows: the official Oracle JDK 21 installer.
Download the node files
Get hyperscale.jar and default.config from the Radix Hyperscale Telegram channel and place them in a folder named Hyperscale.
Open the ports
Forward port 8080 TCP and port 30000 TCP/UDP on your router to your machine and allow them through the firewall. Disable any VPN during the test.
Start the node
From the Hyperscale folder run the command below. In the console you get ledger, network and network -stats to monitor it.
Join and watch
Track your node at http://localhost:8080/dashboard/index.html and register at radixlabs.net to join the test on the announced date.
Linux (Ubuntu/Debian)
macOS
Run Hyperscale
The permanent public testnet, with a home-validator GUI, arrives with Xi'an Milestone 4 (est. 2027). Until then, tests are coordinated per event through radixlabs.net and the Radix Hyperscale Telegram channel.
Scale is no longer
the bottleneck.
Whether you settle tokenized assets for a bank or build agents that pay per query - the architecture that absorbs both is being built in the open, today.