Is a parallel EVM really “fast”? Bitroot tells you: parallelism, first and foremost, requires “precision.”
In the blockchain narrative, “speed” is always the main theme. Tens of thousands of TPS, 0.3-second block times… all kinds of numbers keep reshaping our understanding.
However, when we talk about “Parallel Execution,” a core question is often overlooked: while pursuing ultimate speed, how can we ensure that transaction states are absolutely correct?
If a race car frequently flies off the track in pursuit of top speed, its speed is meaningless. In the blockchain world, this is called “conflicts” and “rollbacks.”
Recently, Bitroot officially published a technical announcement detailing the core mechanisms of its parallel EVM. Rather than simply piling on performance figures, it put forward a declaration with a distinctly geeky spirit: “Parallelism needs more than speed. It needs precision.”
So how does Bitroot manage to be “both fast and precise”?
I. Why Is Parallel Execution So Difficult?
The traditional EVM processes transactions sequentially, like a single-lane highway. It may be safe, but congestion is inevitable. A parallel EVM aims to widen that road into multiple lanes, allowing many cars (transactions) to speed along at once.
But on a multilane road, vehicles changing lanes or cutting in can easily cause collisions. In a blockchain, this means two transactions modifying the same state at the same time—for example, both sending funds to or deducting funds from the same wallet—which results in a transaction conflict.
When a conflict occurs, the system must stop, reorder transactions, and roll back erroneous operations. If the conflict rate is too high, frequent “hard braking” and “reversing” can bring the entire network to a crawl, making parallel execution even slower than sequential processing.
That’s why accurately identifying conflicts and minimizing unnecessary rollbacks is the key to a parallel EVM.
II. Bitroot’s “Three-Stage Conflict Detection”: A Precision Collision-Avoidance System
To solve this problem, Bitroot’s parallel EVM uses a rigorous three-stage transaction conflict detection mechanism. It’s like equipping high-speed transaction data with a precision “collision-avoidance radar.”
1. Pre-Execution Stage: Millisecond-Level “Prediction”
Before a transaction is actually executed, the system performs a quick scan using a Counting Bloom Filter.
It’s like predicting which stretches of road might become congested before vehicles enter the highway. The system can quickly identify potential transaction conflicts, with an extremely low false-positive rate (below 0.1%). This means that most safe transactions are quickly cleared, while only the very few that could genuinely conflict are flagged for closer review in subsequent stages. This step dramatically reduces unnecessary computation later on.
2. Runtime Stage: Microscopic “Precision”
For flagged transactions, the system applies more fine-grained controls, using fine-grained read/write locks and versioned state management.
This is like dividing data into tiny units and assigning a version number to each one. When multiple transactions try to read or modify the same data unit, the locking mechanism immediately steps in to ensure they proceed strictly in order instead of competing blindly. In milliseconds, this mechanism can precisely detect conflicts in concurrent access and prevent “dirty data” from being created.
3. Commit Stage: The Final “Wall” of Consistency
Once all transactions have finished running, they enter the final commit stage. At this point, the system performs a final state validation.
This is an absolute security safeguard, ensuring that the state after parallel execution exactly matches the result of the theoretically optimal sequential execution. It protects the blockchain’s most fundamental properties—state consistency and integrity—so there can never be a situation where A is charged for a transfer but B never receives the funds.
III. Optimistic Parallelism + Selective Rollback: A Smart Compromise and Balance
The core idea behind Bitroot’s combined approach is “Optimistic Parallel Execution.”
It assumes that the vast majority of transactions are safe and lets them execute concurrently. The system only initiates “selective rollback” when those 0.1% of potential conflicts occur.
This means the system doesn’t overturn every transaction in the entire block with a “one-size-fits-all” approach. Instead, it precisely rolls back only the few transactions that actually conflict, while preserving the results of all other safe transactions. This “focus on the few, not the many” approach pushes the network’s concurrent performance to its limits while maintaining absolute state correctness.
Conclusion
Bitroot’s technical approach sends a clear message: in the race to build Web3 infrastructure, blindly chasing TPS is outdated. “Precision” is the only prerequisite for high performance.
As Bitroot puts it: “Smarter execution. Fewer bottlenecks.” When a parallel EVM is no longer just a marketing slogan, but a precision system built from Bloom filters, read/write locks, and versioned state management, a truly high-throughput, low-latency, and highly robust blockchain network can finally become a reality.
This article discusses technical concepts only and does not constitute investment advice.
