Messari Analyzes Pharos: Full Lifecycle Parallelization, Defining Next-Generation High-Performance L1

Written by: Youssef Haidar, Messari Researcher

Translated by: Chopper, Foresight News

TL;DR:

Pharos is a modular Layer 1 public chain positioned as a global infrastructure for real-world assets (RWAs), founded by senior executives from the blockchain infrastructure team led by Ant Group.

Unlike public chains that only process transaction execution in parallel, Pharos designs the entire block lifecycle—including consensus, execution, storage, and data availability—as a parallel architecture, aiming to achieve 30,000 transactions per second on the mainnet.

Pharos Store embeds Merkle trees directly into the storage layer, reducing traditional 8-10 disk reads for I/O operations to 1-3, solving the invisible throughput bottleneck that most high-performance parallel chains face.

Pharos unifies EVM and WASM into a deterministic virtual machine (DTVM), allowing Solidity contracts to call Rust contracts natively without cross-chain bridges or cross-VM overhead.

Dedicated Processing Networks (SPNs) support developers in building customized execution layers for high-load scenarios (such as derivatives trading, ZK proof verification), inheriting mainnet security through native re-staking, eliminating the need to build independent validator node clusters from scratch.

Introduction

Pharos is a high-performance, modular Layer 1 public chain designed to create a universal infrastructure for real-world assets (RWAs). The network supports sub-second block times and can handle billions of concurrent users. Its vision is to build an inclusive financial system: providing the seamless experience of Web2 internet while maintaining the native decentralization and security features of public chains. Pharos emphasizes a “quality over quantity” asset ecosystem, helping traditional institutions unlock on-chain liquidity and opening channels for underserved groups to access assets.

The core advantage of Pharos over typical EVM-compatible chains is its deep parallel computing architecture (DP). Most chains only process transaction execution in parallel, but Pharos leverages custom hardware acceleration to run the entire block lifecycle—including data availability, execution settlement, and consensus confirmation—in parallel.

By breaking through the invisible performance bottlenecks across the entire chain, the network can stably achieve 30,000 transactions per second and 2Gbps data transmission rates, sufficient to support billions of users trading simultaneously worldwide. After the successful launch of the AtlanticOcean testnet in October 2025, Pharos plans to launch its mainnet in Q2 2026 and initiate a token generation event (TGE).

Project Background

Pharos was co-founded by Alex Zhang and Wish Wu in November 2024, both former senior executives in Ant Group’s blockchain infrastructure division. Alex Zhang previously served as CEO of AntChain’s Web3 subsidiary ZAN and CTO of AntChain; Wish Wu was ZAN’s Chief Security Officer, with extensive experience in institutional security and compliance.

Built on Ant Group’s mature technical ecosystem, Pharos has been independently iterated and upgraded with the goal of creating a decentralized, open-source foundational chain. The founding team includes talent from top companies and universities such as Microsoft, PayPal, Stanford, and Ripple, with deep technical expertise.

In November 2024, Pharos completed a seed round of $8 million led jointly by Hack VC and Lightspeed Faction. Concurrently, the project established a strategic partnership with ZAN, focusing on node infrastructure, security systems, and hardware acceleration to ensure the network meets institutional-grade stability standards.

Core Technology

Pharos treats the complete block lifecycle as a parallel scheduling process. The team believes that optimizing only individual execution modules will still leave the network bottlenecked by storage I/O, consensus confirmation, and data distribution.

To eliminate these bottlenecks, Pharos adopts a modular protocol stack, decoupling execution, consensus, and settlement processes, supported by custom storage engines and a dual-VM environment.

Consensus Layer

Traditional Byzantine Fault Tolerance (BFT) consensus relies on single-node proposal blocks, which limits performance and introduces single points of failure. Pharos overcomes these limits with an asynchronous BFT protocol that does not depend on fixed time assumptions. Validation nodes can dynamically progress based on real network conditions rather than passively waiting for timeouts.

Most round-based BFT protocols require waiting for final confirmation of the previous round, which constrains throughput by maximum latency. Pharos decouples block proposal and confirmation phases, allowing validation nodes to process transactions in real-time according to network capacity, avoiding stalls during extreme volatility, and balancing liveness and security. Even in fully asynchronous scenarios with unpredictable message delays, the protocol maintains liveness.

To prevent network congestion caused by duplicate transactions, a deterministic mapping algorithm assigns each transaction to a specific validator node. As illustrated: mempool transactions are sharded and distributed—Validator 1 handles transactions 1 and 2, Validator 2 handles transactions 3 and 4, Validator 3 handles transactions 5; Validator 4 remains idle if no tasks are assigned, avoiding redundant data broadcast. Active validators independently package their transactions into block proposals. Final network resources scale linearly with validator count (doubling nodes roughly doubles proposal bandwidth), avoiding idle redundant nodes.

After all proposals are synchronized and submitted, the network performs dense cross-voting among validators. If over two-thirds agree on a proposal, the network reliably broadcasts and votes to finalize the block, requiring only three rounds of communication to produce a deduplicated, ordered transaction ledger.

Execution Layer

The core of Pharos’s execution layer is the deterministic virtual machine (DTVM) stack, replacing traditional sequential processing with a parallel dual-VM architecture.

DTVM Stack

DTVM natively supports both EVM and WASM within a single runtime, enabling seamless cross-calling between Solidity contracts and Rust, Go, C++ contracts without separate virtual machines. To enforce strict hardware-level determinism, DTVM compiles all bytecode into a deterministic intermediate representation (dMIR), removing non-deterministic behaviors like floating-point ambiguity and undefined exceptions. The dMIR standardizes halting rules and fixed arithmetic logic, with an 8MB fixed call stack (max depth 1024), architecture-agnostic, ensuring identical state on x86 and ARM nodes.

As a multi-bytecode frontend, dMIR serves as a universal backend for JIT compilation, supporting EVM, WASM, and potentially RISC-V contracts, avoiding fragmentation and redundant overhead from multiple VM architectures. Only modules compiled into dMIR are executable on-chain, establishing a strong determinism threshold.

To reduce JIT compilation latency, DTVM integrates the Zeta engine, which breaks the traditional trade-off between full pre-compilation (causing deployment delays) and on-demand compilation (causing first-call latency). Zeta compiles functions at a fine granularity after deployment: verifying contract legality, generating dMIR bytecode, and asynchronously compiling individual functions in the background. If a function isn’t yet compiled when invoked, a lightweight placeholder is used, with native code generated subsequently. Initial invocation latency is measured at just 0.95 milliseconds, with subsequent calls executing fully native code.

Pharos Pipeline

Pharos’s pipeline integrates all components, decomposing the serial block lifecycle into concurrent stages. Unlike conventional chains that follow a strict “proposal → execution → confirmation” sequence, Pharos dynamically allocates CPU and disk I/O resources across a 64-core framework, overlapping execution, Merkle hashing, and final state confirmation stages without hardware idle time.

This architecture supports flexible multi-level finality: ordering finality (permanent transaction sequence lock), transaction finality (deterministic execution results), and block finality (full network access to block data). Low-latency applications like trading and gaming can access transaction order and execution results before full block finality, greatly enhancing user experience; infrastructure components like oracles and block explorers wait for complete finality.

The pipeline enables Pharos to achieve up to 500,000 transactions per second under optimized conditions, reducing latency by 30-50% compared to traditional serial pipelines.

Ph-WASM

EVM is inherently unsuitable for compute-intensive tasks due to its 256-bit word size, stack-based architecture, and lack of support for modern hardware features, resulting in performance ceilings. Ph-WASM is a custom WebAssembly runtime tailored for Pharos, running alongside EVM to handle high-throughput workloads such as AI model scheduling, on-chain perpetual contracts, and ZK proof verification. It incorporates advanced compiler optimizations like SIMD vectorization and instruction fusion, ensuring efficient, low-power processing for CPU and I/O-intensive operations.

Practical value: developers can write critical logic in Rust or C++, deploying to Ph-WASM; existing Solidity contracts continue to run on EVM. Both virtual machines compile to the unified dMIR format, allowing Solidity contracts to call Rust contracts natively without bridges, nested VMs, or inter-process communication overhead. Asset liquidity and composability are globally unified—for example, DeFi protocols’ front-end funds are written in Solidity, while real-time pricing engines are implemented as Rust contracts on Ph-WASM, meeting the demands of real-time, high-throughput applications.

Storage Layer

Ledger bloat and slow disk I/O are invisible but critical bottlenecks for on-chain scalability. Even top-tier execution engines face delays when waiting for traditional Merkle Patricia Tree (MPT) disk reads. For example, querying a single account state in Ethereum requires 8-10 disk reads, with frequent database compactions due to hash-based addressing, consuming massive bandwidth. As the network scales to hundreds of millions of accounts, these costs compound, ultimately constraining throughput.

Pharos Store is a native storage engine based on Log-Structured, Efficient, Trustworthy, Universal Storage (LETUS) principles, designed to eliminate these bottlenecks at the architecture level. Its core innovation embeds Merkle trees directly into the storage engine, abandoning the standard two-layer design of separate key-value stores with Merkle trees. This reduces I/O operations from 8-10 disk reads to 1-3, with structural optimizations that grow with transaction volume.

The engine organizes data via three custom structures:

• Incremental Multi-Version Merkle Tree (DMM-Tree): a high-branching Merkle tree with incremental encoding, persisting only modified states without rewriting entire nodes.

• Log-Structured Paging Version Store (LSVPS): provides paging-based index abstraction between memory and disk for DMM-Tree, using monotonically increasing version numbers instead of hash addresses. This reduces high-frequency compression and disk bandwidth consumption by 96.5%.

• Version Log Data Stream (VDLS): appends user metadata in a read-only log format, ensuring data integrity and enabling rapid recovery after node failures.

According to official data, Pharos Store reduces overall storage costs by 80%, with I/O throughput 15.8 times that of Ethereum’s Merkle Patricia Tree combined with layered databases. Optimized for parallel execution, it supports concurrent reads, multi-threaded Merkle hashing, and non-blocking writes, matching execution layer speeds without backpressure. It also supports tiered storage: older blocks automatically migrate from high-speed SSDs to low-cost archival storage. Edge scanning and simplified ledger mechanisms have reduced storage footprint by over 42%.

Network Layer

The network layer relies on optimized P2P gossip protocols to support full network communication with low latency. It dynamically allocates bandwidth based on real-time load, ensuring efficient transaction and data dissemination even under extreme pressure.

Dedicated Processing Networks (SPNs)

Pharos introduces SPNs—modular, application-specific expansion layers. SPNs are custom, independent execution environments inheriting Pharos’s security, operating semi-independently with configurable consensus parameters and logic. Developers can deploy SPNs for compute-heavy workloads that are impractical or uneconomical on the main chain, including Fully Homomorphic Encryption (FHE), Multi-Party Computation (MPC), AI inference, and high-frequency trading.

SPNs leverage native re-staking for security: validators stake native tokens to obtain flow-staking certificates, which are then re-staked into one or multiple SPN subnets. This shared security model ensures safe startup and capital efficiency without recruiting independent validator sets for each new network.

Users can interact across subnets and the main chain via cross-subnet protocols built on three core components: message mailbox, registry, and cross-chain bridge. Unlike general Layer 2 solutions, this protocol is deeply integrated with Pharos mainnet, supporting low-latency message relays and atomic asset transfers, avoiding liquidity fragmentation common in multi-chain architectures.

Cross-Subnet Communication Workflow:

• User initiates a cross-subnet transaction on SPN1, specifying execution to SPN2’s message queue.

• Relay nodes carry the transaction, encrypted proof, and block headers to the mainnet.

• Mainnet verifies transaction authenticity, archives it into the message mailbox as the authoritative source.

• SPN2 reads from the message mailbox, archives it locally, completing execution transfer.

The entire process is governed by two core smart contracts: one for protocol message validation and routing, and another managing subnet lifecycle, registry, and governance, ensuring configuration consistency across SPNs and the main network. This design enables atomic cross-subnet execution and verifiable data sharing without trusted intermediaries.

An embedded emergency safety mechanism allows users to forcibly withdraw assets back to the main chain regardless of SPN operator behavior, ensuring censorship resistance—suitable for high-risk, high-value scenarios like DeFi derivatives and institutional assets.

Ecosystem

To prepare for the mainnet launch and TGE in Q2 2026, the Pharos Foundation is building a comprehensive ecosystem covering RWAs, BTCFi, decentralized exchanges, perpetual DEXs, prediction markets, liquid staking (LST), yield farming automation, AI-powered banking, lending protocols, and infrastructure such as indexers, oracles, multisigs, explorers, security, cross-chain interoperability, and wallets.

Focus on the “RealFi” track: unlike native crypto DeFi yields, it emphasizes on-chain financial services built on real-world assets. RWAs are openly accessible via issuance platforms like Centrifuge, which will launch tokenized US debt products (JTRSY) and AAA-rated structured credit products (JAAA) on Pharos.

The main obstacle for institutional-grade RWAs on-chain is ecosystem fragmentation. The Pharos Foundation has initiated the RealFi Alliance to foster collaboration. Within the Pharos network and alliance:

• Chainlink provides cross-chain security and data integrity infrastructure. Pharos integrates Chainlink’s data feeds and price oracles natively.

• LayerZero offers cross-chain interoperability protocols; TopNod provides secure, autonomous native wallets.

• Centrifuge issues high-liquidity, highly composable RWAs, tokenizing existing securities into freely tradable DeFi-compatible tokens.

• Anchorage Digital, the first federally compliant crypto bank in the US, offers institutional custody, token minting, and distribution services for Pharos TGE investors.

• R25 develops dedicated protocols for structured credit and transparent yield RWAs.

• Faroo creates Pharos-native real-world asset liquidity staking protocols.

The RealFi Alliance plans to expand gradually, selecting new members based on asset quality, technological maturity, and ecosystem synergy. Additionally, Pharos has announced a $10 million developer incubation fund to support early-stage teams building native DeFi applications and infrastructure, with partners including Hack VC, Draper Dragon, Lightspeed Faction, and Centrifuge.

Conclusion

The core design philosophy of Pharos is that merely parallelizing transaction execution cannot break performance bottlenecks; instead, designing the entire block lifecycle as a concurrent process aims to resolve the structural limitations that have long constrained Layer 1 throughput. Its DTVM stack unifies EVM and WASM within a single deterministic runtime, while Pharos Store seeks to reduce storage I/O from 8-10 disk reads to 1-3, directly addressing the often-overlooked on-chain scalability bottleneck.

Dedicated Processing Networks offer a modular expansion path, preventing liquidity fragmentation across isolated execution environments. The TGE and mainnet are expected to launch in Q2 2026. The project’s future success will ultimately depend on how well its architecture translates into real-world network performance and the adoption of RealFi on Pharos.