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

Following the successful launch of the AtlanticOcean testnet in October 2025, Pharos plans to launch its mainnet and initiate TGE in Q2 2026.

Article by: Youssef Haidar, Messari Researcher

Translation 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 for a stable mainnet throughput of 30,000 transactions per second.
• Pharos Store embeds Merkle trees directly into the storage layer, compressing traditional 8-10 disk reads into 1-3, solving the invisible throughput bottleneck faced by most high-performance parallel chains.
• Pharos unifies EVM and WASM into a deterministic virtual machine (DTVM), allowing Solidity contracts to natively call Rust contracts without cross-chain bridges or cross-VM overhead.
• Dedicated Processing Networks (SPNs) support developers in building customized execution layers for high-load scenarios (e.g., derivatives trading, ZK proof verification), inheriting mainnet security via native re-staking without building independent validator clusters from scratch.

Introduction

Pharos is a high-performance, modular Layer 1 public chain aiming to build 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 create an inclusive financial system: delivering Web2-like smooth user experiences while maintaining the native decentralization and security of public chains. Pharos emphasizes a “quality over quantity” asset ecosystem, helping traditional institutions unlock on-chain liquidity and opening channels for underserved populations to access financial 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 full 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 reliably achieve 30,000 transactions per second and 2 Gbps data transfer rates, supporting global online activity of billions of users. After the successful launch of the AtlanticOcean testnet in October 2025, Pharos plans to launch its mainnet in Q2 2026 and initiate the token generation event (TGE).

Project Background

Founded in November 2024 by Alex Zhang and Wish Wu, both former senior executives in Ant Group’s blockchain infrastructure team, Pharos stems from Ant’s mature technical ecosystem. It has been independently spun off and iteratively upgraded to build a decentralized, open-source foundational chain. The founding team includes talent from Microsoft, PayPal, Stanford, Ripple, and other top institutions, with deep technical expertise.

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

Core Technology

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

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

Consensus Layer

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

Most round-based BFT protocols must wait for final confirmation of the previous round, limiting 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, this 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: Validator 1 handles transactions 1 and 2, Validator 2 handles 3 and 4, Validator 3 handles 5; Validator 4 remains idle if no tasks are assigned, avoiding redundant data broadcast. Active validators independently package their transactions into block proposals. Network resources scale linearly with validator count (doubling nodes roughly doubles proposal bandwidth), avoiding idle redundant nodes.

After all proposals are synchronized, validators perform dense cross-voting. If over two-thirds agree on a proposal, the network reliably broadcasts and votes to finalize the block, completing consensus in three rounds and producing 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 VMs. To enforce strict hardware determinism, DTVM compiles all bytecode into a deterministic intermediate representation (dMIR), removing floating-point ambiguities 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.

Because dMIR serves as a universal backend for multiple bytecode frontends, a single JIT compiler can optimize for EVM, WASM, and future RISC-V contracts, avoiding fragmentation. Only modules compiled into dMIR are executable on-chain, establishing a strict determinism threshold.

To reduce JIT latency, DTVM integrates the Zeta engine, which performs function-level compilation rather than whole-contract precompilation. After deployment, the engine verifies contract legality, generates dMIR bytecode, and asynchronously compiles individual functions. If a function isn’t yet compiled when invoked, a lightweight placeholder triggers on-demand compilation, with subsequent calls executing native code. Initial invocation latency is around 0.95 ms, with full native execution from the second call onward.

Pharos Pipeline

Pharos’s pipeline integrates all components, decomposing the serial block lifecycle into concurrent stages. Unlike traditional chains that follow a strict “proposal → execution → confirmation” sequence, Pharos dynamically allocates CPU and disk I/O resources across execution, Merkle hashing, and final state confirmation, overlapping these stages with hardware fully utilized.

This architecture supports flexible multi-level finality: ordering finality (permanent transaction sequence lock), transaction finality (deterministic execution results), and block finality (full network-wide block access). Low-latency applications like DeFi and gaming can access transaction ordering 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 TPS with a 30-50% latency reduction 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 modern hardware features, limiting performance. Ph-WASM is a custom WebAssembly runtime for Pharos, running in parallel with EVM to handle high-throughput workloads such as AI model scheduling, perpetual on-chain trading, 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.

In practice, developers 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, allowing Solidity contracts to call Rust contracts natively without bridges or nested VM overheads, enabling seamless asset liquidity and composability. For example, DeFi protocols can develop front-end logic in Solidity, while core pricing engines are implemented in Rust on Ph-WASM, meeting real-time throughput demands.

Storage Layer

Large and slow disk I/O for ledger state expansion is a hidden bottleneck for on-chain scalability. Even with high-performance execution engines, waiting on traditional Merkle Patricia Trees (MPT) for disk reads causes stalls. For Ethereum, querying a single account state can require 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 accumulate, making storage a throughput bottleneck.

Pharos Store is a native storage engine based on Log-Structured Trusted Universal Storage (LETUS), designed to eliminate these bottlenecks at the architecture level. Its core innovation embeds Merkle trees directly into the storage engine, replacing the standard two-layer design of separate key-value stores with Merkle trees layered into storage. This reduces I/O from 8-10 disk reads to 1-3, with structural optimizations amplifying as transactions increase.

The engine organizes data with three custom structures:

• Incremental Multi-Version Merkle Tree (DMM-Tree): a high-branching Merkle tree with incremental encoding, persisting only changed states without rewriting entire nodes.
• Log-Structured Versioned Page Store (LSVPS): provides in-memory and disk paging for DMM-Tree, using monotonically increasing version numbers instead of hash addresses. This reduces high-frequency compression and disk bandwidth by 96.5%.
• Versioned Log Data Stream (VDLS): appends user metadata as read-only logs, ensuring data integrity and quick recovery after node failures.

Official data indicates Pharos Store reduces overall storage overhead by 80%, with I/O throughput 15.8 times that of Ethereum’s combined Merkle Patricia Tree and layered databases. It supports concurrent reads, multi-threaded Merkle hashing, and non-blocking writes, matching execution layer speeds without backpressure. The system is compatible with tiered storage, automatically migrating old blocks to low-cost archival storage; field scans streamline ledger management, reducing storage footprint by over 42%.

Network Layer

The network layer relies on optimized P2P gossip protocols for full network communication, ensuring low-latency message propagation. It dynamically adjusts bandwidth based on real-time load, maintaining efficient transaction and data dissemination under extreme conditions.

Dedicated Processing Networks (SPNs)

Pharos introduces SPNs—modular, application-specific networks supporting custom scaling. SPNs are essentially dedicated execution layers inheriting Pharos’s security, operating semi-independently with configurable consensus parameters and logic. Developers can deploy SPNs for compute-heavy workloads unsuitable for general-purpose chains, such as 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-based pledge certificates, which are then re-staked into one or multiple SPN subnets. This shared security model reduces the need for each subnet to recruit independent validator sets, improving capital efficiency.

Users interact with SPNs via cross-subnet protocols built on three core components: message mailbox, registration registry, and cross-chain bridge. Unlike generic 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 setups.

Cross-subnet communication flow:

1. User initiates cross-subnet transaction on SPN1, specifying target SPN2 message queue.
2. Relay nodes carry transaction data, encrypted proofs, and block headers to the mainnet.
3. Mainnet verifies transaction authenticity, archives it into the message mailbox as the authoritative source.
4. SPN2 reads from the mailbox, archives into its local mailbox, completing execution transfer.

All managed by two core smart contracts: one for protocol message validation and routing, and another for subnet lifecycle, registry, and governance, ensuring configuration consistency across the network. This design enables cross-subnet atomic execution and verifiable data sharing without trusted intermediaries.

A built-in emergency escape mechanism allows asset withdrawal to the mainnet regardless of SPN operator behavior, ensuring censorship resistance—crucial for DeFi derivatives and high-value assets.

Ecosystem

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

Focusing on the “RealFi” track: unlike native crypto DeFi yields, it emphasizes institutional-grade on-chain finance based on RWAs. RWAs are openly accessible via issuance platforms like Centrifuge, which will list tokenized US bonds (JTRSY) and AAA-rated structured credit products (JAAA) on Pharos.

Current main obstacle for institutional RWA on-chain is ecosystem fragmentation. The Pharos Foundation has launched the RealFi Alliance to foster collaboration. Under this framework:

• Chainlink provides cross-chain security and data integrity infrastructure; Pharos integrates Chainlink 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 tokens compatible with DeFi.
• Anchorage Digital, a federally compliant US crypto bank, offers institutional custody, token minting, and distribution services for Pharos TGE investors.
• R25 develops specialized protocols for structured credit and transparent yield RWAs.
• Faroo creates Pharos-native RWA liquidity staking protocols.

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

Conclusion

Pharos’s core design philosophy is that parallelizing transaction execution alone cannot overcome performance bottlenecks. By designing the entire block lifecycle as a concurrent process, the network 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 reduces storage I/O from 8-10 disk reads to 1-3, directly addressing the long-neglected on-chain scalability issue.

Native modular expansion via SPNs offers a path to scalable, secure, and flexible infrastructure, avoiding liquidity fragmentation. The TGE and mainnet are expected in Q2 2026, with future success hinging on translating this architecture into real-world network performance and widespread adoption of RealFi on Pharos.