Web3 Parallel Computing Track Panorama: The Best Solution for Native Scaling?

Author: 0xjacobzhao and ChatGPT 4oThe

"Blockchain Trilemma" of "security", "decentralization", and "scalability" of the blockchain reveals the essential trade-off in the design of blockchain systems, that is, it is difficult for blockchain projects to achieve "extreme security, everyone can participate, and high-speed processing" at the same time. In response to the eternal topic of "scalability", the mainstream blockchain scaling solutions in the market are divided according to paradigms, including:

• Execution-enhanced scaling: Improves execution capabilities in situ, such as parallelism, GPU, and multi-core
• State-isolated scaling: Horizontally split state/shard, e.g., shards, UTXO, and multi-subnets
• Off-chain outsourced scaling: Putting execution off-chain, such as rollups, Coprocessor and DA
• structure decoupling scaling: Modular architecture and collaborative operation, such as module chain, shared sequencer, Rollup Mesh
• Asynchronous concurrent scaling: Actor model, process isolation, message-driven, such as agent, multi-threaded asynchronous chain

  The blockchain scaling solution includes: on-chain parallel computing, rollup, sharding, DA module, modular structure, actor system, zk proof compression, stateless architecture, etc., covering multiple levels of execution, state, data, and structure, and is a complete scaling system of "multi-layer collaboration and module combination". This article focuses on scaling methods that mainstream parallel computing.

  Intra-chain parallelism, which focuses on the parallel execution of intra-block transactions/instructions. According to the parallel mechanism, its scaling methods can be divided into five categories, each of which represents a different performance pursuit, development model and architecture philosophy, and the parallel granularity is getting finer and finer, the parallelism intensity is getting higher and higher, the scheduling complexity is getting higher and higher, and the programming complexity and implementation difficulty are also getting higher and higher.

  • Account-level: Represents the project
  • Object-level: Represents the project Sui
  • Transaction-level: Represents the project Monad, Aptos
  • Call-level / MicroVM : Instruction-level MegaETH
  :
  • GatlingX

  The off-chain asynchronous concurrency model, represented by the Actor / Actor Model, belongs to another parallel computing paradigm, as a cross-chain/asynchronous message system (non-block synchronization model), each agent runs independently as an "agent process", asynchronous messages in parallel mode, event-driven, no synchronous scheduling, representative projects such as AO, ICP, Cartesi, etc.

  The well-known rollup or shard scaling scheme belongs to the system-level concurrency mechanism, not the intra-chain parallel computing. They achieve scaling by "running multiple chains/execution domains in parallel", rather than increasing parallelism within a single block/virtual machine. This type of scaling solution is not the focus of this article, but we will still use it to compare the similarities and differences in architectural concepts.

  

  2. EVM Parallel Enhancement Chain: Breaking the Performance Boundary in Compatibility

  Since the development of Ethereum's serial processing architecture, it has undergone multiple rounds of scaling attempts such as sharding, rollup, and modular architecture, but the throughput bottleneck of the execution layer has still not been fundamentally broken. But at the same time, EVM and Solidity are still the smart contract platforms with the most developer base and ecological potential. Therefore, the EVM parallel enhancement chain is becoming an important direction for a new round of scaling and evolution as a key path that takes into account ecological compatibility and execution performance improvement. Monad and MegaETH are the most representative projects in this direction, starting from deferred execution and state decomposition respectively, to build an EVM parallel processing architecture for high-concurrency and high-throughput scenarios.

  Monad's Parallel Computing

  AnalysisMonad is a high-performance Layer1 blockchain redesigned for the Ethereum Virtual Machine (EVM), based on the basic parallel concept of pipelining, with Asynchronous Execution at the consensus layer and Optimistic concurrency at the execution layer Parallel Execution） 。 In addition, at the consensus and storage layers, Monad has introduced the high-performance BFT protocol (MonadBFT) and a dedicated database system (MonadDB) respectively to achieve end-to-end optimization.

  Pipelining: Multi-stage pipeline parallel execution mechanism

  Pipelining is the basic concept of Monad parallel execution, and its core idea is to split the execution process of the blockchain into multiple independent stages, and process these stages in parallel to form a three-dimensional pipeline architecture, each stage runs on independent threads or cores to achieve cross-block concurrent processing. The result is increased throughput and reduced latency. These stages include: Propose, Consensus, Execution, and Commit.

  Asynchronous Execution: Consensus - Execution is asynchronously decoupledOn

  traditional chains, transaction consensus and execution are often synchronous processes, and this serial model severely limits performance scaling. Monad implements consensus layer asynchronous, execution layer asynchronous, and storage asynchronous through "asynchronous execution". Significantly reduce block time and confirmation latency, making the system more resilient, processing more segmented, and resource utilization.

  Core design:

  The
  • consensus process (consensus layer) is only responsible for sorting transactions and does not execute contract logic.
  • The execution process (execution layer) is triggered asynchronously after the consensus is completed.
  • After the consensus is completed, it will enter the consensus process of the next block immediately, without waiting for the execution to be completed.

  Optimistic Parallel Execution: Optimistic Parallel ExecutionTraditional

  Ethereum adopts a strictly serial model for transaction execution to avoid state conflicts. Monad, on the other hand, adopts an "optimistic parallel execution" strategy to significantly increase the transaction processing speed.

  Execution mechanism:

  • Monad optimistically executes all transactions in parallel, assuming that most of the transactions are stateless and conflict-free.
  • Also run a "Conflict Detector" to monitor whether the same state (e.g. read/write conflicts) is accessed between transactions.
  • If a conflict is detected, the conflicting transaction is serialized and reexecuted to ensure that the state is correct.

  Monad has chosen a compatible path: to move as few EVM rules as possible, to achieve parallelism by deferring write state and dynamically detecting conflicts during execution, which is more like a performance version of Ethereum, with a maturity level that makes it easy to migrate to the EVM ecosystem, and is a parallel accelerator in the EVM world.

  MegaETH's parallel computing mechanism resolution

  is different from Monad's L1 positioning, and MegaETH is positioned as an EVM-compatible modular high-performance parallel execution layer, which can be used as an independent L1 public chain, as an execution enhancement layer or modular component on Ethereum. Its core design goal is to deconstruct the account logic, execution environment, and state isolation into the smallest unit that can be independently scheduled to achieve high-concurrency execution and low-latency response capability within the chain. The key innovation proposed by MegaETH is that the Micro-VM architecture + State Dependency DAG (directed and acyclic state dependency graph) and modular synchronization mechanism jointly build a parallel execution system for "intra-chain threading".

  Micro-VM architecture: Accounts are threads

  MegaETH introduces the execution model of "one micro-VM per account", which "threads" the execution environment and provides a minimum isolation unit for parallel scheduling. These VMs communicate with each other through asynchronous messaging instead of synchronous calls, and a large number of VMs can be executed independently, stored independently, and naturally parallel.

  State Dependency DAG: a graph-driven scheduling mechanism

  MegaETH has built a DAG scheduling system based on the account state access relationship, and the system maintains a global dependency graph in real time, and which accounts are modified and which accounts are read for each transaction are all modeled into dependencies. Conflict-free transactions can be executed directly in parallel, and dependent transactions will be scheduled and sorted serially or deferred in topological order. Dependency graphs ensure state consistency and non-duplicate writes during parallel execution.

  The

  asynchronous execution and callback mechanism

  MegaETH is built on top of the asynchronous programming paradigm, similar to the asynchronous message passing of the Actor Model, to solve the problem of traditional EVM serial calls. Contract calls are asynchronous (non-recursive execution), and when contract A -> B -> C is called, each call is asynchronous without blocking waiting; The call stack is expanded into an asynchronous call graph; Transaction processing = traversal of asynchronous graph + dependency resolution + parallel scheduling.

  All in all, MegaETH breaks the traditional EVM single-threaded state machine model, implements micro-virtual machine encapsulation on an account-by-account basis, performs transaction scheduling through state-dependent graphs, and replaces the synchronous call stack with an asynchronous messaging mechanism. It is a parallel computing platform that is redesigned from the full dimensions of "account structure→ scheduling architecture, → execution process", providing a paradigm-level new idea for building a next-generation high-performance on-chain system.

  MegaETH has chosen the refactoring path: it completely abstracts accounts and contracts into independent VMs, and unleashes the ultimate parallelism potential through asynchronous execution scheduling. Theoretically, MegaETH has a higher parallel cap, but it is also more difficult to control complexity, and it is more like a super-distributed operating system under the Ethereum concept.

  

  Monad and MegaETH Both have different design concepts from sharding: sharding horizontally divides the blockchain into multiple independent sub-chains (shards), each of which is responsible for part of the transactions and state, breaking the single-chain limitation and scaling at the network layer; On the other hand, both Monad and MegaETH maintain the integrity of the single chain, scaling horizontally only at the execution layer, and performing optimization breakthroughs in parallel at the limit of the single chain. The two represent two directions: vertical strengthening and horizontal expansion in the blockchain expansion path.

  Parallel computing projects such as Monad and MegaETH mainly focus on the throughput optimization path, with the core goal of improving on-chain TPS, and achieve transaction-level or account-level parallel processing through deferred execution and micro-VM architectures. Pharos Network is a modular, full-stack parallel L1 blockchain network, and its core parallel computing system is called "Rollup Mesh". This architecture supports multi-virtual machine environments (EVM and Wasm) through the synergy of mainnet and special processing networks (SPNs), and integrates advanced technologies such as zero-knowledge proofs (ZK) and trusted execution environments (TEEs).

  Rollup Mesh Parallel Computing Analysis:

  1. Full Lifecycle Asynchronous Pipelining: Pharos decouples the various stages of a transaction (such as consensus, execution, and storage) and adopts asynchronous processing so that each stage can be carried out independently and in parallel, thereby improving the overall processing efficiency.
  2. Dual VM Parallel Execution: Pharos supports both EVM and WASM virtual machine environments, allowing developers to choose the right execution environment for their needs. This dual-VM architecture not only increases the flexibility of the system, but also increases transaction processing through parallel execution.
  3. Special Processing Networks (SPNs): SPNs are key components in the Pharos architecture, similar to modular sub-networks designed to handle specific types of tasks or applications. With SPNs, Pharos enables dynamic allocation of resources and parallel processing of tasks, further enhancing the scalability and performance of the system.
  4. Modular Consensus & Restaking: Pharos introduces a flexible consensus mechanism that supports multiple consensus models (such as PBFT, PoS, PoA), and enables secure sharing and resource integration between the mainnet and SPNs through the restaking protocol.

  In addition, Pharos reconstructs the execution model from the bottom layer of the storage engine through multi-version Merkle tree, Delta Encoding, Versioned Addressing, and ADS Pushdown technology, and launches Pharos Store, a high-performance storage engine for the native blockchain, to achieve high throughput, low latency, and strong verifiable on-chain processing capabilities.

  In general, Pharos' Rollup Mesh architecture achieves high-performance parallel computing capabilities through modular design and asynchronous processing mechanism.

  In addition to the parallel execution architectures of Monad, MegaETH, and Pharos, we also observe that there are some projects in the market that explore the application path of GPU acceleration in EVM parallel computing, as an important supplement and cutting-edge experiment to the EVM parallel ecosystem. Among them, Reddio and GatlingX are two representative directions:

  • Reddio is a high-performance platform that combines zkRollup and GPU parallel execution architecture, and its core lies in reconstructing the EVM execution process, and realizing the native parallelization of the execution layer through multi-threaded scheduling, asynchronous state storage, and GPU-accelerated execution of transaction batches. Parallel granularity at the transaction level + operation level (multi-threaded execution opcode). It is designed to introduce multi-threaded batch execution, asynchronous state loading, and GPU parallel processing transaction logic (CUDA-Compatible Parallel EVM). Like Monad / MegaETH, Reddio also focuses on parallel processing at the execution layer, with the difference being that the execution engine is reconstructed through a GPU-parallel architecture, designed for high-throughput and compute-intensive scenarios such as AI inference. GatlingX,
  • which calls itself "GPU-EVM", proposes a more radical architecture that attempts to migrate the "instruction-level serial execution" model of traditional EVM virtual machines to a GPU-native parallel runtime environment. The core mechanism is to dynamically compile the EVM bytecode into CUDA parallel tasks, and execute the instruction stream through the GPU multi-core, so as to break the sequential bottleneck of the EVM at the lowest level. Parallel granularity that belongs to Instruction-Level Parallelism (ILP). Compared with the "transaction-level/account-level" parallel granularity of Monad / MegaETH, GatlingX's parallelism mechanism belongs to the instruction-level optimization path, which is closer to the underlying refactoring of the virtual machine engine. It is currently in the concept phase, with a whitepaper and architectural sketch published, and no SDK or mainnet yet.

  Artela proposes a differentiated, parallel design concept. With the introduction of the EVM++ architecture WebAssembly (WASM) virtual machine, developers are allowed to dynamically add and execute extensions on-chain using the Aspect programming model while maintaining EVM compatibility. It uses the contract invocation granularity (Function / Extension) as the minimum parallel unit, and supports the injection of Extension modules (similar to "pluggable middleware") when the EVM contract is running, so as to achieve logical decoupling, asynchronous invocation and module-level parallel execution. More attention is paid to the composability and modular architecture of the execution layer. The concept provides new ideas for complex multi-module applications in the future.

  3. Native parallel architecture chain: The EVM execution model of Ethereum, the execution ontology of the reconstructed VM

  ,

  has adopted a single-threaded architecture of "full transaction order + serial execution" since the beginning of its design, aiming to ensure the certainty and consistency of state changes for all nodes in the network. However, this architecture has a natural bottleneck in performance, limiting system throughput and scalability. In contrast, native parallel computing architecture chains such as Solana (SVM), MoveVM (Sui, Aptos), and Sei v2 built on the Cosmos SDK are tailored for parallel execution from the underlying design and have the following advantages:

  Natural
  • separation of state models: Solana uses an account lock declaration mechanism, MoveVM introduces an object ownership model, and Sei v2 is based on transaction type classification. Static conflict judgment is realized, and transaction-level concurrent scheduling is supported.
  • Virtual machines are optimized for concurrency: Solana's Sealevel engine natively supports multi-threaded execution; MoveVM can perform static concurrency graph analysis; Sei v2 integrates a multi-threaded matching engine with a parallel VM module.

  Of course, this kind of native parallel chain also faces the challenge of ecological compatibility. Non-EVM architectures usually require new development languages (such as Move and Rust) and toolchains, which have certain migration costs for developers. In addition, developers need to master a series of new concepts such as stateful access models, concurrency limits, object lifecycles, etc., which put forward higher requirements for understanding thresholds and development paradigms.

  3.1 The Sealevel parallel engine principle of Solana and SVM

  Solana's Sealevel execution model is an account parallel scheduling mechanism, which is the core engine used by Solana to realize the execution of parallel transactions within the chain, and achieves high-performance concurrency at the smart contract level through the mechanism of "account declaration + static scheduling + multi-threaded execution". Sealevel is the first execution model in the blockchain field to successfully implement intra-chain concurrent scheduling in a production environment, and its architectural ideas have influenced many subsequent parallel computing projects, and is a reference paradigm for high-performance Layer 1 parallel design.

  Core mechanism:

  1. Explicit Account Access Lists: Each transaction must declare the account involved (read/write) when submitting, and the system will determine whether there is a state conflict between transactions.

  2. Conflict detection and multi-threaded scheduling

  • If there is no intersection between the account sets accessed by the two transactions→ they can be executed in parallel;
  • There is a conflict→ executing serially in dependent order;
  • The scheduler allocates transactions to different threads based on the dependency graph.

  3. Program Invocation Context: Each contract call runs in an isolated context without a shared stack to avoid cross-call interference.

  Sealevel is Solana's parallel execution scheduling engine, while SVM is a smart contract execution environment built on top of Sealevel (using the BPF virtual machine). Together, they form the technical foundation of Solana's high-performance parallel execution system.

  Eclipse is a project that deploys Solana VMs onto modular chains such as Ethereum L2 or Celestia, leveraging Solana's parallel execution engine as the rollup execution layer. Eclipse is one of the first projects to propose to detach the Solana execution layer (Sealevel + SVM) from the Solana mainnet and migrate it to a modular architecture, and the modular output of Solana's "super concurrent execution model" is Execution Layer-as-a-Service, so Eclipse also belongs to the category of parallel computing.

  Neon's route is different, it introduces the EVM to operate in an SVM / Sealevel environment. Build an EVM-compatible runtime layer, developers can use Solidity to develop contracts and run in the SVM environment, but the scheduling execution uses SVM + Sealeve. Neon leans more towards the Modular Blockchain category than parallel computing innovation.

  All in all, Solana and SVMs rely on the Sealevel execution engine, and Solana's OS-based scheduling philosophy is similar to the kernel scheduler, which is fast but relatively inflexible. It is a native high-performance, parallel computing public chain.

  3.2 MoveVM Architecture: Resource and Object Driven

  MoveVM is a smart contract virtual machine designed for on-chain resource security and parallel execution, and its core language, Move, was originally developed by Meta (formerly Facebook) for the Libra project, emphasizing the concept of "resources are objects", and all on-chain states exist as objects, with clear ownership and life cycles. This enables MoveVM to analyze whether there are state conflicts between transactions during compilation time, and implement object-level static parallel scheduling, which is widely used in native parallel public chains such as Sui and Aptos.

  Sui's object ownership

  modelSui's parallel computing capabilities stem from its unique approach to state modeling and language-level static analysis. Unlike traditional blockchains, which use global state trees, Sui has built an object-centric model based on the "object", which works with MoveVM's linear type system to make parallel scheduling a deterministic process that can be completed at compile time.

  • The Object Model is the foundation of Sui's parallel architecture. Sui abstracts all the state on the chain into separate objects, each with a unique ID, a clear owner (account or contract), and a type definition. These objects do not share state with each other and are inherently isolated. The contract must explicitly declare the collection of objects involved when it is called, avoiding the state coupling problem of the traditional on-chain "global state tree". This design splits the on-chain state into several independent units, making concurrent execution a structurally feasible scheduling premise.
  • Static Ownership Analysis is a compile-time analysis mechanism implemented with the support of the Move language's linear type system. It allows the system to schedule transactions to be executed in parallel by inferring which transactions do not have state conflicts through object ownership before they are executed. Compared with the conflict detection and rollback of traditional runtimes, Sui's static analysis mechanism greatly reduces the scheduling complexity while improving execution efficiency, which is the key to achieving high throughput and deterministic parallel processing capabilities.

  Sui divides the state space on an object-by-object basis, combined with compile-time ownership analysis, to achieve low-cost, rollback-free object-level parallel execution. Compared with the serial execution or runtime detection of traditional chains, Sui has achieved significant improvements in execution efficiency, system determinism, and resource utilization.

  Aptos' Block-STM Execution

  MechanismAptos is a high-performance Layer1 blockchain based on the Move language, and its parallel execution capability is mainly derived from the self-developed Block-STM (Block-level Software Transactional Memory) framework. Unlike Sui's strategy of "static parallelism at compile time", Block-STM belongs to the dynamic scheduling mechanism of "optimistic concurrency at runtime + conflict rollback", which is suitable for dealing with transaction sets with complex dependencies.

  Block-STM divides the transaction execution of a block into three stages:

  • Speculative Execution: All transactions are conflict-free by default before execution, and the system schedules transactions in parallel to multiple threads to try to execute concurrently, and records the account status (read/write set) accessed by them.
  • Validation Phase: The system verifies the execution result: if there is a read-write conflict between two transactions (for example, Tx1 reads the state of being written by Tx2), one of them is rolled back.
  • Retry Phase: Conflicting transactions will be rescheduled until their dependencies are resolved, and eventually all transactions form a valid, deterministic sequence of state submissions.

  Block-STM is a dynamic execution model of "optimistic parallelism + rollback and retries", which is suitable for state-intensive and logically complex on-chain transaction batch processing scenarios, and is the parallel computing core for Aptos to build a high-versatility and high-throughput public chain.

  

  Solana is an engineering scheduling school, more like an "operating system kernel", suitable for clear state boundaries, controllable high-frequency trading, is a hardware engineer style, to run the chain like hardware (Hardware-grade parallel execution); Aptos is a system fault tolerant, more like a "database concurrency engine", suitable for contract systems with strong state coupling and complex call chains. Aptos and Sui are like programming language engineers, and Software-grade resource security represents the technical implementation path of Web3 parallel computing under different philosophies.

  3.3 Cosmos SDK Parallel Scaling

  Sei V2 is a high-performance transactional public chain built based on the Cosmos SDK, and its parallelism capability is mainly reflected in two aspects: the multi-threaded matching engine (Parallel Matching Engine) and the parallel execution optimization of the virtual machine layer, which is designed to serve high-frequency and low-latency on-chain transaction scenarios, such as order book DEX, on-chain exchange infrastructure, etc.

  Core Parallelism Mechanism:

  1. Parallel Matching Engine: SEI V2 introduces a multi-threaded execution path into the order matching logic, splitting the pending order book and the matching logic at the thread-level level, so that the matching tasks between multiple trading pairs can be processed in parallel and avoid the single-threaded bottleneck.
  2. Virtual machine-level concurrency optimization: Sei V2 builds a CosmWasm runtime environment with concurrent execution capabilities, which allows some contract calls to run in parallel without state conflicts, and cooperates with the transaction type classification mechanism to achieve higher throughput control.
  3. Parallel consensus and execution layer scheduling: The so-called "Twin-Turbo" consensus mechanism is introduced to strengthen the throughput and decoupling between the consensus layer and the execution layer, and improve the overall block processing efficiency.

  3.4 UTXO Model Reformer Fuel Fuel

  is a high-performance execution layer designed based on Ethereum's modular architecture, and its core parallelism mechanism is derived from the improved UTXO model (Unspent Transaction Output). Unlike Ethereum's account model, Fuel uses a UTXO structure to represent assets and states, which is inherently state-isolated, making it easy to determine which transactions can be safely executed in parallel. In addition, Fuel introduces its self-developed smart contract language Sway (similar to Rust), combined with static analysis tools, to determine input conflicts before transactions are executed, so as to achieve efficient and secure transaction-level parallel scheduling. It is an EVM alternative execution layer that balances performance and modularity.

  4. Actor Model: A New Paradigm of Concurrent Execution

  of Agents Actor Model is a parallel execution paradigm based on agent or process, which is different from the traditional synchronous computing of global state on the chain (Solana/Sui/Monad and other "on-chain parallel computing" scenarios), which emphasizes that each agent has an independent state and behavior, and communicates and schedules through asynchronous messages. Under this architecture, the on-chain system can be run concurrently by a large number of processes that are decoupled from each other, and has strong scalability and asynchronous fault tolerance. Representative projects include AO (Arweave AO), ICP (Internet Computer), and Cartesi, which are driving the evolution of blockchain from an execution engine to an "on-chain operating system", providing a native infrastructure for AI agents, multi-task interactions, and complex logic orchestration.

  While the design of the Actor Model is similar to sharding in terms of superficial characteristics (e.g., parallelism, state isolation, and asynchronous processing), the two essentially represent completely different technical paths and system philosophies. The Actor Model emphasizes "multi-process asynchronous computing", where each agent runs independently, maintains state independently, and interacts in a message-driven manner. Sharding, on the other hand, is a "horizontal sharding of state and consensus" mechanism, which divides the entire blockchain into multiple subsystems (shards) that process transactions independently. Actor Models are more like a "distributed agent operating system" in the Web3 world, while sharding is a structural scaling solution for on-chain transaction processing capabilities. Both achieve parallelism, but have different starting points, goals, and execution architectures.

  4.1 AO (Arweave), a super-parallel computer on top of the storage layerAO

  is a decentralized computing platform running on the Arweave permanent storage layer, with the core goal of building an on-chain operating system that supports the operation of large-scale asynchronous agents.

  Core architecture features:

  • Process architecture: Each agent is called a process, with independent state, independent scheduler and execution logic;
  • No blockchain structure: AO is not a chain, but a decentralized storage layer + multi-agent message-driven execution engine based on Arweave;
  • Asynchronous message scheduling system: Processes communicate with each other through messages, adopt a lock-free asynchronous operation model, and naturally support concurrent expansion.
  • Permanent state storage: All agent states, message records, and instructions are permanently recorded on Arweave, ensuring full auditability and decentralized transparency.
  • Agent-native: It is suitable for deploying complex multi-step tasks (such as AI agents, DePIN protocol controllers, automatic task orchestrators, etc.), and can build an "on-chain AI coprocessor".

  AO takes the ultimate route of "agent native + storage driver + chainless architecture", emphasizing flexibility and module decoupling, and is a "microkernel framework on the chain built on top of the storage layer", with the system boundary deliberately shrinking, emphasizing lightweight computing + composable control structure.

  4.2 ICP (Internet Computer), a full-stack Web3 hosting platformICP

  is a Web3 native full-stack on-chain application platform launched by DFINITY, with the goal of extending on-chain computing power to Web2-like experiences, and supporting complete service hosting, domain name binding, and serverless architecture.

  Core architecture features:

  • Canister architecture (containers as agents): Each canister is an agent running on a Wasm VM with independent state, code, and asynchronous scheduling capabilities;
  • Subnet Distributed Consensus System (Subnet): The entire network consists of multiple subnets, each of which maintains a set of canisters and reaches consensus through the BLS signature mechanism.
  • Asynchronous invocation model: Canister communicates with Canister through asynchronous messages, supports non-blocking execution, and has natural parallelism.
  • On-chain web hosting: It supports smart contracts to directly host front-end pages, native DNS mapping, and is the first blockchain platform that supports browsers to directly access dApps;
  • The system has complete functions: It has system APIs such as on-chain hot upgrade, identity authentication, distributed randomness, and timer, which is suitable for complex on-chain service deployment.

  ICP chooses an operating system paradigm of heavy platform, integrated packaging, and strong platform control, and has a "blockchain operating system" that integrates consensus, execution, storage, and access, emphasizing complete service hosting capabilities, and expanding the system boundary to a full-stack Web3 hosting platform.

  In addition, the parallel computing projects of other Actor Model paradigms can be referred to the following table:

  

  5. Summary and ProspectBased

  on the differences between virtual machine architecture and language system, blockchain parallel computing solutions can be roughly divided into two categories: EVM parallel enhancement chain and native parallel architecture chain (non-EVM).

  On the basis of retaining the compatibility of the EVM/Solidity ecosystem, the former achieves higher throughput and parallel processing capabilities through in-depth optimization of the execution layer, which is suitable for scenarios that want to inherit Ethereum assets and development tools and achieve performance breakthroughs at the same time. Representative projects include:

  • Monad: Implements an optimistic parallel execution model compatible with EVM through deferred write and runtime conflict detection, builds dependency graphs and schedules execution after consensus is completed.
  • MegaETH: Abstracts each account/contract into an independent micro-VM, and implements highly decoupled account-level parallel scheduling based on asynchronous messaging and state-dependent graphs.
  • Pharos: Build a rollup mesh architecture to achieve system-level parallel processing across processes through asynchronous pipelines and SPN modules.
  • Reddio: Uses the zkRollup + GPU architecture to accelerate the off-chain verification process of zkEVM through batch SNARK generation and improve the verification throughput.

  The latter completely gets rid of the limitations of Ethereum's compatibility and redesigns the execution paradigm from the virtual machine, state model, and scheduling mechanism to achieve native high-performance concurrency. Typical subclasses include:

  • Solana (SVM): an account-level parallel execution model based on account access claims and static conflict graph scheduling;
  • Sui / Aptos (MoveVM system): Based on the resource object model and type system, it supports static analysis at compile time and realizes object-level parallelism.
  • Sei V2 (Cosmos SDK route): introduces a multi-threaded matching engine and virtual machine concurrency optimization in the Cosmos architecture, which is suitable for transactional high-frequency applications.
  • Fuel (UTXO + Sway architecture): Transaction-level parallelism through static analysis of the UTXO input set, combining a modular execution layer with a customized smart contract language Sway;

  In addition, as a more generalized parallel system, the Actor Model builds an on-chain execution paradigm of "multi-agent independent operation + message-driven collaboration" through an asynchronous process scheduling mechanism based on Wasm or custom VMs. Representative projects include:

  • AO (Arweave AO): Building an on-chain asynchronous microkernel system based on the persistent storage-driven agent runtime;
  • ICP (Internet Computer): uses the containerized agent (Canister) as the smallest unit to achieve asynchronous and highly scalable execution through subnet coordination.
  • Cartesi: Introduces the Linux operating system as an off-chain computing environment to provide an on-chain verification path for trusted computing results, suitable for complex or resource-intensive application scenarios.

  Based on the above logic, we can summarize the current mainstream parallel computing public chain scheme into a classification structure as shown in the following figure:

  

  From a broader scaling perspective, sharding and rollup (L2) focus on horizontal scaling through state sharding or off-chain execution, while parallel computing chains (e.g., Monad, Sui, Solana) and actor-oriented systems (e.g., AO, ICP) directly reconstruct the execution model and achieve native parallelism within the chain or at the system layer. The former improves intra-chain throughput through multi-threaded virtual machines, object models, transaction conflict analysis, etc.; The latter takes the process/agent as the basic unit and adopts message-driven and asynchronous execution modes to achieve multi-agent concurrent operation. In contrast, sharding and rollups are more like "splitting the load to multiple chains" or "outsourcing off-chain", while the parallel chain and actor model is "unleashing the performance potential from the execution engine itself", reflecting a more thorough architectural evolution.

  Parallel Computing vs Sharding Architecture vs Rollup Scaling vs Actor Oriented Scaling Path Comparison

  

  It should be pointed out that most of the native parallel architecture chains have entered the mainnet launch stage, although the overall developer ecosystem is still difficult to compare with the Solidity system of the EVM system, but the projects represented by Solana and Sui, with their high-performance execution architecture and the gradual prosperity of ecological applications, have become the core public chains that the market pays great attention to.

  In contrast, although the Ethereum Rollup (L2) ecosystem has entered the stage of "10,000 chains at once" or even "overcapacity", the current mainstream EVM parallel enhancement chain is still generally in the testnet stage, and has not yet been verified by the actual mainnet environment, and its scaling ability and system stability still need to be further tested. It remains to be seen whether these projects can significantly improve EVM performance and drive ecological leaps without sacrificing compatibility, or if they can further differentiate Ethereum's liquidity and development resources.