High-Throughput Relix Mainnet
Relix mainnet is designed for modern, high-volume Web3 applications that cannot afford to slow down when real users show up. From the consensus layer down to fee markets and block production, the protocol is optimized to deliver high throughput, fast finality, and predictable transaction fees.
This page explains how Relix achieves that, and how to reason about throughput when building on top of it.
Finality in Seconds
On many legacy chains, developers need to wait for multiple block confirmations before they can safely treat a transaction as final. This adds latency to every user flow: deposits, swaps, mints, order placement, and more.
Relix is engineered to reach economic finality within seconds, so your application can:
Confirm deposits and swaps quickly
Reduce “pending” UI states and user anxiety
Shorten lifecycle flows like onboarding, bridging, or minting
From an integration perspective, this means:
You can generally treat a transaction as confirmed after a small number of blocks (depending on your risk tolerance and application type).
For UX, you can safely update UI state almost immediately after the transaction is included, without forcing users to wait through long confirmation chains on the client side.
Best practice: For most consumer applications, treating N recent blocks as final will be sufficient. For high-value flows (custody, CEX, institutional flows), you can configure your own internal confirmation policy.
Predictable Fees Under Load
Spikes in demand shouldn’t make your platform unusable.
Relix is designed to keep fees predictable and stable, even when network activity increases. This is achieved through:
Optimized gas accounting – predictable pricing for typical transactions
Efficient block space usage – more useful transactions per block
Protocol-level safeguards – to reduce fee volatility during short demand bursts
For developers, this means:
You can design business models (e.g. swaps, mints, in-game actions) without constantly recalibrating around unpredictable gas swings.
You can make more reliable assumptions when simulating user costs in your frontend or off-chain services.
You can pre-compute or estimate average fees for common actions and show them transparently in the UI.
Tip: When building price or fee estimators, use recent on-chain data (last X blocks) to model user-facing fee ranges. On Relix, those ranges are intentionally narrow, even during busy periods.
Optimized Block Production
Relix block production is tuned for real-world throughput, not just synthetic benchmarks.
Key design goals:
High transaction throughput – more transactions per second (TPS) at the protocol level
Low and stable block times – frequent blocks, with variance minimized
Resilience under heavy load – block production remains consistent even when the mempool is busy
In practice, this gives your application:
Smoother UX – less time spent in “Pending…” states in the wallet and UI
More responsive DeFi flows – order books, AMM swaps, and liquidations can react quickly
Better gaming/NFT performance – interactive apps that require frequent small transactions stay usable
From the node operator / infrastructure side:
Block producers are expected to maintain hardware and network bandwidth that match Relix recommendations.
Relix clients are optimized for efficient block propagation and fast execution of EVM transactions.
Building High-Throughput Applications on Relix
When you build on Relix mainnet, you can safely design for:
Real-time user interfaces
Live swaps, live order books, dashboards, and monitoring tools
Faster refresh cycles backed by the chain’s short block times
High-activity use cases
DEXes and aggregators
On-chain games and social protocols
NFT mints, claims, and reward systems
Backend services that rely on quick finality
Indexers, analytics pipelines, and bots that react to on-chain state in near real time
Oracles and off-chain automations that need deterministic behavior
Design guideline: Treat Relix as a high-performance L1. You can safely move more logic on-chain and rely less on fragile off-chain batching or delayed settlement strategies that were required on slower, high-fee networks.
Throughput Benchmarks
To make performance transparent, Relix provides a set of throughput benchmarks that simulate realistic usage patterns rather than only micro-benchmarks.
Benchmarks include, for example:
Baseline TPS under typical DeFi + NFT + wallet traffic
Stress TPS under high-load scenarios (bursts of swaps, mints, and transfers)
Average block time and its variance
Observed confirmation time to economic finality
Fee stability metrics across different load conditions
You can use these benchmarks to:
Validate that Relix meets the performance requirements of your application
Compare against other chains in terms of real-world throughput, not just peak lab numbers
Plan infrastructure cost and capacity (e.g. indexers, RPC services, and bots
Last updated