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

Author: Youssef Haidar, Researcher at Messari

Translated & edited by: Chopper, Foresight News

TL;DR:

• Pharos is a modular Layer 1 public blockchain designed as global universal infrastructure for real-world assets (RWAs), founded by executives formerly leading Ant Group’s core blockchain infrastructure team.
• Unlike most public blockchains that only parallelize transaction execution, Pharos designs the entire block lifecycle—including consensus, execution, storage, and data availability—as a fully parallel architecture, targeting stable mainnet throughput of 30,000 transactions per second (TPS).
• Pharos Store embeds Merkle trees directly into the storage layer, compressing the traditional I/O path—requiring 8–10 disk reads—down to just 1–3 reads, resolving the “invisible” throughput bottleneck that constrains many high-performance parallel blockchains.
• Pharos unifies EVM and WASM under a single Deterministic Virtual Machine (DTVM), enabling native calls from Solidity contracts to Rust contracts without cross-chain bridges or cross-VM overhead.
• The Specialized Processing Network (SPN) enables developers to build custom execution layers tailored for high-load use cases (e.g., derivatives trading, ZK proof verification). These layers inherit mainnet security natively via restaking, eliminating the need to bootstrap independent validator clusters from scratch.

Introduction

Pharos is a high-performance modular Layer 1 public blockchain engineered to serve as global universal infrastructure for real-world assets (RWAs). The network delivers sub-second block finality and supports concurrent users at the billion-user scale. Its vision is to build an inclusive financial system—delivering the seamless user experience of Web2 while preserving the decentralized security inherent to public blockchains. Pharos pursues a “quality-over-quantity” asset ecosystem strategy: empowering established traditional institutions to unlock onchain liquidity for their assets, while simultaneously opening access channels for underbanked populations.

Pharos’ core differentiator from standard EVM-compatible chains lies in its Deep Parallelism (DP) architecture. While most blockchains parallelize only transaction execution, Pharos leverages custom hardware acceleration to run the entire block lifecycle in parallel—including data availability, execution settlement, and consensus confirmation.

By eliminating end-to-end “invisible” performance bottlenecks, the network achieves stable throughput of 30,000 TPS and 2 Gbps data transfer rates—sufficient to support one billion users transacting concurrently online. Following the successful launch of the AtlanticOcean testnet in October 2025, Pharos plans to launch its mainnet and Token Generation Event (TGE) in Q2 2026.

Project Background

Pharos was co-founded in November 2024 by Alex Zhang and Wish Wu, both former core executives of Ant Group’s blockchain infrastructure division. Alex Zhang previously served as CEO of ZAN—the Web3 subsidiary of Ant Digital—and as CTO of AntChain. Wish Wu served as Chief Security Officer at ZAN, bringing deep expertise and hands-on experience in institutional-grade security and compliance.

Pharos evolved from Ant Group’s mature technology stack, undergoing independent refactoring and iterative upgrades to become a decentralized, open-source foundational public blockchain. Its founding team brings together top-tier talent from Microsoft, PayPal, Stanford University, Ripple, and other leading enterprises and academic institutions—ensuring deep technical foundations.

In November 2024, Pharos raised $8 million in seed funding, co-led by Hack VC and Lightspeed Faction. Concurrently, the project entered a deep strategic partnership with ZAN, focusing on three core pillars: node infrastructure deployment, security protection systems, and hardware performance acceleration—ensuring the network meets institutional-grade stability standards.

Core Technology

Pharos treats the entire block lifecycle as a parallel scheduling process. The team holds that optimizing only a single execution module leaves the network vulnerable to severe performance bottlenecks in storage I/O, consensus finality, and data dissemination.

To eliminate these bottlenecks, Pharos adopts a modular protocol stack that decouples execution, consensus, and settlement, supported by a custom storage engine and dual virtual machine environment.

Consensus Layer

Traditional Byzantine Fault Tolerant (BFT) consensus relies on a single node proposing blocks, imposing hard performance ceilings and exposing single points of failure. Pharos overcomes this limitation using a fully asynchronous BFT protocol—eliminating fixed time assumptions and enabling validators to advance dynamically based on actual network conditions, rather than passively waiting for timeouts.

Most round-based BFT protocols must wait for finality of the prior round before proceeding, capping throughput at maximum network latency. Pharos decouples the block proposal phase from the confirmation phase, allowing validators to process transactions according to real-time network capacity—remaining responsive even under extreme volatility, balancing liveness and safety. Crucially, the protocol maintains liveness even under fully asynchronous conditions where message delivery times are unpredictable.

To prevent network congestion caused by duplicate transactions, a deterministic mapping algorithm assigns each transaction to a designated validator. As illustrated above: mempool transactions are sharded and distributed—Validator 1 processes Txns 1 & 2, Validator 2 handles Txns 3 & 4, and Validator 3 handles Txn 5; Validator 4 remains idle this round, avoiding redundant broadcast. Active validators independently bundle their assigned transactions into block proposals. Ultimately, network resources scale linearly with validator count (doubling the validator set ≈ doubling proposal bandwidth), with zero idle or redundant nodes.

After all validators synchronously submit proposals, the network conducts intensive pairwise cross-voting. Once >⅔ of validators reach consensus on a proposal, the network merges reliable broadcast with consensus voting—finalizing the block in just three rounds of communication and outputting a deduplicated, ordered transaction ledger.

Execution Layer

Pharos’ execution layer centers on the Deterministic Virtual Machine (DTVM) stack—a parallel dual-VM architecture replacing traditional sequential processing models.

DTVM Stack

The DTVM natively supports both EVM and WASM execution within a single runtime—eliminating the need for separate VMs and enabling seamless cross-calling between Solidity contracts and contracts written in Rust, Go, or C++. To enforce strict hardware-level determinism, DTVM compiles all bytecode into a deterministic intermediate representation (dMIR), removing non-deterministic behaviors such as floating-point ambiguities and undefined exception handling. dMIR standardizes halting rules and fixed arithmetic logic, paired with an 8MB fixed virtual call stack (max depth 1024), ensuring identical ledgers across x86 and ARM nodes—architecture-agnostic.

Because dMIR serves as a universal backend for multiple bytecode frontends, a single optimized Just-In-Time (JIT) compiler engine can accommodate EVM, WASM, and potentially RISC-V contracts—avoiding the fragmentation and redundant overhead inherent in multi-VM architectures. Only modules successfully compiled into dMIR format are permitted onchain execution—naturally enforcing determinism.

To reduce traditional JIT latency, DTVM integrates the Zeta Engine. Most blockchain VMs face a tradeoff: full pre-compilation incurs deployment delay; first-call JIT incurs execution delay. Zeta breaks down compilation beyond the contract level—down to individual functions. Upon contract deployment, the engine verifies legality and generates dMIR bytecode, then asynchronously compiles each function in the background. If a function hasn’t yet completed compilation when invoked, lightweight placeholder JIT kicks in—routing subsequent calls directly to native code. Real-world measurements show first-call latency at just 0.95ms, with all subsequent calls executing natively.

Pharos Pipeline

The Pharos Pipeline tightly integrates all components, decomposing the serial block lifecycle into concurrent stages. Conventional blockchains strictly follow the sequential flow “propose → execute → confirm”, with each stage waiting for the prior to complete. Leveraging a 64-core framework, Pharos dynamically allocates CPU and disk I/O resources—running execution, Merkle hashing, and state finalization in parallel and overlapping fashion, keeping hardware fully utilized with zero idle cycles.

This architecture also supports flexible, multi-tier finality: ordering finality (permanent lock-in of transaction order), transaction finality (deterministic execution result), and block finality (full network-wide block accessibility). Low-latency-sensitive applications—such as trading and gaming—can obtain transaction ordering and execution results *before* full block finality, dramatically improving UX; infrastructure like oracles and block indexers await full block finality.

The Pharos Pipeline enables throughput of up to 500,000 TPS in optimized environments—reducing latency by 30–50% compared to traditional serial pipelines.

Ph-WASM

EVM is inherently ill-suited for compute-intensive tasks: its 256-bit base word size, stack-based architecture, and lack of native support for modern hardware features impose hard performance ceilings. Ph-WASM is Pharos’ custom WebAssembly runtime—running in parallel with EVM—to handle high-throughput workloads including AI model orchestration, onchain perpetual contract trading, and zero-knowledge proof verification. It incorporates advanced compilation optimizations—including SIMD vector acceleration and opcode fusion—ensuring highly efficient, low-overhead CPU-intensive computation and I/O-intensive interaction.

Practical value: Developers write performance-critical logic in Rust or C++ and deploy it to Ph-WASM; existing Solidity contracts remain deployed on EVM. Both VMs compile to dMIR, enabling Solidity contracts to call Rust contracts natively—without bridges, nested VM execution, or inter-process communication overhead. Asset liquidity and composability are unified globally. For example, a DeFi protocol’s front-end treasury logic remains in Solidity for ecosystem compatibility, while its real-time pricing engine runs in a Rust contract on Ph-WASM—meeting the native throughput demands of dynamic, real-time applications.

Storage Layer

Bloated ledger state and slow disk I/O represent the “invisible fatal bottleneck” limiting onchain scalability. Even top-tier high-speed execution engines stall waiting for traditional Merkle Patricia Trie (MPT) disk reads. In Ethereum, querying a single account state requires 8–10 independent disk reads; hash-based addressing triggers frequent database compaction, consuming massive disk bandwidth. As networks scale to hundreds of millions of accounts, these cumulative costs ultimately make storage the dominant throughput constraint.

Pharos Store is a chain-native storage engine built on the Log-structured Efficient Trusted Universal Storage (LETUS) principle—designed to eliminate this bottleneck at the architectural level. Its core innovation is native integration of authenticated data structures: abandoning the standard two-layer design (standalone key-value DB overlaid with a Merkle tree), Pharos Store embeds the Merkle tree directly into the storage engine’s foundation. This reduces the I/O path from 8–10 disk reads down to just 1–3 reads—with structural optimization compounding with every transaction processed.

The engine organizes data using three purpose-built structures:

• Delta Multi-Version Merkle Tree (DMM-Tree): A high-branching Merkle tree natively integrating delta encoding—persisting only modified state changes, eliminating full-node rewrites.
• Log-Structured Paging Versioned Storage (LSVPS): Provides memory-to-disk paging index abstraction for DMM-Trees, using monotonically increasing version numbers instead of hash-based addressing. Version indexing eliminates the frequent compaction stalls endemic to log-structured trees, reducing disk bandwidth consumption by 96.5%.
• Versioned Log Data Stream (VDLS): Stores user metadata in append-only, read-only log format—ensuring data integrity and enabling rapid recovery after node crashes.

According to official benchmarks, Pharos Store reduces overall storage overhead by 80%, and delivers I/O throughput 15.8× higher than Ethereum’s combined Merkle Patricia Trie and LevelDB. Deeply optimized for parallel execution, the engine supports concurrent reads, multithreaded Merkle hashing, and non-blocking writes—ensuring the storage layer matches execution speed without acting as a reverse bottleneck. The system supports tiered hot/cold storage: older blocks automatically migrate from high-speed SSDs to low-cost archival storage; boundary scanning and ledger slimming mechanisms have been tested in production, cutting storage footprint by over 42%.

Network Layer

The network layer relies on an optimized P2P gossip protocol to power Pharos-wide communication, enabling low-latency message propagation. The system adaptively allocates bandwidth based on real-time network load, guaranteeing efficient transaction and data distribution even under extreme stress.

Specialized Processing Networks (SPNs)

Pharos introduces Specialized Processing Networks (SPNs) to enable modular, application-specific scaling. SPNs are essentially custom, independent execution layers that natively inherit Pharos security, operating semi-autonomously with customizable consensus parameters and logic. Developers can configure SPNs for compute-intensive workloads impractical or uneconomical on general-purpose L1s—including fully homomorphic encryption (FHE), multi-party computation (MPC), AI model inference, and high-frequency trading.

SPNs launch security natively via restaking: Pharos mainnet validators stake native tokens to receive liquid staking derivatives, which they then restake to one or more SPN subnets. This establishes a shared security framework—guaranteeing secure, capital-efficient subnet launches without requiring each new network to recruit an independent validator set from scratch.

Users achieve interoperability between subnets and the main chain through the SPN Interoperability Protocol—built from three core components: Message Mailbox, Registry, and Cross-Chain Bridge. Unlike generic Layer 2 networks, this protocol is deeply natively integrated into the Pharos mainnet, supporting low-latency message relaying and atomic asset transfers—avoiding the common liquidity fragmentation issues of multi-chain architectures.

End-to-end cross-subnet communication flow:

1. A user initiates a cross-subnet transaction on SPN1, specifying execution in SPN2’s message queue.
2. A relay node carries the transaction, encrypted credentials, and block header to the mainnet.
3. The mainnet validates transaction authenticity, archives it into the Message Mailbox—serving as the globally authoritative source of cross-subnet messages.
4. SPN2 reads the Message Mailbox data and archives it into its local Message Mailbox, completing execution handover.

The entire process is governed by two core smart contracts: the SPN Adaptor Contract handles protocol-layer message validation and cross-subnet routing; the SPN Management Contract oversees subnet lifecycle, registry state, and governance rules—ensuring all SPN configurations remain consistent with the global Pharos network. Together, these components enable cross-subnet atomic execution and verifiable data sharing—without trusted intermediaries.

The design includes a native emergency security escape hatch: regardless of SPN operator behavior, users retain the ability to forcibly withdraw assets back to the main chain—preserving censorship resistance, critical for high-risk, high-value use cases like DeFi derivatives and institutional assets.

Ecosystem

To prepare for the Q2 2026 mainnet launch and TGE, the Pharos Foundation is orchestrating a comprehensive, full-stack ecosystem spanning real-world assets (RWAs), BTCFi, decentralized exchanges (DEXs), perpetual DEXs, prediction markets, liquid staking (LST), yield farming automation, AI-powered banking, lending protocols—and infrastructure including indexing, oracles, multisig, block explorers, security, cross-chain interoperability, and wallets.

The ecosystem focuses on the “RealFi” (Real Finance) vertical: distinct from native crypto-asset DeFi yields, RealFi builds institutional-grade onchain finance anchored to real-world assets. RealFi defaults to permissionless, barrier-free access—RWAs issued via platforms like Centrifuge are open to all users. Centrifuge will launch tokenized U.S. Treasury products (JTRSY) and AAA-rated structured credit products (JAAA) on Pharos.

The primary current obstacle to institutional-grade real-asset onchain adoption is ecosystem fragmentation. To address this, the Pharos Foundation has officially launched the RealFi Alliance initiative. Under the Pharos network and alliance framework:

Chainlink serves as the globally trusted infrastructure for cross-chain secure communication and data integrity. Pharos’ real-asset markets natively integrate Chainlink Data Feed price oracles. LayerZero provides network-wide cross-chain interoperability, while TopNod delivers secure, self-custodial native wallets.

Centrifuge leverages the deRWA real-asset standard to issue highly liquid, composable RWAs—wrapping existing tokenized securities into freely tradable tokens compatible with DeFi protocols.

Anchorage Digital—the first U.S.-federally compliant crypto bank—provides institutional-grade custody, token minting, and distribution services, covering institutional investors participating in the Pharos TGE.

R25 launches a dedicated real-asset protocol focused on structured credit and transparent yield design.

Faroo builds Pharos-native real-asset liquid staking protocols.

The RealFi Alliance will expand in phased, orderly waves—subsequent members selected based on asset quality, technical maturity, and ecosystem synergy criteria. Additionally, Pharos has announced a $10 million RealFi Developer Incubator Fund to support early-stage teams building Pharos-native DeFi applications and infrastructure. Incubation partners include Hack VC, Draper Dragon, Lightspeed Faction, and Centrifuge.

Conclusion

Pharos’ foundational design philosophy is clear: parallelizing transaction execution alone is insufficient to break performance ceilings. By architecting the entire block lifecycle as a concurrent process, Pharos targets the long-standing structural bottlenecks that have constrained Layer 1 public blockchain throughput. Its DTVM stack unifies EVM and WASM under a single deterministic runtime; Pharos Store aims to slash storage I/O from 8–10 disk reads down to 1–3—directly confronting the long-neglected scalability weakness of onchain systems.

Specialized Processing Networks offer a modular scaling pathway—preventing liquidity fragmentation across isolated execution environments. The TGE and mainnet are scheduled for Q2 2026. Ultimately, Pharos’ success will hinge on its ability to translate architectural ambition into tangible network performance—and on how widely RealFi takes root across the Pharos ecosystem.