Technology

You can find the mainnet endpoint here.

Thanks to its novel architecture and features — including dynamic state sharding, and autoscaling — Shardeum can process transactions efficiently without congestion or resource strain. As a result, the network maintains consistently low fees (under $0.01), regardless of demand.

Because Shardeum can scale linearly by adding more shards as new nodes join, it avoids the fee spikes common in other blockchains. This ensures transaction costs remain stable, predictable, and accessible for everyone—permanently.

You can find the latest tutorials here. Advanced users can check our developer docs if needed.

Besides self-hosting, you can run your node using one-click setups, and VPS providers. However, please note that Shardeum does not endorse or take responsibility for any third-party services. Always Do Your Own Research (DYOR).

Following features are live on mainnet:

• Dynamic State Sharding
• Autoscaling
• Linear scaling
• Low transaction fees
• EVM compatibility
• Solid security
• True decentralization
• Immediate finality
• Low Latency
• Low Bandwidth
• High Fairness
• High Capacity

Smart contract functionality is scheduled for test deployment in Q2 of 2025, and live launch in Q3 of 2025.

Shardeum uses the Ethereum Virtual Machine (EVM), making it fully compatible with existing Ethereum-based developer tools. This makes it easy to migrate applications or build new ones on Shardeum—while benefiting from consistently low gas fees under $0.01, so developers and end users never have to worry about rising transaction costs again.

Here is the link to Shardeum whitepaper.

Shardeum’s consensus mechanism is Proof of Quorum (PoQ) while its sybil deterrence mechanism is Proof of Stake (PoS).

There will be 128 nodes in a shard. Most nodes in a shard (>64) would have to accept the tx to generate a PoQ receipt. Suppose a tx involves accounts A and B in shards 1 and 2. In that case, the nodes in these shards form a consensus group (256 nodes), and a majority (>128 since consensus group size is 256) is needed to agree on accepting the transaction.

The network ensures fair and unbiased selection of nodes for consensus and validation, without prioritizing or favoring any particular node. Shardeum is a permissionless network with a leaderless consensus mechanism.

Yes, Shardeum’s source code is open-sourced after we completed defensive patent filings for innovations in our protocol, including the consensus algorithm, autoscaling, and dynamic state sharding, in 2024.

Explore all our projects, contribute to their development, and use the Shardeum protocol to build scalable Web3 applications.

In simple words, sharding breaks the job of validating and confirming transactions into small and manageable bits, or shards. While sharding is ultimately the best way to tackle the scalability issue, applying it to blockchain-based networks is not nearly as easy as applying it to centralized databases.

The good news with Shardeum is that the consensus and processing are done at the transaction level and not at the block level. And, through dynamic state sharding, the network will shard its state by evenly and dynamically distributing compute workload, storage, and bandwidth among all the nodes. This not only allows for parallel processing of transactions but also very low storage requirements for validator nodes as they will store only the state data of transactions/accounts they are involved in.

The protocol assigns each node to cover one or more unique address ranges in such a way that for any given address there is a well defined number of nodes holding the data for that address. Each node added to the network allows other nodes to slightly reduce the total addresses they cover while still ensuring that any given address has the specified level of redundancy.

And why are they important? Well, this is how Shardeum will get to maintain low transaction fees for developers and end users forever. Dynamic state sharding helps the network to scale linearly making it the first Web3 network to do so.

Autoscaling in Shardeum means the network can automatically adjust its capacity in response to demand by leveraging dynamic state sharding. When more validator nodes join the network, new shards are added to distribute the load, allowing throughput (TPS) to scale linearly with the number of nodes.

Unlike most blockchain networks, where fixed block sizes and conflicting resource constraints limit scalability, Shardeum’s architecture resolves this by allowing the protocol to self-govern node participation. This ensures optimal network size, improved resource utilization, and consistent performance—without needing manual intervention.

By aligning node incentives with network requirements, Shardeum ensures that autoscaling is a built-in protocol capability that directly benefits end users through low latency, low fees, and high throughput.

With the help of dynamic state sharding, every node added to the network will increase the transaction throughput instantly. By simply adding more nodes from the network’s ‘standby nodes’ set during peak demand, the TPS will increase proportionally making Shardeum the first Web3 network to scale linearly. And this is the main X factor that impacts every other outcome on a blockchain network favorably including throughput, decentralization, security, and low transaction fees irrespective of the demand in the network.

High fairness means that a transaction received by the network earlier than another one should be processed accordingly.

In a blockchain-based network, transactions within a block are considered to have occurred simultaneously, and the order in which they are applied does not matter. For some applications like games, this does not provide sufficient time resolution. Also, it is possible for transactions that were received much later to be processed before earlier transactions. In most networks, you can get priority by paying more gas fees.

Shardeum processes transactions in the order received preventing MEV,  and ultimately bad user experience.

Shardus handles the protocol layer of Shardeum, including gossip of transactions, consensus, syncing, and sharding. Developers can start with Shardeum’s protocol layer and define the application layer to easily build decentralized applications. The protocol hides the sharding aspect from the application layer.

And how it works at a high level is, on Shardeum, transactions are processed on a FCFS basis individually. That means consensus happens at the transaction level and not at the block level as you see with typical blockchains. Processed transactions are then grouped together and passed onto archive nodes on the network. The protocol layer takes care of cross-shard consensus and data sharing. Shardeum will ensure complex transactions are executed effectively and parallelly in a sharded environment while maintaining the integrity and consistency of the blockchain. In other words, Shardeum will have atomic and cross-shard composability making life easier for developers.

First of all, Shardeum scales linearly. On Shardeum, transactions are ordered in a time based way i.e. FCFS basis, followed by consensus and processing done at the transaction level instead of the block level as you see with typical blockchains. And through dynamic state sharding, the network will shard its state by evenly and dynamically distributing compute workload, storage, and bandwidth among all the nodes. Every node on the network will be assigned dynamic account spaces across multiple shards with sufficient level of overlaps between address ranges. This allows for parallel processing of transactions while maintaining atomic and cross shard composability.

Further, validator nodes will store only the state data of transactions/accounts they are involved in while the individually processed transactions are grouped and passed onto archive nodes on the network. Archive nodes will be responsible to store historical data. Low overhead for validators translates to the network scaling horizontally with low gas fees forever. Autoscaling will enable Shardeum to make efficient use of resources and the consensus mechanism will ensure active nodes/validators are auto-rotated with standby nodes asides from ensuring validity of transactions with immediate finality and low latency.

Ultimately, linear scaling is the main X factor that impacts every other outcome on a blockchain network favorably including throughput, decentralization, security, and constant transaction fees irrespective of the demand in the network. Shardeum is proving that scaling linearly (through sharding) combined with an optimal consensus algorithm, transaction ordering, and autoscaling, can help you in overcoming scalability trilemma. Moreover, we are pleased to inform you that Shardeum’s codebase is open sourced. Asides from staying true to our ethos of decentralization, we are open-sourcing to inspire other blockchain networks to overcome the scalability issues and start onboarding the world to Web3.

High throughput means that the network should process a vast number of transactions per second (TPS).

Unlike traditional blockchains that process transactions sequentially, Shardeum handles them concurrently across shards, enabling significantly higher TPS while maintaining low latency and fees.

Shardeum achieves high throughput by using dynamic state sharding—a technique that splits the network into multiple shards, each capable of processing transactions in parallel. As more nodes join the network, Shardeum automatically adds new shards, allowing the network to scale linearly without compromising decentralization or security. Scaling up with each new node is a first in the blockchain industry.

High capacity refers to the ability of a blockchain to persistently store and manage vast amounts of state data—potentially reaching exabyte-scale as global adoption grows. Most current blockchains have not been stress-tested at this scale and often rely on limited state storage per node.

Shardeum addresses this by using dynamic state sharding, which not only increases transaction throughput but also distributes state data across multiple shards. This means the network can scale its storage capacity in tandem with the number of participating nodes.

By scaling horizontally (i.e., adding more nodes and shards), Shardeum avoids the bottlenecks of monolithic chains and ensures the protocol can support high-volume applications such as global financial platforms, social networks, and enterprise-grade systems—without compromising performance or decentralization.

Low latency means the total turnaround time between submitting a valid transaction to the network and knowing that the network has committed to the transaction in a short period of time. In networks like Bitcoin, latency is the time between submitting the transaction and including it in a block. For such networks, the fastest latency is no less than the average block production time which is around 10 minutes.

Shardeum achieves low latency—processing each transaction within seconds—by handling them individually before bundling them into blocks.

Fast finality means having a quick turnaround time between submitting a transaction to the network and knowing that the transaction is irreversible.

In networks like Bitcoin, there is a probabilistic finality time. The longer you wait, the lower the chance that a transaction confirmed in a block cannot be reversed. Thus, the finality time is not just for the transaction being included in a block. Still, some blocks are being produced after that to reduce the probability of the transaction being reversed. For large value transfers on the Bitcoin network, it is recommended to wait for at least six blocks (about an hour) to ensure irreversibility.

Shardeum’s immediate finality sets it apart from other blockchains, which offer probabilistic or absolute finality. It is further a breakthrough in blockchain technology, as it provides finality without the need to wait for multiple blocks to be confirmed.

Low bandwidth means that the network should minimize the amount of data transfer needed when distributing transactions and achieving consensus.

This does not imply just compressing the data or using binary formats; instead, the more critical factors are network architecture and algorithmic details of the consensus algorithm. In Bitcoin-like networks, adding more nodes increases the amount of bandwidth used to process each transaction.

On Shardeum, the amount of bandwidth consumed by a transaction is constant and does not increase proportionally to the number of nodes.

Energy efficiency means the consensus algorithm used by the network should not require excessive energy beyond what is necessary to process the transactions. Bitcoin and other networks based on the Nakamoto consensus are designed to use high energy expenditure to secure the network from a 51% attack. However, efficient consensus algorithms such as Paxos and PBFT do not require high energy expenditure. The tradeoff is that these algorithms need the nodes to be assigned a node ID before joining the network. Thus, these algorithms have been used in permissioned networks and not for nodes that can participate without requiring a node ID.

Shardeum uses an energy-efficient consensus algorithm that lets any node join the network by permissionlessly obtaining a node ID—without requiring selection or approval from any centralized authority.

It doesn’t quite fit into any of these types. Shardeum’s protocol does consensus on each transaction independently without putting them into blocks. However, to maintain compatibility with the EVM ecosystem, transactions are periodically grouped into blocks—making it functionally a blockchain for interoperability purposes. A proof-of-quorum receipt is generated for each transaction to show if it was accepted or not. The processed transactions are grouped into blocks and passed on to archive nodes. This allows the consensus nodes not to have to deal with storing the transaction history and only maintain the current state of the accounts. Once you’ve done the consensus for the transactions, the data structure you use to store them does not matter. It matters for other networks because the data structure is tightly coupled with the consensus.

Blockchains have intrinsic scalability limitations due to their block-based architecture. Bitcoin bundles transactions into blocks, which are then further constricted by block size and block rate. Ethereum blocks are also constrained by block rate and their block size is indirectly limited by a parameter known as the “gas limit” as each block has a gas limit that dictates the amount of computational work that can be included in the block. Moreover, grouping transactions into blocks makes it impossible to route a particular transaction to just the set of nodes that need the transaction. A node would also receive other transactions in the block which it should not process. Processing transactions without grouping them into blocks works better for sharded networks; however, each transaction needs to be consensed upon individually on Shardeum. It is more efficient to do consensus on a block of transactions than on each individual transaction. This adds more processing to each transaction and at first would seem to slow down the transaction processing rate. Although this is true for a network that is not sharded, for a network with many shards, the level of parallel processing allowed by this approach achieves a much higher transaction processing rate eventually.

Data sharding has long been part of Ethereum’s scalability roadmap, primarily intended to improve data availability — enabling multiple Layer 2 (L2) solutions to post data to the Ethereum network simultaneously. The focus has been on data sharding, not full execution or network sharding, which would be required for true state sharding and deeper scalability at the base layer. However, Ethereum has since evolved its strategy. Rather than pursuing traditional sharding, which is difficult to implement on a mature and complex network, Ethereum has shifted toward Danksharding — a more practical design focused on scaling data throughput through innovations like blobs introduced in Proto-Danksharding.

Shardeum shards compute, state and data to achieve dynamic state sharding. By assigning each node to a unique range of addresses Shardeum has demonstrated true linear scaling. Shardeum is the first L1 to increase TPS with each node added to the network while retaining cross-shard composability. Shardeum’s novel architecture overcomes the challenges faced by existing sharded blockchains while providing a preferred horizontal approach to scaling rather than L2’s and other scaling methods, which use more powerful nodes and hardware to scale vertically.

​EVM-based languages – Solidity and Vyper.

Node.js + TypeScript + Rust