How does Sei run a parallel EVM? · Jumpstart Blockchain
How does Sei run a parallel EVM?
Sei executes a block's transactions in parallel, tracks what each one read and wrote, and re-executes any that conflict, so results match serial order. Contracts need no changes, but shared hot storage slots still serialize.
The Ethereum Virtual Machine was designed to run transactions one at a time, in block order. Sei runs the same EVM bytecode but executes a block's transactions in parallel, without asking developers to declare which state each transaction touches. It does this optimistically: run everything at once, record what each transaction read and wrote, detect the ones that collided, and re-execute those. The final state is exactly what sequential execution would have produced, so contracts behave as they would on Ethereum, just with more throughput and blocks that arrive in a few hundred milliseconds.
Optimistic parallel execution
Parallel execution is hard because transactions share state. If two transfers both debit the same account, running them simultaneously against the same starting balance produces the wrong answer. There are two broad ways to handle this:
Approach
How conflicts are avoided
Used by
Declared access
Each transaction lists the state it will touch up front, and the scheduler only runs non-overlapping ones together
Solana, Sui (owned objects), Sei v1
Optimistic
Run everything in parallel, track actual reads and writes, re-execute on conflict
Aptos Block-STM, Sei v2, Monad
Sei v1 used declared dependencies for its Cosmos modules and CosmWasm contracts. That doesn't work for the EVM, where a contract can compute storage keys at runtime and call other contracts dynamically. So Sei v2 switched to optimistic concurrency control. Per block, it works roughly like this:
Execute in parallel. Every transaction runs concurrently against a multi-version view of state. Each one records a read set (keys and the versions it read) and a write set (keys it wrote), without committing anything.
Validate in block order. For each transaction, check whether any key in its read set was written by a transaction earlier in the block. If not, its result is valid.
Re-execute conflicts. Transactions that read stale data run again against the updated values, and validation repeats until everything is consistent.
Write sets are applied in block order.
Commit.
Because validation follows block order, the outcome is deterministic and identical to running the block serially. Every validator reaches the same state root. Parallelism is an implementation detail of the node, not a change to EVM semantics.
The speedup depends on the workload. Transfers between unrelated accounts and trades on different pools run fully in parallel. Transactions that all write the same storage slot have to happen one after another, whatever the scheduler does.
Twin Turbo consensus
Execution speed is wasted if consensus is slow, so Sei also modified its Tendermint-derived BFT consensus. Sei calls the result Twin Turbo:
Intelligent block propagation. Validators already hold most pending transactions in their mempools. The proposer sends a compact block of transaction hashes, and validators rebuild the full block locally, fetching only the transactions they're missing. That cuts the data sent on the critical path.
Optimistic block processing. Validators start executing a proposed block while the prevote and precommit rounds are still in progress, instead of waiting for it to be finalized. If the block is committed, the work is already done. If not, it's thrown away.
Blocks are produced and finalized in roughly 400 milliseconds. Finality is deterministic: once a block is committed there are no reorgs, so one confirmation is enough.
SeiDB
The standard Cosmos SDK storage layer, IAVL, stores state and its Merkle commitment in the same tree on disk. That leads to heavy write amplification and fast-growing state. SeiDB splits the two:
Layer
Role
State commitment (SC)
A memory-mapped Merkle tree (MemIAVL) that holds the latest state and produces the state root each block
State storage (SS)
A flat key-value store of historical versions for queries, backed by an embedded database such as PebbleDB
Commitment work stays in memory and fast, history is written asynchronously, and old versions can be pruned independently. The result is smaller disks, faster state sync and quicker commits, which matters once parallel execution means the storage layer is the bottleneck.
From Sei V2 to EVM-only
The Sei V2 upgrade went live on mainnet in mid-2024. It added a full EVM based on go-ethereum's execution code, alongside the existing Cosmos and CosmWasm environments. For a while Sei was a dual-VM chain. Each key had both a sei1... bech32 address and a 0x address, accounts could associate the two, and pointer contracts made a token visible as both an ERC-20 and a CW20 or native denom.
In 2025, Sei governance approved SIP-3, a plan to deprecate CosmWasm, IBC and Cosmos-native transactions and make Sei an EVM-only chain. The rollout came in phases through the first half of 2026: EVM-side staking, disabling inbound IBC transfers, removing the native oracle in favor of external providers, and stopping new CosmWasm deployments. Remaining Cosmos-side functionality was scheduled for removal around mid-2026. Sei's roadmap after that is Giga, which is rebuilding execution, storage and consensus (including a multi-proposer consensus design) in stages, with parts already live. Check Sei's current docs for exactly which pieces are active, especially if you hold legacy sei1 balances or CosmWasm contracts.
What developers need to change
Usually nothing. Sei is a standard EVM target:
Deploy with Foundry or Hardhat, sign with MetaMask or any EVM wallet, and use ethers or viem.
Mainnet chain ID is 1329.
Solidity semantics, the ABI and JSON-RPC are the ones you already know.
You don't annotate contracts or declare access lists to benefit from parallelism. The node discovers conflicts at runtime.
Gotchas
Hot-spot state serializes. Any storage slot written by many transactions in the same block forces them into sequence. A global counter is the classic case:
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
contract Tickets {
uint256 public sold; // every purchase writes this slot
mapping(address => uint256) public owned;
event Purchased(address indexed buyer, uint256 amount);
function buy(uint256 amount) external {
sold += amount; // conflict between all buyers
owned[msg.sender] += amount; // no conflict between different buyers
emit Purchased(msg.sender, amount);
}
}
Correctness is unaffected, but under load every buy in a block conflicts on sold and gets re-executed. If you don't need the running total on-chain, drop it and aggregate Purchased events in an indexer. If you do need a cap, consider per-user or bucketed limits. Common hot spots include:
Global counters, totalSupply updates on every mint, and "last caller" or timestamp variables.
A single popular AMM pool or a single oracle contract that everyone writes.
Many transfers into one address, such as an exchange deposit wallet, which all update the same balance.
Some of this is inherent. A pool that everyone trades on can't be parallelized. But avoid creating hot spots by accident.
Block-based timing. Blocks are about 30 times more frequent than Ethereum's 12-second slots. Logic that assumes a block count maps to wall-clock time, such as vesting in blocks or "wait 5 blocks", will be off. Use block.timestamp.
Parallelism doesn't cut your gas bill. It raises chain throughput, not per-transaction efficiency. Gas is metered the same way, and fees follow Sei's own gas price rules.
Legacy Cosmos assumptions. Older integrations built on sei1 addresses, CosmWasm pointer contracts or IBC denoms need migrating to their EVM equivalents under SIP-3.
Summary
Component
What it does
Optimistic parallel execution
Runs transactions concurrently, validates reads in block order, re-executes conflicts, same result as serial
Twin Turbo
Compact block propagation plus executing blocks before they're finalized, about 400 ms blocks, instant finality
SeiDB
Separates in-memory state commitment from flat historical storage
Sei V2
Added a geth-based EVM in 2024, alongside CosmWasm
SIP-3
Moves Sei to EVM-only, with Cosmos, CosmWasm and IBC phased out during 2026
Developer impact
Deploy normal Solidity, and design around shared storage slots that serialize
Sei's parallel EVM is transparent to contracts. The one habit worth changing is how you think about shared state: every slot many users write in the same block is a queue, so keep those slots few and deliberate.