Web3 Parallel Computing Depth Research Report: The Ultimate Path of Native Scalability

I. Introduction: Scalability is an eternal proposition, and parallelism is the ultimate battlefield

Since the birth of blockchain systems, they have faced the core issue of scalability. The performance bottlenecks of Bitcoin and Ethereum are difficult to overcome, contrasting sharply with the traditional Web2 world. This is not a simple matter of adding more servers; rather, it stems from systemic limitations in the underlying design of blockchain.

In the past decade, we have witnessed countless scaling attempts. From the Bitcoin scaling controversy to the Ethereum sharding vision, from state channels, Plasma to Rollup and modular blockchains, from Layer 2 to data availability reconstruction, the industry has forged a path of innovative scaling. Rollup, as the current mainstream scaling solution, significantly improves TPS while alleviating the burden on the main chain and maintaining security. However, it has not touched the true limits of "single-chain performance" at the blockchain's underlying level, especially being constrained by the traditional model of on-chain serial computation at the execution level.

In-chain parallel computing is gradually becoming a new focus. Unlike other scaling solutions, it attempts to completely reconstruct the execution engine while maintaining a single-chain structure. Drawing on modern operating system and CPU design concepts, it upgrades the blockchain from a "single-threaded" mode to a "multi-threaded + pipelined + dependency scheduling" high-concurrency system. This could not only bring hundreds of times improvement in throughput but also become the key to the explosion of complex smart contract applications.

In fact, single-threaded computing has long been eliminated in the Web2 world, replaced by optimization models such as parallel programming and asynchronous scheduling. As a more conservative computing system, blockchain has never fully utilized these parallel ideas. This is both a limitation and an opportunity. New public chains like Solana, Sui, and Aptos have introduced parallelism at the architectural level, initiating this exploration; while projects like Monad and MegaETH have further broken through to pipeline execution and optimistic concurrency, demonstrating characteristics that are increasingly close to modern operating systems.

Parallel computing is not only a performance optimization but also a paradigm shift in the blockchain execution model. It challenges the fundamental mode of smart contract execution and redefines the basic logic of transaction processing. If Rollup is "moving transactions off-chain," then on-chain parallel computing is "building a supercomputing kernel on-chain," with the goal of providing truly sustainable infrastructure for future Web3 native applications.

As the Rollup race converges, on-chain parallelism is becoming a decisive factor in the new round of Layer 1 competition. Performance is no longer just about speed, but about whether it can support a heterogeneous application world. This is not just a technical competition, but a paradigm struggle. The next generation of sovereign execution platforms in the Web3 world is likely to emerge from this on-chain parallelism battle.

II. Overview of Expansion Paradigms: Five Types of Routes, Each with Its Own Focus

Scalability, as one of the most important, ongoing, and challenging topics in the evolution of public chain technology, has spurred the emergence and evolution of almost all mainstream technological paths over the past decade. Beginning with the block size debate of Bitcoin, this technological competition about "how to make the chain run faster" ultimately diverged into five basic routes, each approaching the bottleneck from different angles, with its own technical philosophy, implementation difficulties, risk models, and applicable scenarios.

The first type of route is the most direct on-chain scaling, represented by methods such as increasing block size, shortening block time, or enhancing processing capacity through optimizing data structures and consensus mechanisms. This approach became the focus during the Bitcoin scaling debate, giving rise to forks like BCH and BSV, which are part of the "big block" camp, and it also influenced the design ideas of early high-performance public chains like EOS and NEO. The advantage of this route is that it retains the simplicity of single-chain consistency, making it easy to understand and deploy, but it is also prone to systemic limitations such as centralization risks, increased node operation costs, and greater synchronization difficulties. Therefore, it is no longer a mainstream core solution in today's design but has become more of an auxiliary complement to other mechanisms.

The second type of route is off-chain scaling, represented by state channels and sidechains. The basic idea of this approach is to move most transaction activities off-chain and only write the final results to the main chain, with the main chain serving as the final settlement layer. Technically, it is close to the asynchronous architecture concept of Web2. Although this idea can theoretically scale infinitely in terms of throughput, issues such as the trust model of off-chain transactions, the security of funds, and the complexity of interactions limit its application. A typical example is the Lightning Network, which has a clear financial scenario positioning, but its ecosystem scale has never exploded; while multiple designs based on sidechains, such as Polygon POS, have exposed the downside of being difficult to inherit the security of the main chain while achieving high throughput.

The third type of route is the currently most popular and widely deployed Layer 2 Rollup route. This approach does not directly change the main chain itself but achieves scalability through a mechanism of off-chain execution and on-chain verification. Optimistic Rollup and ZK Rollup each have their advantages: the former achieves speed and high compatibility but faces challenges such as delay during the challenge period and issues with fraud proof mechanisms; the latter has strong security and good data compression capabilities but is complex to develop and lacks sufficient EVM compatibility. Regardless of the type of Rollup, its essence is to outsource execution rights while keeping data and validation on the main chain, achieving a relative balance between decentralization and high performance. The rapid growth of projects such as Arbitrum, Optimism, zkSync, and StarkNet proves the feasibility of this path, but at the same time, it also exposes mid-term bottlenecks such as excessive reliance on Data Availability (DA), still high costs, and fragmented development experience.

The fourth type of route is the modular blockchain architecture that has emerged in recent years, represented by projects such as Celestia, Avail, and EigenLayer. The modular paradigm advocates decoupling the core functions of blockchain, allowing multiple specialized chains to perform different functions, which are then combined into a scalable network through cross-chain protocols. This direction is heavily influenced by the modular architecture of operating systems and the composable concepts of cloud computing, with the advantage of being able to flexibly replace system components and significantly improve efficiency in specific areas (such as DA). However, its challenges are also very obvious: after modular decoupling, the synchronization, verification, and mutual trust costs between systems are extremely high, the developer ecosystem is highly fragmented, and the requirements for mid- to long-term protocol standards and cross-chain security are far greater than those of traditional chain designs. This model essentially no longer builds a "chain," but rather constructs a "chain network," presenting unprecedented thresholds for overall architectural understanding and operation maintenance.

The last category of routes is on-chain parallel computing optimization paths. Unlike the first four categories that mainly focus on "horizontal splitting" from a structural perspective, parallel computing emphasizes "vertical upgrading," which means achieving concurrent processing of atomic transactions by changing the execution engine architecture within a single chain. This requires rewriting the VM scheduling logic and introducing a whole set of modern computer system scheduling mechanisms such as transaction dependency analysis, state conflict prediction, concurrency control, and asynchronous calls. Solana was one of the first projects to implement the concept of parallel VM at the chain level, achieving multi-core parallel execution through transaction conflict judgment based on an account model. New generation projects like Monad, Sei, Fuel, and MegaETH further attempt to introduce cutting-edge ideas such as pipelined execution, optimistic concurrency, storage partitioning, and parallel decoupling to construct high-performance execution cores akin to modern CPUs. The core advantage of this direction is that it can achieve breakthroughs in throughput limits without relying on a multi-chain architecture, while also providing sufficient computational flexibility for complex smart contract execution, making it an important technical prerequisite for future applications like AI Agents, large-scale chain games, and high-frequency derivatives.

Looking at the five types of scalability paths mentioned above, the underlying divisions are actually the systematic trade-offs in blockchain between performance, composability, security, and development complexity. Rollups excel in consensus outsourcing and security inheritance, modularity emphasizes structural flexibility and component reuse, off-chain scaling attempts to break through the bottleneck of the main chain but comes with high trust costs, while on-chain parallelism focuses on fundamental upgrades to the execution layer, trying to approach the performance limits of modern distributed systems without compromising on-chain consistency. Each path cannot solve all problems, but these directions collectively form a panoramic view of the upgrade of the Web3 computing paradigm, providing developers, architects, and investors with an extremely rich set of strategic options.

Just as operating systems have historically transitioned from single-core to multi-core and databases have evolved from sequential indexing to concurrent transactions, the scalability path of Web3 will eventually lead to an era of highly parallel execution. In this era, performance is no longer just a competition of chain speed, but a comprehensive reflection of underlying design philosophy, depth of architectural understanding, hardware-software collaboration, and system control. And on-chain parallelism may very well be the ultimate battlefield of this long-term war.

3. Classification Map of Parallel Computing: Five Major Paths from Accounts to Instructions

In the context of the continuous evolution of blockchain scalability technologies, parallel computing has gradually become a core path for performance breakthroughs. Unlike the horizontal decoupling of the structural layer, network layer, or data availability layer, parallel computing delves deeply into the execution layer. It concerns the underlying logic of blockchain operational efficiency, determining the response speed and processing capacity of a blockchain system when facing high concurrency and multi-type complex transactions. Starting from the execution model, reviewing the development trajectory of this technological lineage, we can outline a clear classification map of parallel computing, which can be roughly divided into five technical paths: account-level parallelism, object-level parallelism, transaction-level parallelism, virtual machine-level parallelism, and instruction-level parallelism. These five paths range from coarse to fine granularity, representing not only the continuous refinement of parallel logic but also the increasing complexity of the system and the rising difficulty of scheduling.

The earliest form of account-level parallelism is represented by the Solana paradigm. This model is based on a decoupled design of account-state, which analyzes the set of accounts involved in transactions through static analysis to determine if there are any conflicts. If the sets of accounts accessed by two transactions do not overlap, they can be executed concurrently on multiple cores. This mechanism is very suitable for handling transactions with clearly defined structures and clear input-output, especially for programs with predictable paths, such as DeFi. However, its inherent assumption is that account access is predictable and state dependencies can be statically inferred, which makes it prone to issues of conservative execution and reduced parallelism when facing complex smart contracts (such as chain games, AI agents, and other dynamic behaviors). Additionally, cross-dependencies between accounts can severely diminish the benefits of parallelism in certain high-frequency trading scenarios. Solana's runtime has achieved high optimization in this regard, but its core scheduling strategy is still constrained by account granularity.

Further refining the account model, we enter the technical level of object-level parallelism. Object-level parallelism introduces semantic abstractions of resources and modules, enabling concurrent scheduling at the level of finer-grained "state objects." Aptos and Sui are important explorers in this direction, especially the latter, which defines ownership and mutability of resources at compile-time through the linear type system of the Move language, allowing for precise control of resource access conflicts at runtime. This approach is more versatile and scalable compared to account-level parallelism, covering more complex state read-write logic and naturally serving high-heterogeneity scenarios such as gaming, social interactions, and AI. However, object-level parallelism also introduces a higher language barrier and development complexity; Move is not a direct replacement for Solidity, and the high cost of switching ecosystems limits the speed of adoption of its parallel paradigm.

Further advancements in transaction-level parallelism are being explored by a new generation of high-performance chains represented by Monad, Sei, and Fuel. This approach no longer treats states or accounts as the minimum parallel units but instead constructs a dependency graph around the entire transaction itself. It views transactions as atomic operation units, building a transaction graph (Transaction DAG) through static or dynamic analysis, and relies on a scheduler for concurrent pipeline execution. This design allows the system to maximize parallelism without needing a complete understanding of the underlying state structure. Monad is particularly noteworthy, as it combines modern database engine technologies such as optimistic concurrency control (OCC), parallel pipeline scheduling, and out-of-order execution, making chain execution closer to "GPU.