Written by: Youssef Haidar, Messari researcher

Translated by: Chopper, Foresight News

TL;DR:

• Pharos is a modular L1 public chain aimed at being the global universal infrastructure for real-world assets (RWAs), founded by executives from the original Ant Group blockchain infrastructure team.
• Unlike public chains that only parallel process transaction execution, Pharos designs the entire block lifecycle, including consensus, execution, storage, and data availability, as a parallel architecture, targeting a stable implementation of 30,000 transactions per second on the mainnet.
• Pharos Store directly embeds the Merkle tree into the storage layer, compressing the traditional 8 to 10 disk reads of the I/O path down to 1 to 3, solving the invisible throughput bottleneck that most high-performance parallel public chains struggle to overcome.
• Pharos unifies EVM and WASM under one deterministic virtual machine (DTVM), allowing Solidity contracts to natively call Rust contracts without the additional overhead of cross-chain bridges or cross-VM processes.
• The Special Processing Network (SPN) supports developers in building customized execution layers for high-load scenarios (such as derivatives trading and ZK proof verification), inheriting the mainnet's security through native restaking without needing to build independent verification node clusters from scratch.

Introduction

Pharos is a high-performance modular Layer 1 public chain designed to build a global universal infrastructure for real-world assets (RWAs). The network supports sub-second block generation speeds and can accommodate billions of concurrent users. The project envisions establishing an inclusive financial system that combines the exceptional smooth experience of the Web2 internet while retaining the native decentralized security features of public chains. Pharos focuses on a "quality over quantity" asset ecosystem layout, helping mature traditional institutions unlock on-chain asset liquidity while opening up asset circulation channels for underserved financial service groups.

Pharos distinguishes itself from ordinary EVM-compatible public chains with its depth of parallel computing architecture (DP). Most public chains can only parallel process transaction execution, while Pharos relies on customized hardware acceleration to achieve full block lifecycle parallel operation, covering data availability, execution settlement, and consensus confirmation throughout the process.

By removing the invisible performance bottleneck across the entire chain, the network can stably achieve a throughput of 30,000 transactions per second and a data transmission rate of 2Gbps, sufficient to support billions of global users trading online simultaneously. Following the successful launch of the AtlanticOcean testnet in October 2025, Pharos plans to launch its mainnet and initiate the token generation event (TGE) in the second quarter of 2026.

Project Background

Pharos was co-founded by Alex Zhang and Wish Wu in November 2024, both of whom previously held core executive positions in Ant Group's blockchain infrastructure. Alex Zhang served as the CEO of Ant Group Web3 subsidiary ZAN and the Chief Technology Officer of Ant Chain; Wish Wu was the Chief Security Officer of ZAN, specializing in institutional security and compliance, with rich practical experience.

Pharos is derived from the mature technology system of Ant Group, independently split and iteratively upgraded, aiming to create a decentralized, open-source base public chain. The founding team comprises top talents from Microsoft, PayPal, Stanford University, Ripple, and other leading companies and institutions, with deep technical expertise.

In November 2024, Pharos completed an $8 million seed round financing, co-led by Hack VC and Lightspeed Faction. At the same time, the project achieved a deep strategic cooperation with ZAN, focusing on three core areas: building node infrastructure, a security protection system, and hardware performance acceleration, ensuring the network meets institutional-grade stability standards.

Core Technology

Pharos views the complete block lifecycle as a parallel scheduling process. The team believes that optimizing a single execution module alone will still lead to severe performance bottlenecks in storage I/O read/write, consensus confirmation, and data distribution.

To eliminate these bottlenecks, Pharos adopts a modular protocol stack that decouples execution, consensus, and settlement processes supported by customized storage engines and twin virtual machine environments.

Consensus Layer

Traditional Byzantine Fault Tolerance (BFT) consensus relies on a single node proposing to produce blocks, which poses performance limits and risks of single points of failure. Pharos breaks through these limitations with a fully asynchronous BFT protocol that does not require fixed time assumptions, allowing validating nodes to advance dynamically based on actual network conditions rather than passively waiting for timeouts.

Most round-based BFT protocols need to wait for the final confirmation of the previous round before proceeding, with throughput constrained by maximum delays; Pharos decouples the block proposal phase from the confirmation phase, allowing validating nodes to process transactions based on real-time network capacity, avoiding stalls under extreme fluctuations while maintaining both liveness and security. Even under completely asynchronous conditions with unpredictable message passing time, this protocol can maintain liveness.

To prevent network congestion caused by duplicate transactions, a deterministic mapping algorithm assigns each transaction to designated validating nodes. The above illustration clearly explains this: memory pool transaction shards are distributed, validating node 1 processes transactions 1 and 2, validating node 2 processes transactions 3 and 4, and validating node 3 processes transaction 5; validating node 4 without assigned tasks remains idle, avoiding broadcasting redundant data. Active validating nodes independently package their own transactions to generate block proposals. Ultimately, network resources scale linearly with validating nodes (doubling the node set ≈ doubling the proposal bandwidth), without generating idle redundant nodes.

After validating nodes synchronously submit all proposals, the entire network engages in intensive pairwise cross-voting. If more than two-thirds of validating nodes reach consensus on a proposal, the network merges reliable broadcasting with consensus voting, requiring only three rounds of communication to finalize the block and output a deduplicated ordered transaction ledger.

Execution Layer

The core of Pharos's execution layer is the Deterministic Virtual Machine (DTVM) stack, replacing the traditional sequential processing model with a parallel twin virtual machine architecture.

DTVM Stack

The DTVM natively supports EVM and WASM execution in a single runtime environment without needing a separate virtual machine, enabling seamless cross-calls between Solidity contracts and contracts written in Rust, Go, C++, and other languages. To enforce strict hardware determinism, the DTVM compiles all bytecode into a deterministic intermediate layer representation (dMIR), eliminating non-deterministic behaviors such as floating-point ambiguities and undefined exception handling. The dMIR standardizes halting rules and fixed value operation logic, paired with an 8MB fixed virtual call stack (maximum depth 1024), unaffected by host architecture, ensuring that x86 and ARM node ledgers remain completely consistent.

Since dMIR acts as a universal backend for multi-bytecode frontends, a single set of Just-In-Time (JIT) optimizers can adapt to EVM, WASM, and potential RISC-V contracts, avoiding the fragmented redundancy costs typically associated with multi-VM architectures. Only modules successfully compiled into dMIR format are allowed on-chain execution, inherently reinforcing the barrier to determinism.

To reduce the inherent delays of traditional JIT, the DTVM integrates the Zeta engine. Most blockchain virtual machines face the dilemma of either lengthy delays from full pre-compiled deployment or time to first call from JIT compilation. Zeta breaks down contract-level compilation logic to function granularity. After deploying a contract on-chain, the engine verifies its validity and generates dMIR bytecode, asynchronously compiling independent functions in the background one by one. If a function's compilation is not complete when triggered, it initiates lightweight placeholder JIT compilation, with subsequent calls going directly to native code. Actual testing showed that the initial call delay is only 0.95 milliseconds, with all subsequent executions being native code.

Pharos Pipeline

The Pharos pipeline connects and integrates all components, breaking the serial block lifecycle down into concurrent phases. Ordinary blockchains strictly adhere to the "proposal → execution → confirmation" sequence, each stage waiting for the previous one to complete before progressing. Pharos relies on a 64-core framework, dynamically allocating CPU and disk I/O resources, and runs execution, Merkle hashing, and state final confirmation concurrently and overlapping, ensuring hardware is fully utilized throughout.

This architecture also supports flexible multi-tier finality: distinguishing between ordering finality (permanently locking transaction order), transaction finality (determining execution results), and block finality (complete global access to blocks). Low-latency sensitive applications like transactions and gaming can pre-obtain transaction ordering and execution results without waiting for complete block finality, greatly optimizing user experience, while infrastructure like oracles and block indexing must wait for complete block finality.

The Pharos pipeline architecture enables Pharos to optimize its environment to achieve a throughput of 500,000 transactions per second, reducing delays by 30% to 50% compared to traditional serial pipelines.

Ph-WASM

EVM is natively unsuitable for compute-intensive tasks: with a 256-bit base word length, stack-based underlying architecture, and lack of native support for modern hardware features, it imposes strict performance limits. Ph-WASM serves as a dedicated WebAssembly runtime for Pharos, running in parallel with EVM to handle high-throughput loads, including AI model scheduling, perpetual contract on-chain trading, and zero-knowledge proof verification. It integrates SIMD vector acceleration, opcode fusion, and other advanced compilation optimizations, ensuring efficient low consumption for CPU-intensive computing and I/O-intensive interactions throughout.

Practical implemented value: developers write performance-critical logic in languages like Rust, C++, etc., deploying it to Ph-WASM; existing Solidity contracts remain operational on EVM. Both virtual machines are uniformly compiled to dMIR, allowing Solidity contracts to natively call Rust contracts without bridging, nested virtual machine execution, or inter-process communication overhead. Asset liquidity and composability remain universally unified. For example, the frontend treasury logic of DeFi protocols is developed in Solidity to accommodate the ecosystem, while the real-time pricing engine is delegated to Rust contracts within Ph-WASM to meet the native throughput needs of dynamic real-time applications.

Storage Layer

The bloated state of the ledger and slow disk I/O present a fatal invisible flaw for on-chain scalability. Even with top-tier high-speed execution engines, waiting for traditional Merkle Patricia tree (MPT) disk reads can still cause stalls. For instance, querying the status of a single Ethereum account requires 8 to 10 independent disk reads, and the hashing addressing mechanism leads to frequent database compressions, consuming massive disk bandwidth. Once the network scales to hundreds of millions of accounts, these costs accumulate, causing storage to become a throughput constraint bottleneck.

Pharos Store is a chain-native storage engine built on the principles of Log-structured Efficient Trustworthy Universal Storage (LETUS), aiming to eliminate the aforementioned bottlenecks from the architectural level. The core innovation is the native sinking of certified data structures: abandoning the "independent key-value database layered with a Merkle tree" standard double-layer design, embedding the Merkle tree directly into the storage engine's foundational layer. This move reduces the I/O path from 8 to 10 disk reads to just 1 to 3, structurally optimizing and continuously amplifying with each transaction on the network.

The engine organizes data with three dedicated customized structures:

• Incremental Multi-Version Merkle Tree (DMM-Tree): A highly branched Merkle tree that integrates incremental coding, preserving only state changes without requiring a complete node rewrite.
• Log-structured Versioned Page Storage (LSVPS): Provides memory and disk paging index abstraction for the incremental multi-version Merkle tree, using monotonically increasing version numbers instead of hash addressing. The version index eliminates the frequent compression latency that traditional log-structured trees experience, reducing disk bandwidth consumption by 96.5%.
• Versioned Log Data Stream (VDLS): Stores user metadata in an append-only read-only log format, ensuring data integrity and enabling quick recovery after node failures.

According to official data, overall storage costs for Pharos Store are reduced by 80%, with I/O throughput being 15.8 times that of Ethereum's Merkle Patricia tree combined with hierarchical databases. For parallel execution deep optimizations, the engine supports concurrent reads, multi-threaded Merkle hashing calculations, and non-blocking writes, ensuring that the storage layer matches the speed of the execution layer without reverse throttling. The system is compatible with layered cold and hot storage, automatically migrating old block data from high-speed solid-state drives to low-cost archival storage; the boundary scan streamlining ledger mechanism has been tested, reducing storage size by over 42%.

Network Layer

The network layer relies on an optimized P2P gossip protocol to support communication across the Pharos system, achieving low-latency message dissemination. The system adapts bandwidth allocation based on real-time network load to ensure efficient transaction and data distribution even under extreme pressure scenarios.

Special Processing Networks (SPNs)

Pharos introduces Special Processing Networks (SPNs), which support modular application-specific scaling. SPNs fundamentally act as custom independent execution layers, natively inheriting the security of Pharos while functioning semi-independently with customizable consensus parameters and logic. Developers can configure SPNs for compute-intensive loads that are impractical or uneconomical for general public chain settings, such as Fully Homomorphic Encryption (FHE), Multi-Party Computation (MPC), AI model inference, and high-frequency trading.

SPNs leverage native restaking for security: Pharos mainnet validating nodes stake native tokens to obtain liquidity staking certificates, which are then restaked to one or multiple SPN subnetworks. This builds a shared security protection system, ensuring the safe initiation of exclusive subnetworks and efficient use of funds without needing to recruit independent validation node sets from scratch for each new network.

Users achieve asset and data flow between subnets and the main chain via the SPN interoperability protocol, which is built out of three core components: a message mailbox, a registry, and a cross-chain bridge. Unlike general Layer 2 networks, this protocol deeply integrates with the Pharos mainnet, supporting low-latency message relays and atomic asset transfers, avoiding the common liquidity fragmentation issues seen in multi-chain architectures.

The complete process of inter-subnet communication is as follows:

1. Users initiate cross-subnet transactions in SPN1, specifying execution to the SPN2 message queue.
2. Relay nodes carry the transaction, encrypted proof, and block header to synchronize with the mainnet.
3. The mainnet verifies the authenticity of the transaction, archiving it in the message mailbox as the authoritative global data source for cross-subnet messages.
4. SPN2 reads data from the message mailbox, archives it in the local message mailbox, and completes the execution handover.

The entire process relies on two layers of core smart contract controls: the SPN adapter contract is responsible for protocol layer message verification and cross-subnet routing, while the SPN management contract coordinates the lifecycle of subnets, registry states, and governance rules, ensuring that all SPN configurations remain consistent with the global Pharos network. The two types of components cooperate without the need for trusted intermediaries, achieving atomic execution across subnets and verifiable data sharing.

A natively built emergency safety escape mechanism is designed: regardless of the actions of SPN subnet operators, users can always forcibly withdraw assets back to the main chain, ensuring anti-censorship properties that fit high-risk, high-value scenarios such as DeFi derivatives and institutional assets.

Ecosystem

To prepare for the mainnet launch and TGE in the second quarter of 2026, the Pharos Foundation is coordinating the establishment of a complete ecosystem covering all categories, including real-world assets (RWAs), BTCFi, decentralized exchanges, perpetual decentralized exchanges, prediction markets, liquid staking (LST), yield farming automation, AI smart banking, lending protocols, and infrastructure like indexing, oracles, multisig, block explorers, security, cross-chain interoperability, and wallets.

The ecosystem focuses on the "RealFi" track of true finance: in contrast to on-chain yields from native crypto asset DeFi, it primarily targets building institutional-grade on-chain finance based on real-world assets. RealFi is default open with no access barriers; RWAs are issued via Centrifuge and are accessible to all users, with Centrifuge set to launch tokenized U.S. Treasury products JTRSY and AAA-rated structured credit products JAAA on Pharos.

The primary obstacle for institutional-level real assets on-chain lies in ecological fragmentation; thus, the Pharos Foundation has officially launched the RealFi alliance co-construction plan. Under the Pharos network and alliance framework:

Chainlink serves as the authoritative infrastructure for global cross-chain secure communication and data integrity. The Pharos real asset market natively integrates Chainlink data stream price oracles. LayerZero provides a global cross-chain interoperability protocol, while TopNod offers secure self-hosted native wallets.

Centrifuge issues highly liquid and highly composable RWAs based on the deRWA real asset standard, wrapping existing tokenized securities into freely circulating tokens compatible with DeFi protocols.

Anchorage Digital, the first federally compliant crypto bank in the U.S., provides institutional-level asset custody, token minting, and distribution services, covering Pharos TGE institutional investor assets.

R25 online focuses on structured credit and transparent yield design with dedicated protocols for real assets.

Faroo is creating a Pharos native liquidity staking protocol for real assets.

The RealFi alliance will expand in batches in an orderly manner, with future members selected based on asset quality, technological maturity, and ecological synergy standards. Additionally, Pharos has announced the establishment of a $10 million RealFi developer incubation fund to support early teams of Pharos native DeFi applications and infrastructure. Incubation partners include Hack VC, Draper Dragon, Lightspeed Faction, and Centrifuge.

Conclusion

The core underlying design philosophy of Pharos is that merely parallelizing transaction execution is insufficient to break through performance bottlenecks; by designing the entire block lifecycle as a concurrent process, the network aims to address the structural bottlenecks long limiting the throughput of Layer 1 public chains. Its DTVM stack unifies EVM and WASM under a single deterministic runtime, while Pharos Store strives to reduce storage I/O from 8 to 10 disk reads down to 1 to 3, directly tackling long-overlooked on-chain scalability shortcomings.

The Special Processing Network is expected to provide a modular scaling path, preventing liquidity fragmentation across independent execution environments. The TGE and mainnet are expected to be launched in the second quarter of 2026, and the future development of the project will ultimately depend on its ability to translate architectural designs into actual network performance, as well as the extent of RealFi's adoption on Pharos.