Pharos aims to build a globally universal infrastructure for RWA, supporting sub-second block speeds and capable of accommodating billions of users.
Article author: Youssef Haidar, Messari researcher
Article compiled by: Chopper, Foresight News
TL;DR:
Pharos is a modular L1 public chain, positioned as a globally universal infrastructure for real-world assets (RWAs), founded by executives from the original Ant Group's 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, aiming to achieve 30,000 transactions per second stably on the mainnet.
Pharos Store directly embeds the Merkle tree into the storage layer, compressing the traditional I/O path of 8 to 10 disk reads down to 1 to 3, solving the invisible throughput bottleneck that many high-performance parallel public chains struggle to overcome.
Pharos unifies EVM and WASM under a Deterministic Virtual Machine (DTVM), allowing Solidity contracts to natively call Rust contracts without incurring additional costs for cross-chain bridges or cross-virtual machine operations.
Dedicated Processing Networks (SPN) support developers in building customized execution layers targeted at high-load scenarios (such as derivatives trading, ZK proof verification), inheriting mainnet security through native re-staking without needing to build independent validation node clusters from scratch.
Introduction
Pharos is a high-performance modular Layer 1 public chain aimed at building a globally universal infrastructure for real-world assets (RWAs). The network supports sub-second block speeds and can accommodate billions of concurrent users. The project envisions constructing an inclusive financial system: providing an extremely smooth experience akin to Web2 while retaining the decentralized security features inherent to public chains. Pharos emphasizes a 'quality over quantity' asset ecosystem layout, assisting traditional mature institutions in unlocking on-chain asset liquidity while opening asset circulation channels for underserved financial groups.
Pharos's core advantage over ordinary EVM-compatible public chains is its deep parallel computing architecture (DP). Most public chains can only process transaction execution stages in parallel, while Pharos, relying on custom hardware acceleration, achieves complete block lifecycle parallel operation, covering data availability, execution settlement, and consensus confirmation throughout the process.
By addressing the invisible performance bottlenecks 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 Atlantic Ocean testnet in October 2025, Pharos plans to launch the mainnet in the second quarter of 2026 and initiate the token generation event (TGE).
Project Background
Pharos was co-founded by Alex Zhang and Wish Wu in November 2024; both previously served as core senior executives in the blockchain infrastructure division of Ant Group. Among them, Alex Zhang was the CEO of Ant Group's Web3 subsidiary ZAN and CTO of AntChain; Wish Wu served as the Chief Security Officer of ZAN, focusing on institutional-level security compliance, with extensive 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 underlying public chain. The founding team gathers talent from top companies and institutions such as Microsoft, PayPal, Stanford University, and Ripple, with deep technical accumulation.
In November 2024, Pharos completed a $8 million seed round financing, jointly led by Hack VC and Lightspeed Faction. At the same time, the project has reached a deep strategic cooperation with ZAN, focusing on three core areas: building node infrastructure, security protection systems, and hardware performance acceleration, ensuring the network meets institutional-level stability standards.
Core Technology
Pharos regards the entire block lifecycle as a parallel scheduling process. The team believes that if only a single execution module is optimized, the network will ultimately still encounter significant performance bottlenecks in storage I/O read/write, consensus confirmation, and data distribution.
To eliminate these bottlenecks, Pharos adopts a modular protocol stack, decoupling the execution, consensus, and settlement processes, supported by a custom storage engine and dual virtual machine environments.
Consensus Layer
Traditional Byzantine Fault Tolerance (BFT) consensus relies on a single node to propose block generation, resulting in performance limits and single points of failure. Pharos breaks these limitations through a fully asynchronous BFT protocol that does not require fixed time assumptions; verification nodes can dynamically progress based on actual network conditions instead of passively waiting for timeouts.
Most round-based BFT protocols need to wait for the final confirmation of the previous round before continuing, limiting throughput due to maximum latency; Pharos decouples the block proposal stage from the confirmation stage, allowing verification nodes to handle transactions based on real-time network capacity, preventing stalls during extreme fluctuations while balancing liveness and security. Even under completely asynchronous conditions where message passing times are unpredictable, the protocol can maintain liveness.
To prevent network congestion caused by duplicate transactions, a deterministic mapping algorithm assigns each transaction to a designated validation node. The diagram above clearly explains this: memory pool transaction sharding distribution, validation node 1 handles transactions 1 and 2, validation node 2 handles transactions 3 and 4, validation node 3 handles transaction 5; this round, validation node 4 has no assigned tasks and remains idle, not broadcasting redundant data. Active validation nodes independently package their own transactions to generate block proposals. Ultimately, network resources scale linearly with validation nodes (doubling the node set ≈ doubling proposal bandwidth) without creating idle redundant nodes.
After validation nodes synchronously submit all proposals, the entire network intensively conducts pairwise cross-voting. If more than two-thirds of validation nodes reach consensus on a proposal, the network merges reliable broadcasting and consensus voting, requiring only three rounds of communication 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 virtual machine architecture.
DTVM Stack
DTVM natively supports EVM and WASM execution in a single runtime, eliminating the need for independent virtual machines, enabling seamless cross-calls between Solidity contracts and those written in Rust, Go, C++, etc. To enforce strict determinism across all hardware, DTVM compiles all bytecode into a deterministic intermediate lower representation (dMIR), eliminating floating-point ambiguities and undefined exception captures. dMIR standardizes halting rules and fixed value arithmetic logic, complemented by an 8MB fixed virtual call stack (maximum depth 1024), unaffected by host architecture restrictions, ensuring that x86 and ARM node ledgers are completely consistent.
As dMIR serves as a multi-byte code frontend and universal backend, a single optimized just-in-time (JIT) engine can adapt to EVM, WASM, and potential RISC-V contracts, avoiding fragmented redundant overhead from multiple virtual machine architectures. Only modules successfully compiled into dMIR format are allowed to execute on-chain, naturally reinforcing determinism thresholds.
To reduce the inherent latency of traditional just-in-time compilation, DTVM integrates the Zeta engine. Most blockchain virtual machines face a dilemma: full pre-compiled deployment latency versus first-call just-in-time compilation latency. Zeta breaks down contract-level compilation logic to 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 function compilation is not completed when a lightweight placeholder just-in-time compilation is triggered, the subsequent calls go directly to native code. Tests show that the latency for the first call is only 0.95 milliseconds, and from the second call onward, it executes native code throughout.
Pharos Pipeline
The Pharos pipeline integrates all components in series, breaking the serial block lifecycle into concurrent stages. Ordinary blockchains strictly follow the order of 'proposal → execution → confirmation', with each stage waiting for the previous one to complete before proceeding. Pharos relies on a 64-core framework to dynamically allocate CPU and disk I/O resources, running execution, Merkle hashing, and state final confirmation in parallel, with no idle hardware throughout.
This architecture simultaneously supports flexible multi-tier finality: distinguishing between ordering finality (permanently locking transaction order), transaction finality (deterministic execution results), and block finality (complete access rights to the entire network block). For applications sensitive to low latency, such as transactions and games, there is no need to wait for the final confirmation of a complete block; they can obtain transaction ordering and execution results in advance, greatly optimizing user experience; infrastructure such as oracles and block indexing must wait for the final confirmation of a complete block.
The Pharos pipeline architecture helps Pharos achieve a throughput of 500,000 transactions per second in an optimized environment, reducing delays by 30% to 50% compared to traditional serial pipelines.
Ph-WASM
EVM natively does not adapt to compute-intensive tasks: 256-bit base word length, stack-based underlying architecture, and lack of support for modern hardware features impose hard performance limits. Ph-WASM is a dedicated WebAssembly runtime customized for Pharos, running in parallel with EVM, handling high-throughput loads including artificial intelligence model scheduling, perpetual contract on-chain trading, and zero-knowledge proof verification. It integrates advanced compilation optimizations such as single-instruction multiple data vector acceleration and opcode fusion, ensuring efficient and low-consumption throughout CPU-intensive calculations and I/O-intensive interactions.
Practical value: Developers write key performance logic in languages such as Rust and C++, deploying it to Ph-WASM; existing Solidity contracts continue to operate on EVM. The two types of virtual machines are unified and compiled into dMIR, allowing Solidity contracts to natively call Rust contracts without bridges, nested virtual machine executions, or process communication overhead. Asset liquidity and composability are globally unified. For example, the funding pool logic of a DeFi protocol is developed in Solidity to fit the ecosystem, while the real-time pricing engine is downscaled to Rust contracts in Ph-WASM, meeting the dynamic real-time application throughput requirements.
Storage Layer
The bloated state of the ledger and slow disk I/O is an invisible fatal shortcoming for on-chain scalability. Even with top-tier high-speed execution engines, waiting for traditional Merkle Patricia Tree (MPT) disk reads will still cause stalling. For example, querying the state of a single Ethereum account requires 8 to 10 independent disk reads; the hash addressing mechanism leads to frequent database compression and sorting, consuming massive disk bandwidth. After the network scales to hundreds of millions of accounts, the cumulative costs mentioned above will ultimately make storage a bottleneck for throughput.
Pharos Store is a chain-native storage engine built on the principles of log-structured efficient and 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 overlaying Merkle tree' standard dual-layer design, it directly embeds the Merkle tree into the underlying storage engine. This move reduces the I/O path from 8 to 10 disk reads down to 1 to 3, with structural optimizations continuously magnifying with each network transaction.
The engine organizes data based on three major proprietary customized structures:
Incremental multi-version Merkle tree (DMM-Tree): A highly branched Merkle tree natively integrates incremental encoding, persisting only modified state changes without requiring full node rewrites.
Log-structured paginated version storage (LSVPS): Provides an abstraction for paging indexes between memory and disk for the incremental multi-version Merkle tree, using monotonically increasing version numbers instead of hash addressing. The version index eliminates the frequent compression stalling of traditional log-structured trees, 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 rapid recovery after node failures.
According to official data, Pharos Store reduces overall storage costs by 80%, with I/O throughput being 15.8 times that of the combination of Ethereum's Merkle Patricia Tree and hierarchical databases. For deep optimization of parallel execution, the engine supports concurrent reads, multi-threaded Merkle hash calculations, and non-blocking writes, ensuring that the storage layer matches the execution layer's speed without reverse throttling. The system supports layered hot and cold storage, automatically migrating old block data from high-speed solid-state drives to low-cost archival storage; the boundary scanning mechanism has been tested and implemented, resulting in a reduction of storage space by over 42%.
Network Layer
The network layer supports Pharos system-wide communication through an optimized P2P chatting protocol, achieving low-latency message propagation. The system adapts bandwidth allocation based on real-time network load, ensuring efficient distribution of transactions and data under extreme pressure scenarios.
Dedicated Processing Network (SPNs)
Pharos launches Dedicated Processing Networks (SPNs) to support modular application-specific scaling. SPNs are essentially custom 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 loads that are impractical or uneconomical for general public chains, including fully homomorphic encryption (FHE), multi-party secure computation (MPC), artificial intelligence model inference, and high-frequency trading.
SPNs rely on native re-staking to initiate security: Pharos mainnet validation nodes stake native tokens to obtain liquidity staking certificates, which can then be re-staked to one or multiple SPNs subnets. This builds a shared security protection system, ensuring the safe launch of dedicated subnets and financial efficiency, without requiring each new network to independently recruit a collection of validation nodes from scratch.
Users can achieve asset and data transfer between subnets and the main chain through the SPNs interoperability protocol, built on three core components: message inbox, registry, and cross-chain bridge. Unlike general Layer 2 networks, this protocol is deeply natively integrated with Pharos's mainnet, supporting low-latency message relaying and atomic asset transfers, avoiding common liquidity fragmentation issues in multi-chain architectures.
Complete process of cross-subnet communication:
Users initiate cross-subnet transactions in SPN1, specifying execution to the SPN2 message queue.
Relay nodes carry transactions, encrypted credentials, and block headers to synchronize with the mainnet.
The mainnet verifies the authenticity of transactions, archiving them into the message inbox as the global authoritative data source for cross-subnet messages.
SPN2 reads data from the message inbox, archiving it into the local message inbox, completing the execution handover.
The entire process relies on two layers of core smart contracts for control: the SPN adaptation contract is responsible for protocol layer message verification and cross-subnet routing; the SPN management contract oversees subnet lifecycle, registry status, and governance rules, ensuring that each SPN configuration is consistent with the global Pharos network. The two types of components collaborate without needing a trusted intermediary, enabling atomic execution across subnets and verifiable data sharing.
Design a native built-in emergency safety escape mechanism: regardless of the behavior of the SPN subnet operator, users can always forcibly withdraw assets back to the main chain, ensuring anti-censorship properties, adaptable to high-risk high-value scenarios such as DeFi derivatives and institutional assets.
Ecosystem
In preparation for the mainnet launch and TGE in the second quarter of 2026, the Pharos Foundation is coordinating the construction of a comprehensive ecosystem covering real-world assets (RWAs), BTCFi, decentralized exchanges, perpetual decentralized exchanges, prediction markets, liquid staking (LST), yield farming automation, AI smart banking, lending protocols, as well as essential infrastructure such as indexing, oracles, multi-signatures, block explorers, security, cross-chain interoperability, and wallets.
The ecosystem focuses on the 'RealFi' real finance track: unlike the on-chain yields of native crypto assets DeFi, it aims to build institutional-level on-chain finance based on real-world assets. RealFi is open to unrestricted access by default, with RWAs made available to all users through issuers like Centrifuge, which will launch tokenized U.S. treasury products JTRSY and AAA-rated structured credit products JAAA on Pharos.
The primary obstacle to the on-chain landing of institutional-level real assets is ecosystem fragmentation, prompting the Pharos Foundation to formally launch 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. Pharos's real asset market natively integrates Chainlink's data stream price oracle. LayerZero provides a global cross-chain interoperability protocol, and TopNod offers secure self-custody native wallets.
Centrifuge issues highly liquid and highly composable RWAs based on the deRWA real asset standard, encapsulating existing tokenized securities into freely circulating tokens compatible with DeFi protocols.
The first batch of federally compliant crypto banks in the United States, Anchorage Digital, provides institutional-level asset custody, token minting, and distribution services, covering the assets of institutional investors in Pharos TGE.
The R25 launch focuses on structured credit and transparent yield design for real asset-specific protocols.
Faroo creates a native liquidity staking protocol for real assets on Pharos.
The RealFi Alliance will expand in an orderly manner in batches, with subsequent members selected based on asset quality, technological maturity, and ecosystem collaboration standards. In addition, Pharos 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
Pharos's core underlying design philosophy is that merely parallelizing transaction execution is insufficient to overcome performance bottlenecks. By designing the entire lifecycle of a block as a concurrent process, the network aims to address the structural bottlenecks that have long limited the throughput of Layer 1 public chains. Its DTVM stack unifies EVM and WASM under a single deterministic runtime, and Pharos Store strives to reduce storage I/O from 8 to 10 disk reads to 1 to 3, directly targeting the long-neglected shortcomings of on-chain scalability.
The dedicated processing network is expected to provide a modular expansion path, avoiding liquidity fragmentation in independent execution environments. TGE and the mainnet are expected to launch in the second quarter of 2026, and the future development of the project will ultimately depend on its ability to translate architectural design into actual network performance, as well as the level of adoption of RealFi on Pharos.