Key Insights
- Pharos is a modular Layer 1 blockchain designed to function international infrastructure for real-world belongings (RWAs), based by former Ant Group executives who led its blockchain infrastructure group.
- Not like different chains that solely parallelize execution, Pharos targets the whole block lifecycle, consensus, execution, storage, and information availability as a concurrent course of, aiming to maintain 30,000 transactions per second (TPS) on mainnet.
- Pharos Retailer embeds the Merkle tree immediately into the storage engine itself, collapsing the I/O path from eight to 10 disk reads down to 1 to a few. This targets an under-the-radar bottleneck that caps throughput on even the quickest parallel chains.
- Pharos unifies EVM and WASM below a single deterministic runtime (DTVM), permitting Solidity contracts to natively name Rust contracts with no bridges or cross-VM overhead.
- Particular Processing Networks (SPNs) let builders spin up application-specific execution layers for demanding workloads, akin to derivatives buying and selling and ZK verification, inheriting mainnet safety by means of native restaking quite than bootstrapping a brand new validator set from scratch.
Introduction
Pharos is a high-performance, modular Layer 1 blockchain designed to function international infrastructure for real-world belongings (RWAs). The community gives sub-second block instances and may deal with a billion concurrent customers. Its mission is to create an inclusive monetary system that gives the velocity of Web2 methods whereas sustaining the decentralized safety of a public blockchain. By prioritizing high quality over amount in its asset ecosystem, Pharos goals to unlock liquidity for each financially underserved communities and established establishments.
What differentiates Pharos from different EVM networks is its excessive diploma of parallelism (DP). Not like different chains that solely parallelize transaction execution, Pharos can run the whole lifecycle of a block (information availability, execution, settlement, and consensus) concurrently, utilizing specialised {hardware} to spice up efficiency. By eradicating these hidden bottlenecks at each stage of the block lifecycle, Pharos can maintain 30,000 transactions per second (TPS) and a couple of Gigabits per second, making certain the community can deal with the worldwide scale of a billion customers concurrently.
After the success of its AtlanticOcean testnet (launched October 2025), Pharos is now making ready for its mainnet launch and Token Technology Occasion (TGE) in Q2 2026.
Background
Pharos was based in November 2024 by Alex Zhang and Want Wu, former executives of the blockchain infrastructure group at Ant Group, a fintech affiliate of Alibaba Group. Zhang served because the CEO of ZAN, a Web3 subsidiary of Ant Group Digital Applied sciences, and beforehand because the CTO of AntChain. Wu served because the Chief Safety Officer at ZAN, bringing intensive expertise in institutional-grade safety and compliance.
Pharos was established as a spin-out to rework this infrastructure right into a decentralized and public Layer 1 blockchain. The founding group combines deep technological experience with backgrounds from Microsoft, PayPal, Stanford, and Ripple. In November 2024, Pharos raised an $8 million seed spherical co-led by Hack VC and Lightspeed Faction. Alongside this funding, Pharos entered a strategic partnership with ZAN centered on node infrastructure, safety, and {hardware} acceleration to make sure the community is provided for institutional-grade reliability.
Know-how
Pharos targets the whole block lifecycle as a parallel course of. Its structure is constructed on the precept that if solely execution is parallelized, the community will inevitably bottleneck on the storage I/O, consensus, or information availability phases.
To remove these bottlenecks, Pharos employs a modular stack that decouples execution, consensus, and settlement, underpinned by a custom-built storage engine and a dual-virtual machine surroundings.
Consensus Layer
Conventional Byzantine-Fault-Tolerant (BFT) consensus mechanisms depend on a single chief to suggest a block, making a efficiency ceiling and a single level of failure. Pharos eliminates this constraint by means of a completely asynchronous BFT protocol that operates with out mounted timing assumptions, permitting validators to advance dynamically primarily based on precise community circumstances quite than arbitrary timeouts. Most round-based BFT protocols require the community to attend for prior rounds to finalize earlier than continuing, tying throughput to worst-case latency. Pharos decouples the block proposing section from the committing section, so validators course of transactions primarily based on real-time community capability. This prevents stalls throughout unstable circumstances and maximizes throughput with out sacrificing security ensures. The protocol maintains liveness even below full asynchrony, the place message supply instances are unpredictable.
To forestall duplicate transactions from flooding the community, a deterministic mapping algorithm assigns every transaction to a delegated validator. The diagram above illustrates this clearly. Transactions from the mempool are partitioned in order that validator1 receives tx1 and tx2, validator2 receives tx3 and tx4, and validator3 receives tx5, whereas validator4, having no assigned transactions on this spherical, sits idle quite than rebroadcasting redundant information. Every lively validator then packages its assigned transactions into an unbiased proposal. The result’s that community sources scale linearly as validators be a part of (doubling the validator set roughly doubles the mixture proposal bandwidth), quite than creating extra idle nodes.
As soon as validators concurrently submit their proposals, all proposals feed right into a dense all-to-all voting course of. If no less than two-thirds of validators agree on the proposals, the community merges dependable broadcast and consensus voting right into a single streamlined course of that commits the block in simply three communication rounds. The output is a single finalized block containing the deduplicated, ordered transaction record.
Execution Layer
On the coronary heart of the Pharos execution layer is the DeTerministic Digital Machine (DTVM) stack, which replaces the usual sequential processing mannequin with a parallel, dual-VM structure.
The DTVM Stack
DTVM natively helps each EVM and WASM execution below a single runtime, eliminating the necessity for separate digital machines and enabling frictionless cross-contract interoperability between Solidity contracts and people written in languages like Rust, Go, and C++. To implement strict determinism throughout various {hardware}, DTVM compiles all bytecode right into a Deterministic Center Intermediate Illustration (dMIR), a unified, platform-agnostic translation layer that strips out non-deterministic behaviors akin to floating-point ambiguities and unspecified lure dealing with. dMIR enforces standardized halt circumstances, strict numerical computation guidelines, and a fixed-size digital name stack (8MB with a 1,024-call depth restrict) unbiased of the host system, guaranteeing actual state replication throughout each node no matter whether or not it runs on x86 or ARM.
As a result of dMIR acts as a typical backend for a number of bytecode frontends, a single optimized Simply-In-Time (JIT) compiler can service EVM, WASM, and doubtlessly RISC-V contracts, avoiding the fragmentation and redundant VM overhead that plagues multi-VM architectures. Solely modules that efficiently compile to dMIR are cleared for execution, making the IR itself a determinism gatekeeper.
To reduce the latency historically related to JIT compilation, DTVM incorporates the Zeta Engine. Most blockchain VMs face an uncomfortable tradeoff between compiling every thing upfront and delaying deployment, or compiling on first invocation and delaying execution. Zeta sidesteps this by compiling on the perform stage quite than the contract stage. When a contract is deployed, the engine validates it, generates dMIR, and begins compiling particular person capabilities asynchronously within the background. If a perform is named earlier than its compilation finishes, a light-weight stub triggers on-demand compilation after which patches itself so that each subsequent name hits optimized native code immediately. The result’s a first-invocation latency of simply 0.95 milliseconds, with native code execution from the second name onward.
Pharos Pipelining
Pharos Pipelining ties these elements collectively by deconstructing the sequential block lifecycle into concurrent phases. In a typical blockchain, a block is proposed, then executed, and at last dedicated, with every stage ready for the earlier to complete. Pharos runs execution, merklization, and state finalization concurrently in overlapping pipelines utilizing a 64-core framework that dynamically allocates CPU and disk I/O sources, so {hardware} is rarely sitting idle.
This structure additionally gives versatile, multi-tier finality. Pharos separates ordering finality (everlasting transaction sequencing), transaction finality (deterministic execution outcomes), and block finality (entry to the totally finalized block). Purposes can obtain early affirmation of transaction ordering and execution outcomes earlier than the block totally finalizes, a significant UX enchancment for latency-sensitive use circumstances like buying and selling and gaming, whereas infrastructure elements like oracles and indexers await full block finality.
This pipelining permits Pharos to attain a throughput of 500,000 TPS in optimized environments, leading to 30-50% decrease latency than conventional sequential pipelining fashions.
Ph-WASM
The EVM is traditionally inefficient for compute-intensive duties; its 256-bit phrase measurement, stack-based structure, and lack of native help for contemporary {hardware} options impose a tough efficiency ceiling. Ph-WASM is Pharos’ specialised WebAssembly runtime, designed to run alongside the EVM and deal with workloads that demand greater throughput, akin to AI mannequin orchestration, onchain buying and selling of perpetual futures onchain, and ZK proof verification. Excessive-level compiler optimizations, together with SIMD vectorization and opcode fusion, hold each CPU-bound and I/O-bound operations quick and resource-efficient.
The sensible impression is that builders can write performance-critical logic in languages like Rust or C++ and deploy it to Ph-WASM whereas preserving their current Solidity contracts on the EVM facet. As a result of each VMs compile all the way down to the identical dMIR layer, a Solidity contract can name a Rust contract natively, no bridges, no nested VM execution, no inter-process communication overhead. This implies liquidity and composability keep unified throughout each runtimes. A DeFi protocol, for instance, may run its user-facing vault logic in Solidity for ecosystem compatibility whereas offloading its pricing engine to a Rust contract on Ph-WASM for the uncooked throughput that dynamic, real-time functions require.
Storage Layer
State bloat and sluggish disk I/O are the silent killers of onchain scalability. Even the quickest execution engine will stall if it has to attend for a standard Merkle Patricia Trie (MPT) to learn from disk. Ethereum’s MPT, as an illustration, requires eight to 10 separate disk reads simply to entry a single account’s state, and its hash-based addressing causes fixed database compactions that devour large quantities of disk bandwidth. As a community scales to a whole lot of tens of millions of accounts, these prices compound till storage turns into the binding constraint on throughput, not execution or consensus.
Pharos Retailer is a blockchain-native storage engine constructed on Log-Structured Environment friendly Trusted Common Storage (LETUS) rules, designed to remove these bottlenecks on the architectural stage. Its core innovation is Authenticated Knowledge Construction (ADS) pushdown. Quite than layering a Merkle tree on high of a separate key-value database (the usual two-layer design), Pharos Retailer embeds the Merkle tree immediately into its storage engine. This collapses the I/O path from eight to 10 disk reads down to 1 to a few, a structural enchancment that compounds with each transaction the community processes.
The engine organizes information round three purpose-built buildings:
- The Delta-Encoded Multi-Model Merkle Tree (DMM-Tree) is a high-fanout Merkle tree with built-in delta-encoding, which means solely modified state adjustments are endured quite than full node rewrites.
- The Log-Structured Versioned Web page Retailer (LSVPS) gives a page-level index abstraction between reminiscence and disk for the DMM-Tree, utilizing monotonically growing model numbers as an alternative of hash-based addressing. This version-based indexing eliminates the heavy compaction cycles that plague conventional LSM-tree backends, decreasing disk bandwidth consumption by 96.5%.
- The Versioned Knowledge Logging Stream (VDLS) shops consumer metadata in an append-only log, making certain information integrity and enabling quick restoration after node crashes.
In response to the group, Pharos Retailer reduces storage overhead by 80% and delivers 15.8 instances the I/O throughput of Ethereum’s MPT and LevelDB stack. For parallel execution particularly, the engine helps concurrent reads, multi-threaded Merkle hash computation, and non-blocking writes, making certain that storage retains tempo with the execution layer quite than throttling it. The system additionally helps tiered storage, robotically migrating older block information from quick SSDs to cheaper archival storage, and boundary-scan-based pruning that has decreased storage footprints by over 42% in manufacturing checks.
Networking Layer
The networking layer underpins all communication within the Pharos system utilizing an optimized P2P gossip protocol for low-latency message propagation. The system implements adaptive bandwidth allocation primarily based on real-time community load, making certain environment friendly transaction and information dissemination even below stress.
Particular Function Networks (SPNs)
Pharos introduces Particular Processing Networks (SPNs) to permit for modular, application-specific scaling. An SPN is basically a {custom} execution layer that inherits Pharos’ safety whereas working semi-independently with its personal consensus parameters and logic. Builders can configure an SPN for compute-intensive workloads that will be impractical or uneconomical to run on a general-purpose chain, akin to Absolutely Homomorphic Encryption (FHE), multiparty computation (MPC), AI mannequin inference, and high-frequency buying and selling.
SPNs bootstrap their safety by means of native restaking. Validators on the Pharos mainnet can stake native tokens and obtain a liquid staking certificates, which they then restake into a number of SPNs. This creates a shared safety blanket that makes launching a specialised sub-network each safe and capital-efficient, quite than forcing every new surroundings to draw its personal unbiased validator set from scratch.
To maneuver belongings and information between SPNs and the primary chain, customers leverage the SPN Interoperability Protocol, which is constructed round three core elements: a Mailbox, a Registry, and a Bridge. Not like generic Layer-2s, this protocol is deeply built-in with Pharos’ main community, enabling low-latency message relaying and atomic asset transfers that forestall the liquidity fragmentation widespread in multichain architectures.
Cross-SPN communication depends on a number of steps:
- A consumer initiates a cross-SPN transaction inside SPN1, concentrating on execution in SPN2’s message queue.
- A Relayer transmits the transaction, together with its cryptographic proof and block header, to the Major Community.
- The Major Community verifies the transaction’s authenticity and information it within the Mailbox, serving because the canonical supply of reality for cross-SPN messages.
- SPN2 retrieves the message from the Mailbox and information it inside its personal native Mailbox, finishing the execution handoff.
This circulate is ruled by two key good contract layers. The SPN Adapter handles message verification and cross-SPN routing on the protocol stage, whereas the SPN Supervisor oversees lifecycle administration, registry state, and governance, making certain every SPN’s configuration stays in keeping with the broader Pharos community. Collectively, these elements allow atomic execution and verifiable information sharing throughout SPNs with out counting on trusted intermediaries.
The design additionally incorporates built-in escape hatches, making certain censorship resistance by guaranteeing that customers can all the time withdraw belongings to the primary chain no matter SPN operator conduct, a essential safeguard for high-stakes use circumstances like DeFi derivatives and institutional asset administration.
Ecosystem
In preparation for its mainnet launch and TGE in Q2 2026, Pharos Basis, the challenge’s nonprofit designed to supervise the event and ecosystem of Pharos Community options, has coordinated a complete ecosystem, inclusive of real-world belongings (RWAs), BTCfi, DEXs, Perp DEXs, a prediction market, liquid staking (LST), yield farming and automation, AI and agentic banking, lending and borrowing protocols, and infrastructure, together with indexing, RPC, oracles, multisig, block explorers, safety, crosschain interoperability, and wallets.
The ecosystem is targeted on “RealFi,” a time period used to explain institutional-grade finance constructed onchain by way of RWAs quite than DeFi yield from crypto native belongings. RealFi is meant to be open by default, with RWAs accessible to all by way of issuers like Centrifuge, which can be issuing its tokenized U.S. Treasuries product JTRSY and AAA-rated structured credit score product JAAA on Pharos.
To comprehend open entry to RWAs in an surroundings the place fragmentation stays the first barrier to institutional RWA adoption, Pharos Basis has introduced the RealFi Alliance. On Pharos, and below this alliance:
- Chainlink serves because the canonical crosschain infrastructure for safe messaging and information integrity. Pharos has additionally adopted Chainlink Knowledge Streams for value information for its RWA markets. LayerZero gives interoperability, and TopNod gives a safe self-custodial pockets.
- Centrifuge points freely transferable, totally composable RWAs by way of its deRWA token normal, which wraps current tokenized securities into freely transferable tokens totally composable with DeFi protocols.
- Anchorage Digital, the primary federally regulated crypto financial institution in the USA, gives institutional-grade custody, token minting, and asset distribution. This contains for enterprise traders receiving tokens from Pharos’ upcoming token technology occasion (TGE).
- R25 will introduce RWA-backed protocols centered on structured credit score and clear yield design.
- Faroo will present a liquid staking protocol for RWAs on Pharos.
The RealFi Alliance will broaden in structured batches, with future members chosen primarily based on asset high quality, technical readiness, and ecosystem alignment. On high of this, Pharos has introduced a $10 million RealFi builder incubator program designed to help early-stage groups constructing DeFi functions and infrastructure on Pharos. Companions for the incubator embrace Hack VC, Draper Dragon, Lightspeed Faction, and Centrifuge.
Closing Abstract
Pharos is constructed on the thesis that parallelizing transaction execution alone is inadequate. By designing the whole block lifecycle, consensus, execution, storage, and information availability as a concurrent course of, the community makes an attempt to handle the structural bottlenecks which have traditionally capped Layer 1 throughput. Its DTVM stack unifies EVM and WASM below a single deterministic runtime, whereas Pharos Retailer goals to break down storage I/O from eight to 10 disk reads down to 1 to a few, concentrating on what has lengthy been an ignored constraint on onchain scalability.
Particular Processing Networks may provide a modular path towards scaling with out fragmenting liquidity throughout remoted execution environments. With each TGE and mainnet launch anticipated in Q2 2026, the challenge’s trajectory will in the end be decided by its capacity to translate architectural design into dwell community efficiency and adoption of RealFi on Pharos.
