Messari Analysis of Pharos: Full Lifecycle Parallelization, Defining the Next-Generation High-Performance L1

Original Author: Youssef Haidar, Messari Researcher

Original Compilation: Chopper, Foresight News

TL;DR:

• Pharos is a modular Layer 1 public blockchain, positioned as a global universal infrastructure for Real World Assets (RWAs), founded by former executives from Ant Group's core blockchain infrastructure team.
• Unlike public chains that only parallelize transaction execution, 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 the Merkle tree directly into the storage layer, compressing the traditional I/O path of 8-10 disk reads down to 1-3 reads, solving the hidden throughput bottleneck that most high-performance parallel public chains struggle to overcome.
• Pharos unifies EVM and WASM under a single Deterministic Virtual Machine (DTVM), allowing Solidity contracts to natively call Rust contracts without the overhead of bridges or cross-VM communication.
• The Specialized Processing Network (SPN) enables developers to build customized execution layers for high-load scenarios (e.g., derivatives trading, ZK proof verification), inheriting mainnet security through native restaking without needing to build an independent validator cluster from scratch.

Introduction

Pharos is a high-performance modular Layer 1 public blockchain designed to be a global 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: combining the seamless experience of Web2 internet while retaining the native decentralized security of public blockchains. Pharos focuses on a "quality over quantity" asset ecosystem strategy, helping both traditional mature institutions unlock on-chain asset liquidity and opening asset circulation channels for the underbanked.

Pharos's core advantage over standard EVM-compatible chains is its Deep Parallelism (DP) architecture. Most blockchains can only parallelize transaction execution, while Pharos, leveraging custom hardware acceleration, achieves parallel operation of the entire block lifecycle, covering data availability, execution settlement, and consensus confirmation.

By eliminating hidden performance bottlenecks across the entire pipeline, the network can stably achieve 30,000 TPS throughput and 2 Gbps data transmission rates, sufficient to support billions of global users trading simultaneously. Following the successful launch of the AtlanticOcean testnet in October 2025, Pharos plans to launch its mainnet and conduct its 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. Alex Zhang previously served as CEO of ZAN (Ant Group's Web3 subsidiary) and CTO of AntChain. Wish Wu served as Chief Security Officer at ZAN, with deep expertise in institutional-grade security and compliance.

Evolving from Ant Group's mature technology stack and independently iterated, Pharos aims to build a decentralized, open-source underlying public chain. The founding team brings together talent from top-tier companies and institutions like Microsoft, PayPal, Stanford University, and Ripple, with profound technical expertise.

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

Core Technology

Pharos treats the entire block lifecycle as a parallel scheduling process. The team believes that optimizing only a single execution module will eventually lead to severe performance bottlenecks in storage I/O, consensus confirmation, and data distribution.

To eliminate these bottlenecks, Pharos employs a modular protocol stack, decoupling execution, consensus, and settlement processes, supported by a custom storage engine and a dual-virtual-machine environment.

Consensus Layer

Traditional Byzantine Fault Tolerance (BFT) consensus relies on a single node proposing blocks, facing performance ceilings and single-point-of-failure risks. Pharos overcomes these limitations with a fully asynchronous BFT protocol, eliminating fixed-time assumptions. Validators can dynamically progress based on actual network conditions rather than passively waiting for timeouts.

Most round-based BFT protocols require waiting for finalization of the previous round to continue, limiting throughput by maximum latency. Pharos decouples the block proposal phase from the confirmation phase. Validators process transactions based on real-time network capacity, avoiding stalls even under extreme volatility, balancing liveness and safety. The protocol maintains liveness even under fully asynchronous conditions with unpredictable message delivery times.

To prevent network congestion from duplicate transactions, a deterministic mapping algorithm assigns each transaction to a specific validator. The diagram above explains this clearly: mempool transactions are sharded and distributed; Validator 1 processes transactions 1 and 2, Validator 2 processes 3 and 4, Validator 3 processes 5. Validator 4, with no assigned tasks this round, remains idle, not broadcasting redundant data. Active validators independently package their assigned transactions into block proposals. Ultimately, network resources scale linearly with validators (doubling the validator set ≈ doubling proposal bandwidth), without creating idle redundant nodes.

After validators synchronously submit all proposals, the network conducts intensive pairwise cross-voting. If over two-thirds of validators reach consensus on a proposal, the network merges reliable broadcast with consensus voting, requiring only three communication rounds to finalize the block, outputting a deduplicated, ordered transaction ledger.

Execution Layer

The core of the Pharos execution layer is the Deterministic Virtual Machine (DTVM) stack, replacing the traditional sequential processing model with a parallel dual-VM architecture.

DTVM Stack

The DTVM natively supports both EVM and WASM execution within a single runtime, eliminating the need for separate virtual machines and enabling seamless cross-calls between Solidity contracts and contracts written in Rust, Go, C++, etc. To enforce strict hardware determinism, the DTVM compiles all bytecode into a deterministic intermediate low-level representation (dMIR), removing non-deterministic behaviors like floating-point ambiguities and undefined exception handling. dMIR standardizes halting rules and fixed numerical operation logic, paired with a fixed 8MB virtual call stack (max depth 1024), ensuring ledger consistency across x86 and ARM nodes regardless of host architecture.

Since dMIR serves as a common backend for multiple bytecode frontends, a single optimized Just-In-Time (JIT) compilation engine can adapt to EVM, WASM, and potential RISC-V contracts, avoiding the fragmented redundancy overhead of multi-VM architectures. Only modules successfully compiled into dMIR format are allowed for on-chain execution, naturally establishing a deterministic barrier.

To reduce the inherent latency of traditional JIT compilation, the DTVM integrates the Zeta engine. Most blockchain virtual machines face a dilemma: full pre-compilation deployment delay vs. first-call JIT execution delay. Zeta breaks the contract-level compilation logic, refining it to a function-level granularity. After a contract is deployed on-chain, the engine verifies its legality, generates dMIR bytecode, and asynchronously compiles individual functions in the background. If a function is triggered before compilation is complete, a lightweight placeholder JIT is used, with subsequent calls executing native code directly. Benchmarks show first-call latency of only 0.95 milliseconds, with native code execution from the second call onward.

Pharos Pipeline

The Pharos Pipeline serially integrates all components, decomposing the sequential block lifecycle into concurrent stages. Ordinary blockchains strictly follow the "propose → execute → confirm" sequential flow, where each stage must wait for the previous one to complete. Pharos, leveraging a 64-core framework, dynamically allocates CPU and disk I/O resources, overlapping the execution, Merkle hashing, and state finalization phases in parallel, ensuring hardware is never idle.

This architecture also supports flexible multi-level finality: distinguishing between ordering finality (permanent transaction order lock), transaction finality (deterministic execution result), and block finality (complete global block access). Low-latency-sensitive applications like trading and gaming can obtain transaction ordering and execution results early without waiting for full block finality, significantly optimizing user experience; infrastructure like oracles and block indexers wait for full block finality.

The Pharos Pipeline architecture helps Pharos achieve a throughput of 500,000 TPS in optimized environments, reducing latency by 30% to 50% compared to traditional serial pipelines.

Ph-WASM

The EVM is natively unsuitable for compute-intensive tasks: its 256-bit base word length, stack-based architecture, and lack of native support for modern hardware features impose a hard performance ceiling. Ph-WASM is a custom WebAssembly runtime for Pharos, running in parallel with the EVM to handle high-throughput workloads, including AI model scheduling, on-chain perpetual contract trading, and zero-knowledge proof verification. It integrates advanced compilation optimizations like SIMD vector acceleration and opcode fusion, ensuring high efficiency and low consumption for both CPU-intensive computations and I/O-intensive interactions.

Practical value: Developers can write performance-critical logic in languages like Rust or C++ and deploy it to Ph-WASM, while existing Solidity contracts continue running on the EVM. Both virtual machines compile to dMIR, allowing Solidity contracts to natively call Rust contracts without bridging, nested VM execution, or inter-process communication overhead. Asset liquidity and composability remain globally unified. For example, a DeFi protocol's front-end treasury logic can be developed in Solidity for ecosystem compatibility, while its real-time pricing engine is offloaded to 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 are hidden fatal weaknesses for on-chain scaling. Even top-tier high-speed execution engines can stall while waiting for traditional Merkle Patricia Trie (MPT) disk reads. Taking Ethereum as an example, querying a single account state requires 8 to 10 independent disk reads, and its hash-based addressing mechanism triggers frequent database compaction, consuming massive disk bandwidth. As the network scales to hundreds of millions of accounts, these costs accumulate, ultimately making storage the throughput bottleneck.

Pharos Store is a chain-native storage engine built on the Log-structured Efficient Trustworthy Universal Storage (LETUS) principle, designed to architecturally eliminate these bottlenecks. Its core innovation is the native embedding of authenticated data structures: abandoning the standard two-layer design of "independent key-value database + outer Merkle tree overlay," it embeds the Merkle tree directly into the storage engine's底层. This compresses the I/O path from 8-10 disk reads down to 1-3 reads, with structural optimization benefits compounding with every network transaction.

The engine organizes data using three specialized custom structures:

• Delta Multi-version Merkle Tree (DMM-Tree): A high-branching Merkle tree natively integrated with delta encoding, only persisting modified state changes without requiring full node rewrites.
• Log-structured Versioned Page Store (LSVPS): Provides a paging index abstraction between memory and disk for the DMM-Tree, using monotonically increasing version numbers instead of hash-based addressing. Version indexing eliminates the frequent compaction stalls of traditional log-structured trees, reducing disk bandwidth consumption by 96.5%.
• Versioned Data Log Stream (VDLS): Stores user metadata in an append-only log format, ensuring data integrity and enabling fast recovery after node failures.

According to official data, Pharos Store reduces overall storage overhead by 80%, with I/O throughput being 15.8 times that of Ethereum's MPT and LevelDB combination. Optimized for parallel execution, the engine supports concurrent reads, multi-threaded Merkle hash calculation, and non-blocking writes, ensuring the storage layer matches the execution layer's speed without becoming a bottleneck. The system is compatible with tiered cold/hot storage, automatically migrating old block data from high-speed SSDs to low-cost archival storage; a boundary scanning mechanism for ledger pruning has been tested, reducing storage footprint by over 42%.

Network Layer

The network layer relies on an optimized P2P gossip protocol to support global communication within the Pharos system, enabling low-latency message propagation. The system adaptively allocates bandwidth based on real-time network load, ensuring efficient transaction and data distribution even under extreme pressure.

Specialized Processing Networks (SPNs)

Pharos introduces Specialized Processing Networks (SPNs) to support modular, application-specific scaling. SPNs are essentially customized, independent execution layers that natively inherit Pharos's security, operating semi-independently with customizable consensus parameters and logic. Developers can configure SPNs for compute-intensive workloads impractical or uneconomical on a general-purpose public chain, including Fully Homomorphic Encryption (FHE), Multi-Party Computation (MPC), AI model inference, and high-frequency trading.

SPNs bootstrap security through native restaking: Pharos mainnet validators stake the native token to obtain liquid staking tokens, which can then be restaked to one or more SPN subnets. This establishes a shared security umbrella, ensuring security and capital efficiency for launching specialized subnets without each new network needing to recruit an independent validator set from scratch.

Users can transfer assets and data between subnets and the main chain via the SPN Interoperability Protocol, built on three core components: a Message Mailbox, a Registry, and a Bridge. Unlike general-purpose Layer 2 networks, this protocol is deeply natively integrated with the Pharos mainnet, supporting low-latency message relay and atomic asset transfers, avoiding the common liquidity fragmentation issues of multi-chain architectures.

Complete cross-subnet communication flow:

1. A user initiates a cross-subnet transaction on SPN1, specifying execution to SPN2's message queue.
2. Relay nodes carry the transaction, encrypted credentials, and block header to synchronize with the mainnet.
3. The mainnet verifies the transaction's authenticity, archives it in the Message Mailbox, serving as the global authoritative data source for cross-subnet messages.
4. SPN2 reads the data from the Message Mailbox, archives it in its local message mailbox, completing the execution handover.

The entire process is managed by two layers of core smart contracts: The SPN Adapter Contract handles protocol-layer message verification and cross-subnet routing; The SPN Manager Contract oversees subnet lifecycle, registry status, and governance rules, ensuring each SPN's configuration aligns with the global Pharos network. These components work together to achieve atomic cross-subnet execution and verifiable data sharing without trusted intermediaries.

The design natively includes an emergency security escape hatch: regardless of an SPN subnet operator's actions, users can always force-withdraw assets back to the main chain, ensuring censorship resistance, suitable for high-risk, high-value scenarios like DeFi derivatives and institutional assets.

Ecosystem

In preparation for the mainnet launch and TGE in Q2 2026, the Pharos Foundation is coordinating the build-out of a comprehensive, full-category ecosystem covering Real World Assets (RWAs), BTCFi, Decentralized Exchanges (DEXs), Perpetual DEXs, Prediction Markets, Liquid Staking Tokens (LSTs), Yield Farming Automation, AI Smart Banking, Lending Protocols, as well as infrastructure like Indexers, Oracles, Multi-sigs, Block Explorers, Security, Cross-chain Interoperability, and Wallets.

The ecosystem focuses on the "RealFi (Real Finance)" track: distinct from native crypto asset DeFi yield, it emphasizes building institutional-grade on-chain finance based on real-world assets. RealFi defaults to open,