From Bottlenecks to Breakthroughs: What Are Parallelized EVMs

Scalability and efficiency have always been hurdles for many developers and users of blockchain technology. These challenges stem from the inherent trade-offs between decentralisation, security, and performance.

As blockchain networks grow, the need for solutions that strike a delicate balance is unquestionably important — it could make or break a project. Whether optimising consensus algorithms, implementing L2 solutions, or exploring new approaches, the quest for scalability and efficiency remains at the forefront of blockchain innovation. Traditional Ethereum Virtual Machines (EVMs), while foundational to the success of Ethereum-based applications, have struggled under the weight of growing demand.

Enter Parallelized Ethereum Virtual Machines (pEVMs), a fantastic solution meant to redefine the capabilities of blockchain networks. This approach not only promises to resolve the scalability issues but also introduces new possibilities for developers and users. By enabling multiple transactions to be processed simultaneously, pEVMs bring a new era of speed, efficiency, and accessibility to the blockchain — which is what we’ll be digging into here.

This article will explore how pEVMs work, their significant advantages, and their potential to reshape the future of decentralised applications. We’ll begin by diving into pEVMs and follow up with a brief refresher on EVMs before highlighting key differences between the two. We will then examine pEVMs in action and check out early adopters of this technology to speculate on future developments.

What Are Parallelized EVMs?

Parallelized EVMs are a relatively straightforward concept. They help a blockchain scale by allowing multiple transactions to happen “in parallel” rather than in a sequence, making them much more efficient. Simple, right? It is worth noting that it can get pretty involved as some projects have slightly tweaked the concept.

For example, some projects use “optimistic” parallel execution, where transactions run in parallel, and conflicts are resolved by rerunning conflicting transactions sequentially. Some others improve performance by maximising the capabilities of sharding. Further, Neon EVM uses a proxy to wrap Ethereum transactions and execute them on the Solana blockchain, while Aptos and Sui are also making strides in parallel transaction execution, each with their unique approaches to maximising throughput and reducing transaction latency.

To summarize, performing operations in parallel is much faster than doing them one after another. Now, let’s look at why pEVMs were necessary in the first place.

EVMs: Why They Aren’t Cutting It

EVMs are considered the heart of Ethereum’s blockchain. It’s essentially the software that allows smart contracts to be executed and transactions to be processed. This execution environment is necessary for operating DApps across the network. However, the EVM’s traditional method of processing transactions back-to-back creates bottlenecks when the network is stressed with overactivity. Undoubtedly, most of us have experienced slower transaction times and insane gas prices due to this increased network demand.

Gas prices skyrocket because traditional EVMs cannot efficiently distribute gas costs across the network due to their limited capacity to handle high transaction volumes without raising fees. In contrast, pEVMs optimise opcode execution by grouping independent transactions, reducing the number of opcodes needed, and thereby lowering gas costs. With that said, you might be curious about how pEVMs segment transactions to mitigate network congestion and, consequently, reduce gas costs. Let’s dive into that now.

How Do Parallelized EVMs Work?

As mentioned, pEVMs leverage parallel processing to be faster and more scalable, but what is actually involved? To help break this down, we’ll look at how they’re implemented including scheduler-based concurrent processing, multi-threaded EVM instances, and system-level sharding. These components provide a foundational understanding of what happens in a parallelized EVM.

Before moving forward, it’s worth noting that rollups loosely fit the description and have been referred to as pEVMs, as seen with projects like Lumio. However, this article will focus on implementations that are currently being integrated into definitive pEVM projects, which are detailed later.

With that said, let’s begin by breaking down scheduler-based processing.

Scheduler-based Processing

Scheduler-based concurrent processing is a common approach in computer systems to manage the execution of multiple processes or threads efficiently. This method involves a scheduler component that controls how processes share CPU time, memory, and other system resources. Ensuring the system runs smoothly and responsively is essential, especially when multiple tasks need attention simultaneously.

In the context of pEVMs, this “scheduling system” manages and distributes the execution of transactions across multiple EVM instances or threads running in parallel. This would help handle more transactions simultaneously, improving the network’s scalability and efficiency.

To give you an idea of the mechanics, we can take a classic example of how an operating system manages multiple applications running on a computer. Here’s a simplified explanation:

• Multiple Applications Running: Imagine you have several applications open on your computer—perhaps a web browser, a word processor, and a video player.
• Task Scheduler: The operating system includes a component known as the task scheduler. This scheduler is responsible for deciding which application gets CPU time and when. It must manage all the running applications and ensure that each gets enough time to function properly without making the system unresponsive.
• Time Slicing: The scheduler often uses a technique called ‘time slicing’ to allocate time to each process. In time slicing, the scheduler allows each process to run for a fixed amount of time (a time slice) before switching to another process. This switching is fast enough that to the user, it appears all applications are running simultaneously, but in reality, the CPU is quickly switching between them.
• Priority-based Scheduling: Sometimes, the scheduler will prioritise certain processes over others. For example, a real-time video application might be prioritised over a background file download. This prioritisation ensures that more critical or time-sensitive processes receive adequate resources to operate smoothly.
• Resource Allocation: In addition to managing CPU time, the scheduler allocates other resources, such as memory and input/output bandwidth, according to each process’s needs and priorities.

System Level Sharding

System-level sharding is a concept used primarily in distributed computing systems, including blockchain technologies, to scale the network’s capacity and enhance its performance. The fundamental idea is to partition or segment the system’s data, workload, and processing tasks into smaller, manageable pieces or “shards.” Each shard operates semi-independently, which allows for parallel processing, reducing bottlenecks and improving throughput.

Here’s how system-level sharding works:

• Division of Data: The system’s entire dataset is divided into several shards, each containing a subset of the total data. For instance, sharding might involve distributing rows across different servers in a database.
• Parallel Processing: Each shard can process requests independently of the others. This parallelism enables the system to handle more transactions or operations simultaneously than it could if it were a single, unsharded system.
• Load Balancing: Sharding helps balance the load across the network. By distributing the data and the processing load, no single node or server is overwhelmed with too much data or too many requests.
• Reduced Latency: By localising data within specific shards, the system can reduce the distance data needs to travel for processing, which often results in reduced data retrieval and update latency.

Application in Blockchains

In the context of blockchain technology, system-level sharding is used to address scalability issues. Here’s how it typically applies:

• Network Sharding: The network nodes are divided into different shards, with each shard responsible for maintaining a portion of the blockchain’s ledger. This setup allows multiple blocks to be produced and validated simultaneously across different shards.
• State Sharding: This involves splitting the blockchain’s state (e.g., account balances, and contract storage) among multiple shards, reducing the requirement for each node to maintain a full copy of the entire network state.
• Transaction Sharding: Transactions are divided among shards, with each shard processing a subset of all transactions in parallel. This significantly increases the number of transactions the blockchain can process per second.

Challenges

While system-level sharding introduces significant improvements in scalability and performance, it also presents challenges such as:

• Cross-Shard Communication: Ensuring efficient and secure communication between shards can be complex, especially when transactions or operations span multiple shards.
• Data Consistency and Integrity: Maintaining consistency and integrity across different shards requires robust synchronisation and consensus mechanisms.
• Security Concerns: Shards may be more susceptible to attacks if the security measures are not evenly distributed or if a shard contains significantly less computational power than others.

Overall, system-level sharding is a powerful technique used in various technologies to enhance scalability, performance, and efficiency. It is particularly prominent in blockchain development, where it’s considered a vital solution for supporting larger-scale operations.

Multi-threaded EVM Instances

A multi-threaded EVM instance refers to an adaptation of the EVM that allows it to execute multiple transaction processes simultaneously, utilising multi-threading techniques. Traditional EVM implementations process transactions sequentially, one after the other, which can be a bottleneck as previously mentioned.

How Multi-threading Could Enhance the EVM:

• Parallel Transaction Processing: By enabling the EVM to manage multiple threads, transactions could be processed in parallel rather than sequentially. This would allow the EVM to handle more transactions within the same time frame, effectively increasing the network’s throughput.
• Efficiency Improvements: Multi-threading could improve the overall efficiency of transaction processing by reducing the time transactions wait in the queue, thus speeding up the execution time.
• Resource Utilisation: It could better utilise the computational resources of the nodes, spreading the workload more evenly across multiple CPU cores or processors.

Challenges and Considerations

• Concurrency Issues: Implementing multi-threading in an EVM requires careful handling of concurrency issues, such as race conditions and deadlocks, which arise when multiple threads attempt to access and modify shared data simultaneously.
• State Management: Blockchain maintains a global state that is updated with each transaction. Managing this state correctly across multiple threads without inconsistencies is a significant challenge.
• Complexity in Implementation: Adding multi-threading to the EVM significantly increases its complexity, potentially making it harder to maintain and more prone to bugs.

The Impact on Ethereum

It should be obvious now that the pEVM is a game-changer for Ethereum’s scalability. It makes Ethereum more user-friendly and appealing to a broader audience of developers and users. It enhances the performance of existing applications and opens up possibilities for more complex and resource-intensive applications that were previously not feasible.

Various projects have been proactive in facilitating developers’ transition to pEVMs, which is important for Ethereum’s continued growth and competitiveness. They’re providing several supportive features, like backward compatibility, which allows developers to deploy existing smart contracts without re-coding. Enhanced tooling integration helps developers maintain a familiar development environment. Additionally, innovations in parallel processing are being introduced to optimise performance without requiring developers to overhaul their existing applications.

Lastly, and perhaps most obviously, is the impact on the community. High gas fees have long been a major complaint among us users—so much so that they almost seem ‘part of the game’. And, frankly, we’re usually surprised when prices are actually reasonable. Ironically, there would be uproar if we were dealing with these transaction costs in the traditional banking system.

Recall last year’s incident when a trader paid 64 ETH for a single transaction—approximately $119,157—to send 84 WETH. It was pretty unbelievable. While this was obviously not the norm, ETH gas fees generally sting, and any effort by Ethereum to stop it is welcomed. So, let’s now look at who is safeguarding us from these excessive gas fees coupled with frustrating network slowdowns.

Notable pEVM Projects

Here are a few notable pEVM projects!

Sei Network

Sei V2 is a significant upgrade for Sei, establishing it as the first fully parallelized EVM. It ensures backward compatibility for EVM smart contracts so that devs can deploy existing audited contracts from other EVM-compatible blockchains without code changes. It enhances usability with popular tools like Metamask and introduces optimistic parallelization, which supports efficient parallel transaction processing without defining dependencies.

Sei V2 will increase network performance with a processing capacity of 28,300 batched transactions per second while also maintaining block times and finality at 390 milliseconds. This will help support a larger user base and allow more dynamic interactions online, all while drastically lowering transaction costs.

Sei has various software components working together to support its blockchain operations, with some tied to the consensus layer and others to the execution layer. Sei V2 transforms the execution layer to enhance support for optimistic parallelization and improve state storage. A notable addition will be a new component designed to facilitate EVM smart contracts, which will benefit from the upgraded consensus and parallelization capabilities and be compatible with existing Cosmwasm smart contracts.

Sei allows developers to specify how the state is managed within their smart contracts. The “state” refers to the storage conditions the smart contracts operate under. This flexibility allows developers to tailor the state according to the specific needs of their applications. Notably, the feature can also add complexity to the development process, potentially making it harder to manage and optimise.

With Sei V2, the process of managing state access is automated. This means that Sei V2 will handle how transactions interact with the blockchain’s state without requiring developers to specify these interactions manually, simplifying things for developers.

Additionally, Sei V2 intends to run all transactions in parallel by default. As we know, this increases the throughput and efficiency. However, when multiple transactions are processed simultaneously, they might try altering the same data (state), leading to conflicts. Sei V2 will automatically detect these conflicts and rerun the conflicting transactions as needed. This could be done either in parallel again or sequentially, depending on how the transactions interact with the stored data.

This will make it easier for developers to create and manage smart contracts on Sei, reducing the effort needed to handle transaction complexities while benefiting from parallel processing efficiencies.

Neon Labs

NeonEVM is the first pEVM integrated with the Solana blockchain, designed to blend Ethereum’s massive dApp ecosystem with Solana’s high-performance capabilities. The idea is to allow Ethereum developers to deploy their dApps on Solana without needing significant modifications to existing code via a pEVM.

The integration of pEVM within NeonEVM will help transaction throughput and reduce gas fees by taking advantage of Solana’s inherently low transaction costs. This setup maintains full compatibility with Ethereum’s opcode set, ensuring that traditional Ethereum smart contracts can run on Solana through NeonEVM without any alterations. Developers can continue using familiar tools such as Hardhat, Remix, and Embark, making the transition smoother and leveraging Solana’s scalability and speed.

NeonEVM employs Proxy Operators that act as a bridge by converting Ethereum transactions into Solana-compatible transactions. This mechanism allows Ethereum dApps to port over to Solana effortlessly, benefiting from enhanced performance without departing from the Ethereum environment.

One notable achievement is the deployment of Aave V3 MVP on NeonEVM’s mainnet. This showcases its capacity to support complex Ethereum projects efficiently and promotes broader adoption of high-performance blockchain solutions.

Monad

Monad’s architecture leverages parallel execution to process multiple Ethereum transactions at the same time via a technique called ‘pipelined execution,’ which separates the transaction ordering and execution into different stages. This allows Monad to handle up to 10,000 transactions per second with a block time of just one second and achieve instant finality. The platform uses a consensus mechanism known as MonadBFT, which is a pipelined two-phase Byzantine Fault Tolerance algorithm that optimises for both performance and security.

Some of Monad’s pEVM integration’s key features include ‘High Transaction Throughput’. As we’ve come to understand, processing transactions in parallel significantly increases the number of transactions that can be handled. As mentioned, the ideal throughput here would be 10,000 transactions per second. Another important feature is ‘Instant Finality’.

The pipelined consensus mechanism ensures that transactions achieve finality instantly within each block, minimising latency and enhancing the reliability of transaction settlements. And then there is Ethereum compatibility. Monad maintains full compatibility with Ethereum, supporting all opcodes as of the Shanghai fork and integrating with the Ethereum RPC API. This compatibility allows existing Ethereum applications to migrate seamlessly to Monad without changing their code.

Monad has been actively developing this technology, with a scheduled mainnet launch in Q4 of this year (2024). The project is currently in the Devnet phase, which allows developers to test and refine their applications in preparation for the public testnet and eventual mainnet deployment.

Potential Future Developments

We’ll not speculate on potential future developments around pEVM.

Ordinals

A promising area that pEVMs could help with in the future is fixing the challenges posed by inscriptions, a type of digital collectable created by embedding data into specific fields of blockchain transactions. These inscriptions became notably popular following the Taproot upgrade on the Bitcoin network in 2021, allowing for the creation of images, tokens, and other digital collectibles.

As the trend expanded beyond Bitcoin to Ethereum sidechains and layer-2 solutions like Arbitrum, Avalanche, and Polygon, the method of embedding data into the “calldata” field of EVM-based networks allowed for cheaper creation of collectibles compared to traditional NFTs. However, the increased volume of these transactions led to significant network congestion, resulting in high fees and instability, with platforms like Arbitrum experiencing substantial downtime.

Brendan Farmer, co-founder of Polygon, suggests that pEVMs could address the issue by introducing all the previously mentioned benefits (throughput, stability, and minimal transaction fees). Although this feature has not yet been implemented on Polygon, it represents a future goal to enhance network efficiency and user experience.

Blockchain Gaming

When it comes to blockchain gaming, pEVMs should be able to help significantly in addressing several key issues:

Parallelized EVMs’ features will be critical in gaming environments, where real-time interactions and fast responses are essential for gameplay continuity and user satisfaction. By removing network congestion that could occur while playing, gamers will have smoother and more responsive gaming experiences.

They will also allow for more sophisticated and stable in-game economies by providing the infrastructure necessary for handling complex economic transactions quickly and efficiently. Additionally, by keeping transaction fees reasonable, you avoid burdening players with the high costs you don’t typically see in traditional Web 2.0 gaming experiences.

Regarding interoperability, pEVMs facilitate cross-chain interactions, a substantial boon for gaming universes that aim to allow asset transferability and shared experiences across different games and platforms.

This capability can lead to a more interconnected and expansive gaming experience. By enabling assets to be used and recognized across various blockchain platforms, pEVMs help break down the barriers between different gaming ecosystems, allowing a new level of collaboration and asset utility that has been largely conceptual until now.

Conclusion

Parallelized pEVMs will certainly have a massive impact on blockchain technology and significantly change the landscape. Projects like Sei, Neon Labs, and Monad show us the innovative potential of pEVMs.

And, as the blockchain industry continues moving forward, it wouldn’t be surprising if the adoption of pEVMs generates a period of rapid growth and broader acceptance, since these technologies are crucial for addressing the scalability challenges faced by resource-heavy DApps that are likely in the works, particularly in sectors like blockchain gaming and DeFi.

Regardless, introducing pEVMs represents an important development not only for Ethereum but for the entire web3 space. By significantly enhancing processing speeds, pEVMs increase accessibility and set the stage for widespread application across various global industries. This shift heralds a new era where blockchain solutions could become more integral and commonplace across diverse sectors.