# Table of Contents

- [Pi Squared Blog - our vision for Proof of Proof and the Universal Settlement Layer](#pi-squared-blog-our-vision-for-proof-of-proof-and-the-universal-settlement-layer)
- [claims - Pi Squared Blog](#claims-pi-squared-blog)
- [VSL - Pi Squared Blog](#vsl-pi-squared-blog)
- [ULM - Pi Squared Blog](#ulm-pi-squared-blog)
- [zkVM Benchmarking - Pi Squared Blog](#zkvm-benchmarking-pi-squared-blog)
- [Semantics Based - Pi Squared Blog](#semantics-based-pi-squared-blog)
- [Proof of Proof - Pi Squared Blog](#proof-of-proof-pi-squared-blog)
- [Yi Zhang - Pi Squared Blog](#yi-zhang-pi-squared-blog)
- [Pi Squared - Pi Squared Blog](#pi-squared-pi-squared-blog)
- [USL - Pi Squared Blog](#usl-pi-squared-blog)
- [Shresth Agrawal - Pi Squared Blog](#shresth-agrawal-pi-squared-blog)
- [Vision - Pi Squared Blog](#vision-pi-squared-blog)
- [Ilja Zakharov - Pi Squared Blog](#ilja-zakharov-pi-squared-blog)
- [Ossie Amir - Pi Squared Blog](#ossie-amir-pi-squared-blog)
- [Nicholas Harness - Pi Squared Blog](#nicholas-harness-pi-squared-blog)
- [Siyuan Han - Pi Squared Blog](#siyuan-han-pi-squared-blog)
- [Dwight Guth - Pi Squared Blog](#dwight-guth-pi-squared-blog)
- [Ibrahim Yusufali - Pi Squared Blog](#ibrahim-yusufali-pi-squared-blog)
- [Musab Alturki - Pi Squared Blog](#musab-alturki-pi-squared-blog)
- [Bolton Bailey - Pi Squared Blog](#bolton-bailey-pi-squared-blog)
- [Xiaohong Chen - Pi Squared Blog](#xiaohong-chen-pi-squared-blog)
- [FastSet: To Blockchain or Not?](#fastset-to-blockchain-or-not-)
- [Grigore Rosu - Pi Squared Blog](#grigore-rosu-pi-squared-blog)
- [Looking Back at the VSL Devnet and What Comes Next](#looking-back-at-the-vsl-devnet-and-what-comes-next)
- [Introducing FastSet Pre-Release](#introducing-fastset-pre-release)
- [Introducing the VSL Devnet: A New Era of Fast Verifiability](#introducing-the-vsl-devnet-a-new-era-of-fast-verifiability)
- [Mirror to the Future: Why State Mirroring via the VSL is a Web3 Game Changer](#mirror-to-the-future-why-state-mirroring-via-the-vsl-is-a-web3-game-changer)
- [Unpacking the VSL: What are Claims?](#unpacking-the-vsl-what-are-claims-)
- [From TVL to TVU: Why Web3 Needs a New Narrative](#from-tvl-to-tvu-why-web3-needs-a-new-narrative)
- [Pi Squared’s Integration with Wormhole NTT](#pi-squared-s-integration-with-wormhole-ntt)
- [Matching logic and mathematical proofs of program execution](#matching-logic-and-mathematical-proofs-of-program-execution)
- [Pi Squared + pod: Faster Finality and Trustless Verification](#pi-squared-pod-faster-finality-and-trustless-verification)
- [Why Web3 Needs a Universal Settlement Layer](#why-web3-needs-a-universal-settlement-layer)
- [Pi Squared’s Universal Language Machine (ULM): Revolutionizing Web3 Development](#pi-squared-s-universal-language-machine-ulm-revolutionizing-web3-development)
- [Why We’re Renaming the Universal Settlement Layer / Introducing the VSL](#why-we-re-renaming-the-universal-settlement-layer-introducing-the-vsl)
- [Trust in Today's Blockchain Space](#trust-in-today-s-blockchain-space)
- [Revolutionizing Blockchain Interoperability: Insights from Pi Squared and Wormhole](#revolutionizing-blockchain-interoperability-insights-from-pi-squared-and-wormhole)
- [How to Bring a Million Developers to Web3](#how-to-bring-a-million-developers-to-web3)
- [How Formal Semantics Will Bring More Developers to Web3](#how-formal-semantics-will-bring-more-developers-to-web3)
- [Pi Squared’s Integration with EigenLayer](#pi-squared-s-integration-with-eigenlayer)
- [Benchmarking zkVMs on Metamath Proof Checking](#benchmarking-zkvms-on-metamath-proof-checking)
- [ABCDE: Why we invested in Pi Squared](#abcde-why-we-invested-in-pi-squared)
- [BYOL (Bring Your Own Language) to Web3](#byol-bring-your-own-language-to-web3)
- [Universality for Web3: Settling Transactions in Any Language or VM without Compilers](#universality-for-web3-settling-transactions-in-any-language-or-vm-without-compilers)
- [The Beginner's Guide To Proof Of Proof](#the-beginner-s-guide-to-proof-of-proof)
- [Pi Squared: The Next Generation of Verifiable Computing](#pi-squared-the-next-generation-of-verifiable-computing)
- [What are zkVMs?](#what-are-zkvms-)

---

# Pi Squared Blog - our vision for Proof of Proof and the Universal Settlement Layer

![Pi Squared Blog](https://blog.pi2.network/content/images/size/w2000/2025/06/Pi-Squared-Blog-Hero-Update.png)

[![Introducing FastSet Pre-Release](https://blog.pi2.network/content/images/size/w2000/2025/08/Pi2-Blog-Introducing-VSL-Devnet--2-.png)](https://blog.pi2.network/introducing-fastset-pre-release/)

[Get an early look at FastSet, the first fully decentralized Web3 infrastructure that delivers 100,000+ TPS, sub-100ms finality, and is verifiable by design.](https://blog.pi2.network/introducing-fastset-pre-release/)

[![FastSet: To Blockchain or Not?](https://blog.pi2.network/content/images/size/w2000/2025/07/Pi2-Blog-FastSet-to-Blockchain-or-Not.png)](https://blog.pi2.network/fastset-to-blockchain-or-not/)

[A surface dive into what FastSet is, but mainly what it is not.](https://blog.pi2.network/fastset-to-blockchain-or-not/)

[![Looking Back at the VSL Devnet and What Comes Next](https://blog.pi2.network/content/images/size/w2000/2025/07/Pi2-Blog-Looking-Back-at-the-VSL-Devnet.png)](https://blog.pi2.network/looking-back-at-the-vsl-devnet-and-what-comes-next/)

[Read what the team achieved and learned from the VSL Devnet and also what's to come with FastSet, the next evolution of our verifiability stack.](https://blog.pi2.network/looking-back-at-the-vsl-devnet-and-what-comes-next/)

[![Introducing the VSL Devnet: A New Era of Fast Verifiability](https://blog.pi2.network/content/images/size/w2000/2025/06/Pi2-Blog-Introducing-VSL-Devnet.png)](https://blog.pi2.network/introducing-the-vsl-devnet-a-new-era-of-fast-verifiability/)

[We’re excited to announce the launch of the Pi Squared VSL devnet, a developer-first environment for building, testing, and exploring the future of composable AI and blockchain infrastructure.](https://blog.pi2.network/introducing-the-vsl-devnet-a-new-era-of-fast-verifiability/)

[![Mirror to the Future: Why State Mirroring via the VSL is a Web3 Game Changer](https://blog.pi2.network/content/images/size/w2000/2025/06/Pi2-Blog-2025-05-02-Mirroring.png)](https://blog.pi2.network/mirror-to-the-future-why-state-mirroring-via-the-vsl-is-a-web3-game-changer/)

[State mirroring with the Verifiable Settlement Layer (VSL) enables blockchains to cryptographically synchronize and access each other’s state without bridges or trust assumptions, unlocking a new era of seamless, verifiable cross-chain applications.](https://blog.pi2.network/mirror-to-the-future-why-state-mirroring-via-the-vsl-is-a-web3-game-changer/)

[![Unpacking the VSL: What are Claims?](https://blog.pi2.network/content/images/size/w2000/2025/05/Pi2-Blog-Unpacking-VSL-What-are-claims.png)](https://blog.pi2.network/unpacking-the-vsl-what-are-claims/)

[Pi Squared’s Verifiable Settlement Layer (VSL) treats every verifiable action as a claim backed by flexible proofs, enabling fast, scalable, and trustless interoperability across Web3 systems.](https://blog.pi2.network/unpacking-the-vsl-what-are-claims/)

[![From TVL to TVU: Why Web3 Needs a New Narrative](https://blog.pi2.network/content/images/size/w2000/2025/05/Pi2-Blog-Web3-Needs-a-New-Narrative--1-.png)](https://blog.pi2.network/from-tvl-to-tvu-why-web3-needs-a-new-narrative-2/)

[Unlocking the future of Web3 through universality, verifiability, and seamless cross-chain access](https://blog.pi2.network/from-tvl-to-tvu-why-web3-needs-a-new-narrative-2/)

[![Why We’re Renaming the Universal Settlement Layer / Introducing the VSL](https://blog.pi2.network/content/images/size/w2000/2025/04/Pi2-Blog-USL-to-VSL--1-.png)](https://blog.pi2.network/why-were-renaming-the-universal-settlement-layer-introducing-the-vsl/)

[Reframing Web3’s foundation with verifiability, correctness, and security at its core](https://blog.pi2.network/why-were-renaming-the-universal-settlement-layer-introducing-the-vsl/)

[![Matching logic and mathematical proofs of program execution](https://blog.pi2.network/content/images/size/w2000/2025/03/Pi2-Blog-Hero-Graphic-Matching-Logic-and-Mathematical-Proofs.png)](https://blog.pi2.network/matching-logic-and-mathematical-proofs-of-program-execution/)

[Learn how Pi Squared uses matching logic and the K framework to mathematically prove that program executions are correct, enabling trustworthy and language-agnostic development tools.](https://blog.pi2.network/matching-logic-and-mathematical-proofs-of-program-execution/)

[![Trust in Today's Blockchain Space](https://blog.pi2.network/content/images/size/w2000/2025/03/2025-03-03---Pi2-Blog-Trust-in-Web3.png)](https://blog.pi2.network/trust-in-web3/)

[Trust in Web3 is fragile—just like a stolen childhood bike. Pi Squared’s Proof of Proof and USL make trust verifiable, reducing blind faith.](https://blog.pi2.network/trust-in-web3/)

[![Pi Squared + pod: Faster Finality and Trustless Verification](https://blog.pi2.network/content/images/size/w2000/2025/02/20205-02-13---Pod-Pi2-PoP-Ring-BlogHero-copy.jpg)](https://blog.pi2.network/pi2-pod/)

[Faster finality, trustless verification and optimized speed. We explore why Pi Squared's USL + pod is a win for Web3 devs and users.](https://blog.pi2.network/pi2-pod/)

[![Benchmarking zkVMs on Metamath Proof Checking](https://blog.pi2.network/content/images/size/w2000/2025/01/2025-01-28---Logo-garden-for-zkVM-Benchmarking-Opt-1-1.png)](https://blog.pi2.network/zkvm-benchmarking/)

[We evaluate the performance of zkVMs to validate mathematical proofs of on-chain transactions](https://blog.pi2.network/zkvm-benchmarking/)

[![Pi Squared’s Integration with EigenLayer](https://blog.pi2.network/content/images/size/w2000/2025/01/2025-01-08---Pi2-EigenLayer-Hero-V2.png)](https://blog.pi2.network/eigenlayer/)

[Pi Squared and EigenLayer are revolutionizing multi-language execution and settlement for dApps.](https://blog.pi2.network/eigenlayer/)

[![Revolutionizing Blockchain Interoperability: Insights from Pi Squared and Wormhole](https://blog.pi2.network/content/images/size/w2000/2024/12/Pi2-Wormhole-USL-Blog.png)](https://blog.pi2.network/usl-wormhole-recap/)

[Pi Squared and Wormhole unveiled the integration of our Universal Settlement Layer (USL) into Wormhole's Native Transfer Token (NTT) Framework.](https://blog.pi2.network/usl-wormhole-recap/)

[![Pi Squared’s Universal Language Machine (ULM): Revolutionizing Web3 Development](https://blog.pi2.network/content/images/size/w2000/2024/12/2024-12-10---Pi2-ULM-Blog-Hero.png)](https://blog.pi2.network/ulm/)

[Watch the launch of our Universal Language Machine (ULM) at Devcon. ULM enables developers to build in any programming language for any blockchain.](https://blog.pi2.network/ulm/)

[![Pi Squared’s Integration with Wormhole NTT](https://blog.pi2.network/content/images/size/w2000/2024/11/2024-09-25---Pi2---Wormhole-Blog.png)](https://blog.pi2.network/usl-wormhole/)

[Learn how USL's integration with Wormhole is a convergence of advanced technologies enhancing security and efficiency for cross-chain operations.](https://blog.pi2.network/usl-wormhole/)

[![How to Bring a Million Developers to Web3](https://blog.pi2.network/content/images/size/w2000/2024/10/2024-10-11---How-to-bring-million-developers-Blog.png)](https://blog.pi2.network/onboarding-developers-to-web3/)

[Breaking down barriers for global developer talent will revolutionize Web3, unleashing creativity and collaboration on a global scale.](https://blog.pi2.network/onboarding-developers-to-web3/)

[![Universality for Web3: Settling Transactions in Any Language or VM without Compilers](https://blog.pi2.network/content/images/size/w2000/2024/10/2024-09-27---Pi2-Blog-Universality---Settling-Transactions-in-Any-Language.jpg)](https://blog.pi2.network/byol-web3-interoperability/)

[We explore how Bring Your Own Language (BYOL) is the key to Web3 interoperability.](https://blog.pi2.network/byol-web3-interoperability/)

[![ABCDE: Why we invested in Pi Squared](https://blog.pi2.network/content/images/size/w2000/2024/09/2024-09-23---Graphic-ABCDE-Why-We-Invest-Blog.png)](https://blog.pi2.network/abcde-why-we-invested/)

[How Siyuan Han of crypto fund ABCDE envisions Pi Squared’s approach to verifiable computing delivering greater efficiency and security for Web3.](https://blog.pi2.network/abcde-why-we-invested/)

[![How Formal Semantics Will Bring More Developers to Web3](https://blog.pi2.network/content/images/size/w2000/2024/09/2024-09-01---Pi2-LLVM-Hero-Galaxy-Cluster.png)](https://blog.pi2.network/how-formal-semantics-will-bring-more-developers-to-web3/)

[It needs to be easier for developers to write smart contracts. Learn how formal semantics let developers build in any programming language.](https://blog.pi2.network/how-formal-semantics-will-bring-more-developers-to-web3/)

[![BYOL (Bring Your Own Language) to Web3](https://blog.pi2.network/content/images/size/w2000/2024/09/2024-09-10---BlogPost-Universality-Hero-R4.png)](https://blog.pi2.network/byol/)

[In our first guest post Ibrahim Yusufali, Investor at Polychain Capital, explains how Pi Squared will enable millions of Web3 dApps.](https://blog.pi2.network/byol/)

[![Introduction to zkVMs](https://blog.pi2.network/content/images/size/w2000/2024/08/2024-08-27---Pi2-zkVM-Hero-Black-Hole.png)](https://blog.pi2.network/intro-to-zkvms/)

[zkVMs make it easier for developers to build on-chain apps. What are they, and how do they work?](https://blog.pi2.network/intro-to-zkvms/)

[![Why Web3 Needs a Universal Settlement Layer](https://blog.pi2.network/content/images/size/w2000/2024/08/Pi2-USL-Universe.png)](https://blog.pi2.network/why-web3-needs-usl/)

[Web3 developers are forced to trust that critical systems are operating accurately. How do they verify that these systems are working as intended?](https://blog.pi2.network/why-web3-needs-usl/)

[![The Beginner's Guide To Proof Of Proof](https://blog.pi2.network/content/images/size/w2000/2024/08/2024-08-01---Pi2-Blog-PoP-Hero.png)](https://blog.pi2.network/guide-to-proof-of-proof/)

[In this post, we dive deeper into Proof of Proof to provide background for new entrants into the expanding Pi Squared universe.](https://blog.pi2.network/guide-to-proof-of-proof/)

[![Pi Squared: The Next Generation of Verifiable Computing](https://blog.pi2.network/content/images/size/w2000/2024/07/2024-07-30---Pi2-USL-Graphic-V1-1.png)](https://blog.pi2.network/pi-squared-the-next-generation-of-verifiable-computing/)

[Our Founder & CEO talks about how Pi Squared’s Universal Settlement Layer will unify the fractured Web3 space.](https://blog.pi2.network/pi-squared-the-next-generation-of-verifiable-computing/)

---

# claims - Pi Squared Blog

A collection of 1 post

[![Unpacking the VSL: What are Claims?](https://blog.pi2.network/content/images/size/w2000/2025/05/Pi2-Blog-Unpacking-VSL-What-are-claims.png)](https://blog.pi2.network/unpacking-the-vsl-what-are-claims/)

[Pi Squared’s Verifiable Settlement Layer (VSL) treats every verifiable action as a claim backed by flexible proofs, enabling fast, scalable, and trustless interoperability across Web3 systems.](https://blog.pi2.network/unpacking-the-vsl-what-are-claims/)

---

# VSL - Pi Squared Blog

A collection of 5 posts

[![Looking Back at the VSL Devnet and What Comes Next](https://blog.pi2.network/content/images/size/w2000/2025/07/Pi2-Blog-Looking-Back-at-the-VSL-Devnet.png)](https://blog.pi2.network/looking-back-at-the-vsl-devnet-and-what-comes-next/)

[Read what the team achieved and learned from the VSL Devnet and also what's to come with FastSet, the next evolution of our verifiability stack.](https://blog.pi2.network/looking-back-at-the-vsl-devnet-and-what-comes-next/)

[![Introducing the VSL Devnet: A New Era of Fast Verifiability](https://blog.pi2.network/content/images/size/w2000/2025/06/Pi2-Blog-Introducing-VSL-Devnet.png)](https://blog.pi2.network/introducing-the-vsl-devnet-a-new-era-of-fast-verifiability/)

[We’re excited to announce the launch of the Pi Squared VSL devnet, a developer-first environment for building, testing, and exploring the future of composable AI and blockchain infrastructure.](https://blog.pi2.network/introducing-the-vsl-devnet-a-new-era-of-fast-verifiability/)

[![Mirror to the Future: Why State Mirroring via the VSL is a Web3 Game Changer](https://blog.pi2.network/content/images/size/w2000/2025/06/Pi2-Blog-2025-05-02-Mirroring.png)](https://blog.pi2.network/mirror-to-the-future-why-state-mirroring-via-the-vsl-is-a-web3-game-changer/)

[State mirroring with the Verifiable Settlement Layer (VSL) enables blockchains to cryptographically synchronize and access each other’s state without bridges or trust assumptions, unlocking a new era of seamless, verifiable cross-chain applications.](https://blog.pi2.network/mirror-to-the-future-why-state-mirroring-via-the-vsl-is-a-web3-game-changer/)

[![Unpacking the VSL: What are Claims?](https://blog.pi2.network/content/images/size/w2000/2025/05/Pi2-Blog-Unpacking-VSL-What-are-claims.png)](https://blog.pi2.network/unpacking-the-vsl-what-are-claims/)

[Pi Squared’s Verifiable Settlement Layer (VSL) treats every verifiable action as a claim backed by flexible proofs, enabling fast, scalable, and trustless interoperability across Web3 systems.](https://blog.pi2.network/unpacking-the-vsl-what-are-claims/)

[![Why We’re Renaming the Universal Settlement Layer / Introducing the VSL](https://blog.pi2.network/content/images/size/w2000/2025/04/Pi2-Blog-USL-to-VSL--1-.png)](https://blog.pi2.network/why-were-renaming-the-universal-settlement-layer-introducing-the-vsl/)

[Reframing Web3’s foundation with verifiability, correctness, and security at its core](https://blog.pi2.network/why-were-renaming-the-universal-settlement-layer-introducing-the-vsl/)

---

# ULM - Pi Squared Blog

A collection of 2 posts

[![Pi Squared’s Integration with EigenLayer](https://blog.pi2.network/content/images/size/w2000/2025/01/2025-01-08---Pi2-EigenLayer-Hero-V2.png)](https://blog.pi2.network/eigenlayer/)

[Pi Squared and EigenLayer are revolutionizing multi-language execution and settlement for dApps.](https://blog.pi2.network/eigenlayer/)

[![Pi Squared’s Universal Language Machine (ULM): Revolutionizing Web3 Development](https://blog.pi2.network/content/images/size/w2000/2024/12/2024-12-10---Pi2-ULM-Blog-Hero.png)](https://blog.pi2.network/ulm/)

[Watch the launch of our Universal Language Machine (ULM) at Devcon. ULM enables developers to build in any programming language for any blockchain.](https://blog.pi2.network/ulm/)

---

# zkVM Benchmarking - Pi Squared Blog

A collection of 2 posts

[![Benchmarking zkVMs on Metamath Proof Checking](https://blog.pi2.network/content/images/size/w2000/2025/01/2025-01-28---Logo-garden-for-zkVM-Benchmarking-Opt-1-1.png)](https://blog.pi2.network/zkvm-benchmarking/)

[We evaluate the performance of zkVMs to validate mathematical proofs of on-chain transactions](https://blog.pi2.network/zkvm-benchmarking/)

[![Introduction to zkVMs](https://blog.pi2.network/content/images/size/w2000/2024/08/2024-08-27---Pi2-zkVM-Hero-Black-Hole.png)](https://blog.pi2.network/intro-to-zkvms/)

[zkVMs make it easier for developers to build on-chain apps. What are they, and how do they work?](https://blog.pi2.network/intro-to-zkvms/)

---

# Semantics Based - Pi Squared Blog

A collection of 1 post

[![How Formal Semantics Will Bring More Developers to Web3](https://blog.pi2.network/content/images/size/w2000/2024/09/2024-09-01---Pi2-LLVM-Hero-Galaxy-Cluster.png)](https://blog.pi2.network/how-formal-semantics-will-bring-more-developers-to-web3/)

[It needs to be easier for developers to write smart contracts. Learn how formal semantics let developers build in any programming language.](https://blog.pi2.network/how-formal-semantics-will-bring-more-developers-to-web3/)

---

# Proof of Proof - Pi Squared Blog

A collection of 2 posts

[![Trust in Today's Blockchain Space](https://blog.pi2.network/content/images/size/w2000/2025/03/2025-03-03---Pi2-Blog-Trust-in-Web3.png)](https://blog.pi2.network/trust-in-web3/)

[Trust in Web3 is fragile—just like a stolen childhood bike. Pi Squared’s Proof of Proof and USL make trust verifiable, reducing blind faith.](https://blog.pi2.network/trust-in-web3/)

[![The Beginner's Guide To Proof Of Proof](https://blog.pi2.network/content/images/size/w2000/2024/08/2024-08-01---Pi2-Blog-PoP-Hero.png)](https://blog.pi2.network/guide-to-proof-of-proof/)

[In this post, we dive deeper into Proof of Proof to provide background for new entrants into the expanding Pi Squared universe.](https://blog.pi2.network/guide-to-proof-of-proof/)

---

# Yi Zhang - Pi Squared Blog

![Yi Zhang](https://blog.pi2.network/content/images/2025/02/Zhang-Yi.webp)

Yi is Chief Architect at Pi Squared, working on the design and implementation of the Universal Settlement Layer. Prior to Pi Squared, Yi worked at DARPA as well as Google's Laser and YouTube teams.

[![Pi Squared + pod: Faster Finality and Trustless Verification](https://blog.pi2.network/content/images/size/w2000/2025/02/20205-02-13---Pod-Pi2-PoP-Ring-BlogHero-copy.jpg)](https://blog.pi2.network/pi2-pod/)

[Faster finality, trustless verification and optimized speed. We explore why Pi Squared's USL + pod is a win for Web3 devs and users.](https://blog.pi2.network/pi2-pod/)

---

# Pi Squared - Pi Squared Blog

[![Introducing FastSet Pre-Release](https://blog.pi2.network/content/images/size/w2000/2025/08/Pi2-Blog-Introducing-VSL-Devnet--2-.png)](https://blog.pi2.network/introducing-fastset-pre-release/)

[Get an early look at FastSet, the first fully decentralized Web3 infrastructure that delivers 100,000+ TPS, sub-100ms finality, and is verifiable by design.](https://blog.pi2.network/introducing-fastset-pre-release/)

[![Looking Back at the VSL Devnet and What Comes Next](https://blog.pi2.network/content/images/size/w2000/2025/07/Pi2-Blog-Looking-Back-at-the-VSL-Devnet.png)](https://blog.pi2.network/looking-back-at-the-vsl-devnet-and-what-comes-next/)

[Read what the team achieved and learned from the VSL Devnet and also what's to come with FastSet, the next evolution of our verifiability stack.](https://blog.pi2.network/looking-back-at-the-vsl-devnet-and-what-comes-next/)

[![Introducing the VSL Devnet: A New Era of Fast Verifiability](https://blog.pi2.network/content/images/size/w2000/2025/06/Pi2-Blog-Introducing-VSL-Devnet.png)](https://blog.pi2.network/introducing-the-vsl-devnet-a-new-era-of-fast-verifiability/)

[We’re excited to announce the launch of the Pi Squared VSL devnet, a developer-first environment for building, testing, and exploring the future of composable AI and blockchain infrastructure.](https://blog.pi2.network/introducing-the-vsl-devnet-a-new-era-of-fast-verifiability/)

---

# USL - Pi Squared Blog

A collection of 5 posts

[![Pi Squared + pod: Faster Finality and Trustless Verification](https://blog.pi2.network/content/images/size/w2000/2025/02/20205-02-13---Pod-Pi2-PoP-Ring-BlogHero-copy.jpg)](https://blog.pi2.network/pi2-pod/)

[Faster finality, trustless verification and optimized speed. We explore why Pi Squared's USL + pod is a win for Web3 devs and users.](https://blog.pi2.network/pi2-pod/)

[![Revolutionizing Blockchain Interoperability: Insights from Pi Squared and Wormhole](https://blog.pi2.network/content/images/size/w2000/2024/12/Pi2-Wormhole-USL-Blog.png)](https://blog.pi2.network/usl-wormhole-recap/)

[Pi Squared and Wormhole unveiled the integration of our Universal Settlement Layer (USL) into Wormhole's Native Transfer Token (NTT) Framework.](https://blog.pi2.network/usl-wormhole-recap/)

[![Pi Squared’s Integration with Wormhole NTT](https://blog.pi2.network/content/images/size/w2000/2024/11/2024-09-25---Pi2---Wormhole-Blog.png)](https://blog.pi2.network/usl-wormhole/)

[Learn how USL's integration with Wormhole is a convergence of advanced technologies enhancing security and efficiency for cross-chain operations.](https://blog.pi2.network/usl-wormhole/)

[![Universality for Web3: Settling Transactions in Any Language or VM without Compilers](https://blog.pi2.network/content/images/size/w2000/2024/10/2024-09-27---Pi2-Blog-Universality---Settling-Transactions-in-Any-Language.jpg)](https://blog.pi2.network/byol-web3-interoperability/)

[We explore how Bring Your Own Language (BYOL) is the key to Web3 interoperability.](https://blog.pi2.network/byol-web3-interoperability/)

[![Why Web3 Needs a Universal Settlement Layer](https://blog.pi2.network/content/images/size/w2000/2024/08/Pi2-USL-Universe.png)](https://blog.pi2.network/why-web3-needs-usl/)

[Web3 developers are forced to trust that critical systems are operating accurately. How do they verify that these systems are working as intended?](https://blog.pi2.network/why-web3-needs-usl/)

---

# Shresth Agrawal - Pi Squared Blog

![Shresth Agrawal](https://blog.pi2.network/content/images/2025/02/Screenshot-2025-02-18-at-4.48.45-PM.png)

Shresth is the Founder & CEO of pod. With deep expertise in building scalable and secure blockchain protocols, he believes consensusless networks are a key step toward mainstream blockchain adoption.

[![Pi Squared + pod: Faster Finality and Trustless Verification](https://blog.pi2.network/content/images/size/w2000/2025/02/20205-02-13---Pod-Pi2-PoP-Ring-BlogHero-copy.jpg)](https://blog.pi2.network/pi2-pod/)

[Faster finality, trustless verification and optimized speed. We explore why Pi Squared's USL + pod is a win for Web3 devs and users.](https://blog.pi2.network/pi2-pod/)

---

# Vision - Pi Squared Blog

A collection of 9 posts

[![Pi Squared + pod: Faster Finality and Trustless Verification](https://blog.pi2.network/content/images/size/w2000/2025/02/20205-02-13---Pod-Pi2-PoP-Ring-BlogHero-copy.jpg)](https://blog.pi2.network/pi2-pod/)

[Faster finality, trustless verification and optimized speed. We explore why Pi Squared's USL + pod is a win for Web3 devs and users.](https://blog.pi2.network/pi2-pod/)

[![Pi Squared’s Integration with EigenLayer](https://blog.pi2.network/content/images/size/w2000/2025/01/2025-01-08---Pi2-EigenLayer-Hero-V2.png)](https://blog.pi2.network/eigenlayer/)

[Pi Squared and EigenLayer are revolutionizing multi-language execution and settlement for dApps.](https://blog.pi2.network/eigenlayer/)

[![Pi Squared’s Universal Language Machine (ULM): Revolutionizing Web3 Development](https://blog.pi2.network/content/images/size/w2000/2024/12/2024-12-10---Pi2-ULM-Blog-Hero.png)](https://blog.pi2.network/ulm/)

[Watch the launch of our Universal Language Machine (ULM) at Devcon. ULM enables developers to build in any programming language for any blockchain.](https://blog.pi2.network/ulm/)

[![How to Bring a Million Developers to Web3](https://blog.pi2.network/content/images/size/w2000/2024/10/2024-10-11---How-to-bring-million-developers-Blog.png)](https://blog.pi2.network/onboarding-developers-to-web3/)

[Breaking down barriers for global developer talent will revolutionize Web3, unleashing creativity and collaboration on a global scale.](https://blog.pi2.network/onboarding-developers-to-web3/)

[![ABCDE: Why we invested in Pi Squared](https://blog.pi2.network/content/images/size/w2000/2024/09/2024-09-23---Graphic-ABCDE-Why-We-Invest-Blog.png)](https://blog.pi2.network/abcde-why-we-invested/)

[How Siyuan Han of crypto fund ABCDE envisions Pi Squared’s approach to verifiable computing delivering greater efficiency and security for Web3.](https://blog.pi2.network/abcde-why-we-invested/)

[![BYOL (Bring Your Own Language) to Web3](https://blog.pi2.network/content/images/size/w2000/2024/09/2024-09-10---BlogPost-Universality-Hero-R4.png)](https://blog.pi2.network/byol/)

[In our first guest post Ibrahim Yusufali, Investor at Polychain Capital, explains how Pi Squared will enable millions of Web3 dApps.](https://blog.pi2.network/byol/)

[![Why Web3 Needs a Universal Settlement Layer](https://blog.pi2.network/content/images/size/w2000/2024/08/Pi2-USL-Universe.png)](https://blog.pi2.network/why-web3-needs-usl/)

[Web3 developers are forced to trust that critical systems are operating accurately. How do they verify that these systems are working as intended?](https://blog.pi2.network/why-web3-needs-usl/)

[![The Beginner's Guide To Proof Of Proof](https://blog.pi2.network/content/images/size/w2000/2024/08/2024-08-01---Pi2-Blog-PoP-Hero.png)](https://blog.pi2.network/guide-to-proof-of-proof/)

[In this post, we dive deeper into Proof of Proof to provide background for new entrants into the expanding Pi Squared universe.](https://blog.pi2.network/guide-to-proof-of-proof/)

[![Pi Squared: The Next Generation of Verifiable Computing](https://blog.pi2.network/content/images/size/w2000/2024/07/2024-07-30---Pi2-USL-Graphic-V1-1.png)](https://blog.pi2.network/pi-squared-the-next-generation-of-verifiable-computing/)

[Our Founder & CEO talks about how Pi Squared’s Universal Settlement Layer will unify the fractured Web3 space.](https://blog.pi2.network/pi-squared-the-next-generation-of-verifiable-computing/)

---

# Ilja Zakharov - Pi Squared Blog

![Ilja Zakharov](https://blog.pi2.network/content/images/2025/02/Ilja-Zakharov.webp)

Ilja Zakharov is an engineering manager at Pi Squared with a Ph.D. in Computer Science. He has over a decade of experience building secure solutions blending productivity and empathy for user needs.

[![Trust in Today's Blockchain Space](https://blog.pi2.network/content/images/size/w2000/2025/03/2025-03-03---Pi2-Blog-Trust-in-Web3.png)](https://blog.pi2.network/trust-in-web3/)

[Trust in Web3 is fragile—just like a stolen childhood bike. Pi Squared’s Proof of Proof and USL make trust verifiable, reducing blind faith.](https://blog.pi2.network/trust-in-web3/)

---

# Ossie Amir - Pi Squared Blog

![Ossie Amir](https://blog.pi2.network/content/images/2024/11/image.png)

As Global Integrations Lead at the Wormhole Foundation, Ossie focuses on activating insightful ideas with a dialectical approach to strategy and a penchant for cutting-edge technology.

[![Pi Squared’s Integration with Wormhole NTT](https://blog.pi2.network/content/images/size/w2000/2024/11/2024-09-25---Pi2---Wormhole-Blog.png)](https://blog.pi2.network/usl-wormhole/)

[Learn how USL's integration with Wormhole is a convergence of advanced technologies enhancing security and efficiency for cross-chain operations.](https://blog.pi2.network/usl-wormhole/)

---

# Nicholas Harness - Pi Squared Blog

![Nicholas Harness](https://blog.pi2.network/content/images/2024/10/Nicholas-Harness.jpeg)

Nicholas is the ecosystem lead at Pi Squared in addition to being a student at UIUC. He was previously the founder of UBA (now CollegeDAO).

[![Why We’re Renaming the Universal Settlement Layer / Introducing the VSL](https://blog.pi2.network/content/images/size/w2000/2025/04/Pi2-Blog-USL-to-VSL--1-.png)](https://blog.pi2.network/why-were-renaming-the-universal-settlement-layer-introducing-the-vsl/)

[Reframing Web3’s foundation with verifiability, correctness, and security at its core](https://blog.pi2.network/why-were-renaming-the-universal-settlement-layer-introducing-the-vsl/)

[![Revolutionizing Blockchain Interoperability: Insights from Pi Squared and Wormhole](https://blog.pi2.network/content/images/size/w2000/2024/12/Pi2-Wormhole-USL-Blog.png)](https://blog.pi2.network/usl-wormhole-recap/)

[Pi Squared and Wormhole unveiled the integration of our Universal Settlement Layer (USL) into Wormhole's Native Transfer Token (NTT) Framework.](https://blog.pi2.network/usl-wormhole-recap/)

[![How to Bring a Million Developers to Web3](https://blog.pi2.network/content/images/size/w2000/2024/10/2024-10-11---How-to-bring-million-developers-Blog.png)](https://blog.pi2.network/onboarding-developers-to-web3/)

[Breaking down barriers for global developer talent will revolutionize Web3, unleashing creativity and collaboration on a global scale.](https://blog.pi2.network/onboarding-developers-to-web3/)

---

# Siyuan Han - Pi Squared Blog

![Siyuan Han](https://blog.pi2.network/content/images/2024/09/ABCDE-logo.jpeg)

Siyuan Han is a Partner at ABCDE Labs, where he led the investments in Cysic, MegaETH, and Pi Squared. He's a final-year PhD student at HKUST with research interests in Blockchain and ML/AI Systems.

[![ABCDE: Why we invested in Pi Squared](https://blog.pi2.network/content/images/size/w2000/2024/09/2024-09-23---Graphic-ABCDE-Why-We-Invest-Blog.png)](https://blog.pi2.network/abcde-why-we-invested/)

[How Siyuan Han of crypto fund ABCDE envisions Pi Squared’s approach to verifiable computing delivering greater efficiency and security for Web3.](https://blog.pi2.network/abcde-why-we-invested/)

---

# Dwight Guth - Pi Squared Blog

![Dwight Guth](https://blog.pi2.network/content/images/2024/08/dwight_guth.webp)

Dwight is Head of Engineering at Pi Squared. He focuses on the internal infrastructure powering Proof of-Proof capabilities, ensuring these systems scale and perform well on real-world inputs.

[![How Formal Semantics Will Bring More Developers to Web3](https://blog.pi2.network/content/images/size/w2000/2024/09/2024-09-01---Pi2-LLVM-Hero-Galaxy-Cluster.png)](https://blog.pi2.network/how-formal-semantics-will-bring-more-developers-to-web3/)

[It needs to be easier for developers to write smart contracts. Learn how formal semantics let developers build in any programming language.](https://blog.pi2.network/how-formal-semantics-will-bring-more-developers-to-web3/)

---

# Ibrahim Yusufali - Pi Squared Blog

![Ibrahim Yusufali](https://blog.pi2.network/content/images/2024/09/Polychain-Logo.png)

Ibrahim is passionate about decentralized systems and blockchain technology. He is currently a Researcher and Investor at Polychain Capital.

[![BYOL (Bring Your Own Language) to Web3](https://blog.pi2.network/content/images/size/w2000/2024/09/2024-09-10---BlogPost-Universality-Hero-R4.png)](https://blog.pi2.network/byol/)

[In our first guest post Ibrahim Yusufali, Investor at Polychain Capital, explains how Pi Squared will enable millions of Web3 dApps.](https://blog.pi2.network/byol/)

---

# Musab Alturki - Pi Squared Blog

![Musab Alturki](https://blog.pi2.network/content/images/2024/08/Musab-Alturki.webp)

Musab Alturki is a senior research engineer leading the design and implementation of the Universal Settlement Layer (USL), realizing the vision of Pi Squared Inc.

[![Universality for Web3: Settling Transactions in Any Language or VM without Compilers](https://blog.pi2.network/content/images/size/w2000/2024/10/2024-09-27---Pi2-Blog-Universality---Settling-Transactions-in-Any-Language.jpg)](https://blog.pi2.network/byol-web3-interoperability/)

[We explore how Bring Your Own Language (BYOL) is the key to Web3 interoperability.](https://blog.pi2.network/byol-web3-interoperability/)

[![Why Web3 Needs a Universal Settlement Layer](https://blog.pi2.network/content/images/size/w2000/2024/08/Pi2-USL-Universe.png)](https://blog.pi2.network/why-web3-needs-usl/)

[Web3 developers are forced to trust that critical systems are operating accurately. How do they verify that these systems are working as intended?](https://blog.pi2.network/why-web3-needs-usl/)

---

# Bolton Bailey - Pi Squared Blog

![Bolton Bailey](https://blog.pi2.network/content/images/2024/08/bolton.png)

Bolton Bailey is a Proof engineer at Pi Squared Inc. Prior to joining, he was a Ph.D. student in computer science at the University of Illinois at Urbana-Champaign.

[![Benchmarking zkVMs on Metamath Proof Checking](https://blog.pi2.network/content/images/size/w2000/2025/01/2025-01-28---Logo-garden-for-zkVM-Benchmarking-Opt-1-1.png)](https://blog.pi2.network/zkvm-benchmarking/)

[We evaluate the performance of zkVMs to validate mathematical proofs of on-chain transactions](https://blog.pi2.network/zkvm-benchmarking/)

[![Introduction to zkVMs](https://blog.pi2.network/content/images/size/w2000/2024/08/2024-08-27---Pi2-zkVM-Hero-Black-Hole.png)](https://blog.pi2.network/intro-to-zkvms/)

[zkVMs make it easier for developers to build on-chain apps. What are they, and how do they work?](https://blog.pi2.network/intro-to-zkvms/)

---

# Xiaohong Chen - Pi Squared Blog

![Xiaohong Chen](https://blog.pi2.network/content/images/2024/08/Xiaohong-Chen.webp)

Xiaohong Chen is the Chief Technology Officer, a formal methods engineer, and a zero-knowledge (ZK) researcher at Pi Squared Inc.

[![FastSet: To Blockchain or Not?](https://blog.pi2.network/content/images/size/w2000/2025/07/Pi2-Blog-FastSet-to-Blockchain-or-Not.png)](https://blog.pi2.network/fastset-to-blockchain-or-not/)

[A surface dive into what FastSet is, but mainly what it is not.](https://blog.pi2.network/fastset-to-blockchain-or-not/)

[![Mirror to the Future: Why State Mirroring via the VSL is a Web3 Game Changer](https://blog.pi2.network/content/images/size/w2000/2025/06/Pi2-Blog-2025-05-02-Mirroring.png)](https://blog.pi2.network/mirror-to-the-future-why-state-mirroring-via-the-vsl-is-a-web3-game-changer/)

[State mirroring with the Verifiable Settlement Layer (VSL) enables blockchains to cryptographically synchronize and access each other’s state without bridges or trust assumptions, unlocking a new era of seamless, verifiable cross-chain applications.](https://blog.pi2.network/mirror-to-the-future-why-state-mirroring-via-the-vsl-is-a-web3-game-changer/)

[![Unpacking the VSL: What are Claims?](https://blog.pi2.network/content/images/size/w2000/2025/05/Pi2-Blog-Unpacking-VSL-What-are-claims.png)](https://blog.pi2.network/unpacking-the-vsl-what-are-claims/)

[Pi Squared’s Verifiable Settlement Layer (VSL) treats every verifiable action as a claim backed by flexible proofs, enabling fast, scalable, and trustless interoperability across Web3 systems.](https://blog.pi2.network/unpacking-the-vsl-what-are-claims/)

[![Why We’re Renaming the Universal Settlement Layer / Introducing the VSL](https://blog.pi2.network/content/images/size/w2000/2025/04/Pi2-Blog-USL-to-VSL--1-.png)](https://blog.pi2.network/why-were-renaming-the-universal-settlement-layer-introducing-the-vsl/)

[Reframing Web3’s foundation with verifiability, correctness, and security at its core](https://blog.pi2.network/why-were-renaming-the-universal-settlement-layer-introducing-the-vsl/)

[![Matching logic and mathematical proofs of program execution](https://blog.pi2.network/content/images/size/w2000/2025/03/Pi2-Blog-Hero-Graphic-Matching-Logic-and-Mathematical-Proofs.png)](https://blog.pi2.network/matching-logic-and-mathematical-proofs-of-program-execution/)

[Learn how Pi Squared uses matching logic and the K framework to mathematically prove that program executions are correct, enabling trustworthy and language-agnostic development tools.](https://blog.pi2.network/matching-logic-and-mathematical-proofs-of-program-execution/)

[![Pi Squared’s Universal Language Machine (ULM): Revolutionizing Web3 Development](https://blog.pi2.network/content/images/size/w2000/2024/12/2024-12-10---Pi2-ULM-Blog-Hero.png)](https://blog.pi2.network/ulm/)

[Watch the launch of our Universal Language Machine (ULM) at Devcon. ULM enables developers to build in any programming language for any blockchain.](https://blog.pi2.network/ulm/)

[![Universality for Web3: Settling Transactions in Any Language or VM without Compilers](https://blog.pi2.network/content/images/size/w2000/2024/10/2024-09-27---Pi2-Blog-Universality---Settling-Transactions-in-Any-Language.jpg)](https://blog.pi2.network/byol-web3-interoperability/)

[We explore how Bring Your Own Language (BYOL) is the key to Web3 interoperability.](https://blog.pi2.network/byol-web3-interoperability/)

[![The Beginner's Guide To Proof Of Proof](https://blog.pi2.network/content/images/size/w2000/2024/08/2024-08-01---Pi2-Blog-PoP-Hero.png)](https://blog.pi2.network/guide-to-proof-of-proof/)

[In this post, we dive deeper into Proof of Proof to provide background for new entrants into the expanding Pi Squared universe.](https://blog.pi2.network/guide-to-proof-of-proof/)

---

# FastSet: To Blockchain or Not?

Introduction
============

At its core, a blockchain is a decentralized ledger––a public record of transactions that anyone can read and write to, provided they follow the rules.

Each new transaction is added in a block, and these blocks are chained together in the order they were confirmed. This structure guarantees transparency and trust, even when the network is made up of unknown participants.

Well-known platforms like Bitcoin, Ethereum, Solana, and Algorand all rely on this blockchain technology. They differ in how they validate transactions, mainly in how fast they operate, and how decentralized they are, but they all share the same fundamental trait, which is that every transaction must be recorded in a single, agreed-upon sequence.

However, FastSet takes a different path.

FastSet is a decentralized network optimized for massively parallel payments and claim settlement, on which the next wave of blockchains and verifiable computing applications can be built.

In this blog post, we’ll explore what makes FastSet fundamentally different from a blockchain. We’ll explain why it abandons total ordering, how it achieves parallel settlement without [strongly consistent consensus](https://en.wikipedia.org/wiki/Strong_consistency?ref=blog.pi2.network)
, and why that unlocks a new class of scalable, decentralized applications.

On blockchains
==============

To understand where FastSet diverges, it helps to look closely at how blockchains traditionally work.

As earlier stated, blockchains function like a public ledger. Anyone can submit a transaction, and once accepted, it’s grouped into a block and added to the chain—a continuous, immutable sequence of blocks that all participants agree on.

Each block contains a set of transactions and is cryptographically linked to the one before it, forming a verifiable history that cannot be altered.

![](https://blog.pi2.network/content/images/2025/08/Blockchain-consensus-transactions.png)

**Figure 1:** _Blockchain, in an oversimplified view._

In the diagram above, the colored stripes represent transactions from two different accounts waiting to be settled, with yellow and red originating from the same account and with blue being the first transaction initiated, and yellow being the last. The rectangles at the top denote the blocks settled on the chain, with the light purple rectangle being the genesis block of the chain, and the yellow rectangle the last one settled. The left arrows depicts the links between blocks. The vortex icon represents the consensus or settlement algorithm (e.g., Proof of Work, Delegated Proof of Stake, or Pure Proof of Stake) used to decide which transactions get settled. The boxes represent the nodes of the network and the colorful stacks to their right denote the order in which transactions are appended to their local copy of the blockchain, with the one on the bottom representing the first transaction.

There are three major properties a blockchain is expected to satisfy: **decentralization**, **security**, and **scalability**.

*   **Decentralization** means that anyone should be able to participate in deciding the next page of transactions to be written into the ledger.
*   **Security** ensures that malicious actors cannot rewrite or corrupt the ledger’s history.
*   **Scalability** means that as the number of transactions and users increases, the time it takes to write them to the ledger should remain somewhat constant.

Until recently, it was widely believed that a blockchain could only satisfy two out of these three properties at a time—a concept known as the **blockchain trilemma** and introduced by Ethereum co-founder [Vitalik Buterin](https://en.wikipedia.org/wiki/Vitalik_Buterin?ref=blog.pi2.network)
.

For example, Bitcoin started as a highly decentralized blockchain. However, it relies on Proof of Work (PoW) to determine who gets to write the next block, and this process only occurs roughly every ten minutes.

Over time, solving the PoW puzzle has become so computationally expensive that only a few large mining pools can currently compete, leading to reduced decentralization. Additionally, the ten-minute delay per block is a clear scalability limitation.

Ethereum attempted to address this with Delegated Proof of Stake (DPoS), selecting a fixed group of 21 delegates to decide which transactions are added next. While this speeds things up, having just 21 validators in a network of hundreds of thousands limits decentralization. Ethereum still struggles with scalability, and transactions remain slow and expensive to settle.

Blockchain trilemma and Algorand
================================

The blockchain trilemma has been challenged in recent years by newer designs, most notably by **Algorand**, a blockchain developed at MIT by Turing Award winner [Silvio Micali](https://en.wikipedia.org/wiki/Silvio_Micali?ref=blog.pi2.network)
.

Algorand introduces a novel approach that aims to satisfy **decentralization**, **security**, and **scalability** without compromise, using a cryptographic tool called **Verifiable Random Function (VRF).**

VRF is a type of cryptographic function that transforms arbitrary input into a random-looking output, using a secret seed. The result is both random and verifiable, so much so that anyone can check that it was honestly generated, without learning the secret behind it. Algorand uses VRFs to randomly select who gets to participate in the next round of transaction settlement.

Rather than relying on PoW or DPoS, Algorand uses a **Pure Proof of Stake (PPoS)** consensus algorithm. In this system, 1,000 users are randomly selected to validate transactions in each round. The chance of being selected is proportional to the number of tokens a user holds, but the selection is unpredictable and private, which makes the system resistant to manipulation.

This design helps Algorand achieve the three goals of the trilemma:

*   **Security**, because attackers cannot predict or influence who will be selected.
*   **Decentralization**, because any token holder can be chosen to participate.
*   **Scalability**, because selection takes just a microsecond and does not require global coordination.

Algorand’s approach shows that it’s possible to challenge the trade-offs that defined early blockchains.

However, while it solves many problems, one key limitation still remains and that’s where FastSet draws a different line.

No total order and FastSet
==========================

Algorand makes impressive strides toward solving the blockchain trilemma. However, it still holds on to one of blockchain’s most rigid features: the idea that transactions must be totally ordered.

A total order means that every transaction is placed in a single, global sequence. Every participant in the network must agree not only on _which_ transactions happened, but also on _exactly when_ each one happened relative to the others. This ordering is essential for preventing double-spending and ensuring consistency but it comes at a high cost.

In reality, most transactions are independent of each other. If Alice sends tokens to Bob, and Carol sends tokens to Dave at the same time, the two transfers don’t conflict, they could happen in any order. Enforcing a global order in such cases is unnecessary overhead.

FastSet takes a different approach.

Rather than using a list of transactions (or ledger) as blockchains do, FastSet maintains a **set** **of** **transactions** whose processing order is not as strict, as long as they don't originate from the same accounts. More specifically, FastSet enforces total order on transactions originating from the same account, but no restrictions on transactions from different users.

Note that although we refer to transactions, FastSet isn't just for payments. It supports any kind of decentralized operation, from voting and identity verification to verifiable computations. And to capture the entire range we use the term claims, with transactions being a special type thereof.

From further on we are going to refer only to claims, instead of just transactions, to capture the whole capabilities of FastSet.

![](https://blog.pi2.network/content/images/2025/08/FastSet-consensus-transactions.png)

**Figure 2:** _FastSet, in an oversimplified view._

In the diagram above, the colored stripes represent claims from two different accounts waiting to be settled, with yellow and red originating from the same account and with blue being the first claim initiated, and yellow being the last. The vortex icon represents the settlement process. The boxes represent the nodes of the network and the colorful stacks to their right denote the order in which transactions are processed, with the one on the bottom representing the first one. Each node processes the claims independently and while they may follow a different sequence, they all converge to the same final state. Note that the red transaction is always going to be processed before the yellow one, as both originate from the same account and transaction order in this case has to be preserved. This behavior works because FastSet does not rely on a strong consistency consensus algorithm, but on [eventual consistency](https://en.wikipedia.org/wiki/Eventual_consistency?ref=blog.pi2.network)
.

In FastSet, any node can act as a validator and unlike in classical blockchain protocols, they do not need to talk to each other. There’s no mining, staking, or leader election. Claims are simply broadcast, and validators independently verify them. 

Once enough validators approve a claim, it becomes **certified**, meaning it’s accepted by the network and safe to apply to the validator’s local state.

So how does FastSet achieve consistency without enforcing a strict order on transactions?

It builds on a clever insight: most claims are not related, as they originate from different users. And if claims waiting to be settled are "unrelated-enough" then they can be processed in any order by different nodes and still end up in the same state. This is one of the core innovations of FastSet, which we call **weak independence**.

Scalability in FastSet comes not just from the weak independence of claims, but also from validator independence. Rather than coordinating globally, each validator checks claims on its own. Certification replaces consensus and only certified claims are applied to the local state.

It’s not a blockchain. It’s better
==================================

Blockchains brought us a new way to coordinate trust in a decentralized world but they came with trade-offs.

Every improvement in scalability or speed has traditionally meant giving up something else, whether it’s decentralization or security. Even with modern designs like Algorand, the assumption that all transactions must be globally ordered still limits how far these systems can scale.

FastSet challenges that assumption entirely. By settling claims without global consensus and letting validators work in parallel, it unlocks a new model for decentralized applications, one where throughput increases naturally as more validators join. No bottlenecks. Just massively parallel settlement at the speed of the network.

If you’re curious about how it works under the hood or want to see how it fits into your applications, check out the [whitepaper](https://pi2.network/papers/fastset?ref=blog.pi2.network)
, explore our [docs](https://docs.pi2.network/?ref=blog.pi2.network)
, or follow us on [X (Twitter)](https://x.com/Pi_Squared_Pi2?ref=blog.pi2.network)
 to stay in the loop as we continue building with FastSet.

---

# Grigore Rosu - Pi Squared Blog

![Grigore Rosu](https://blog.pi2.network/content/images/2024/08/unnamed--1-.png)

Grigore Rosu the Founder & CEO of Pi Squared. He is also a Computer Science professor at the University of Illinois at Urbana-Champaign (UIUC), where he leads the Formal Systems Laboratory (FSL).

[![From TVL to TVU: Why Web3 Needs a New Narrative](https://blog.pi2.network/content/images/size/w2000/2025/05/Pi2-Blog-Web3-Needs-a-New-Narrative--1-.png)](https://blog.pi2.network/from-tvl-to-tvu-why-web3-needs-a-new-narrative-2/)

[Unlocking the future of Web3 through universality, verifiability, and seamless cross-chain access](https://blog.pi2.network/from-tvl-to-tvu-why-web3-needs-a-new-narrative-2/)

[![Pi Squared’s Integration with EigenLayer](https://blog.pi2.network/content/images/size/w2000/2025/01/2025-01-08---Pi2-EigenLayer-Hero-V2.png)](https://blog.pi2.network/eigenlayer/)

[Pi Squared and EigenLayer are revolutionizing multi-language execution and settlement for dApps.](https://blog.pi2.network/eigenlayer/)

[![Pi Squared: The Next Generation of Verifiable Computing](https://blog.pi2.network/content/images/size/w2000/2024/07/2024-07-30---Pi2-USL-Graphic-V1-1.png)](https://blog.pi2.network/pi-squared-the-next-generation-of-verifiable-computing/)

[Our Founder & CEO talks about how Pi Squared’s Universal Settlement Layer will unify the fractured Web3 space.](https://blog.pi2.network/pi-squared-the-next-generation-of-verifiable-computing/)

---

# Looking Back at the VSL Devnet and What Comes Next

**Introduction**
================

Three weeks ago, we launched the Pi Squared VSL devnet, our first public proving ground for verifiable, decentralized execution.

It was a big moment for us. We opened up our core infrastructure to developers, researchers, and partners and invited them to test-drive the ideas behind the VSL: programmable claims, composable compute, and on-chain verifiability across systems. And what followed was even better than we expected.

Over the course of the devnet, we saw real usage, strong engagement, and a wave of interest from across the ecosystem. Demos ran continuously. Millions of claims were processed. Developers explored, built, and gave feedback that helped shape what is to come.

Now, as we wrap up the devnet, we want to take a moment to look back at what we built, what we learned, and where we're headed next.

### **What we built together**

The goal of the devnet was simple: to put the Verifiable Settlement Layer (VSL) into the hands of real developers and see what they could do with it. Over the course of two weeks, we saw that goal come to life.

We launched with a set of public demos that highlighted some of the core use cases for VSL: multichain asset transfers, blockchain mirroring, and AI running inside trusted execution environments (TEEs). In total, seven demos ran continuously throughout the devnet. These weren't just technical showcases. They were live, interactive examples of how programmable claims could power new types of infrastructure across domains.

More importantly, we saw developers explore and test the limits of what's possible. From debugging flows to poking at edge cases, this wasn't a passive experience. It was active, hands-on participation in building a better foundation for verifiable computing.

### **Devnet by the numbers**

Beyond the demos and developer feedback, the devnet gave us something even more valuable: real-world data.

Over the two-week period, more than **71,000** people signed up to explore the devnet. From that group, we allowlisted over **3,500** wallets to access the live demos, ensuring a steady wave of real developers actively testing and interacting with the VSL-powered applications in a focused, hands-on environment.

Behind the scenes, our infrastructure was doing exactly what it was built for. Across seven live demos, the network processed over **2 million claims**, with most of them settled explicitly by users signing transactions in their wallets. That translates to **more than one claim per second**, settled through real, hands-on interaction.

These numbers gave us confidence not just in the technology, but in the growing interest around verifiable infrastructure too. Developers are ready for faster, more flexible systems. And the VSL is helping prove what that can look like.

### **What did we learn?**

One of the biggest benefits of running a public devnet is that it reveals things you can't always catch in a controlled environment. The past two weeks gave us a clearer picture of how VSL behaves under load, how developers interact with it, and where the experience can be improved.

We saw which demos attracted the most attention, where developers got stuck, and which features sparked curiosity. The multichain and mirroring flows generated steady engagement, and the AI + TEE demo opened up new conversations around composability and trust in AI systems.

The feedback we received from Discord chats to direct integrations helped us uncover usability gaps, surface feature requests, and refine how we talk about VSL. It also confirmed something important: the core ideas behind VSL resonate. Developers are thinking about claims as primitives, not just proofs. They're imagining new workflows, not just porting old ones.

The devnet validated the direction we're heading to and gave us a better sense of how to move forward.

### **Where we’re headed: FastSet**

With the devnet wrapped up, we're now turning our focus to what's next.

Introducing **FastSet**, the next evolution of our verifiability stack.

FastSet builds on everything we learned from the devnet. It's designed to handle claims at a much larger scale by introducing parallel claim settlement without consensus. This means claims can be validated and finalized without needing complex validator coordination, making the system faster, leaner, and more scalable from day one.

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXdrhuQgTR2Df9GTpDdXrSuWDO2oFgkr4mRyGxPCrH8I3lvQm1CGJtbp8ZqDcVtL-5HbfcQKq9LRjEPtwVMNHS3Te6fjksD682AJYHwY3jTZ5bJsZvHQ8Tk27G9Bn5gq9b20S-TQ?key=qOt4nIKywJXdjs3jzgNSVg)

If VSL was about proving that programmable claims could work across systems, FastSet is about pushing that to a production-level scale.

We'll be sharing a lot more about FastSet over the coming weeks, but for now, you can get a deeper look at how it works by checking out the [FastSet whitepaper](https://pi2.network/papers/fastset?ref=blog.pi2.network)
. We're excited about what this unlocks, and we're just getting started.

### **Stay involved**

To everyone who joined the Devnet, we want to say thank you.

Whether you explored a demo, tested edge cases, submitted feedback, or just watched from the sidelines, you helped us move this technology forward. We're grateful for the energy, ideas, and curiosity you brought to the devnet.

The devnet is now closed, but this isn't the end; rather, it marks the beginning of something new.

We're now shifting our efforts to FastSet, and we'd love for you to be part of that journey, too.

Here’s how you can stay involved:

*   [Read the FastSet whitepaper](https://pi2.network/papers/fastset?ref=blog.pi2.network)
     to learn more about the next phase of our infrastructure.
*   [Join our Discord](https://discord.gg/NdBJBZMz4e?ref=blog.pi2.network)
     to stay connected and share ideas.
*   [Follow Pi Squared on X](https://x.com/Pi_Squared_Pi2?ref=blog.pi2.network)
     for weekly updates, technical drops, and news on what's coming next.

Thanks again for helping us get here. Let's keep building!

---

# Introducing FastSet Pre-Release

Today, we’re opening a window into the future of Web3. We’re excited to announce the pre-release of our FastSet Protocol, a major step forward in our mission to bring about the fastest TPS protocol ever seen, with near-instant finality and settlement to every corner of the decentralized ecosystem.

Starting Tuesday, August 12th, the FastSet Pre-Release gives developers and users an early look at the first fully decentralized Web3 infrastructure that delivers 100,000+ TPS, sub-100ms finality, and is verifiable by design.

### What’s Included in the FastSet Pre-Release?

This early rollout features 3 core components of the FastSet stack

*   [**FastSet Explorer**](https://explorer.fastset.xyz/?ref=blog.pi2.network)
    : Track transactions and visualize execution in real time.
*   [**FastSet Wallet**](https://wallet.fastset.xyz/?ref=blog.pi2.network)
    : Try out FastSet by initiating and observing transactions across supported chains.
*   **TPS Challenge Game (Coming Soon):** At scheduled times, the community will join forces to push FastSet to its absolute limits by sending as many transactions as possible through an interactive game. This will allow us to gather more accurate, authentic benchmark data rather than relying solely on simulated tests. This game will be live in the coming weeks so stay tuned!

0:00

/0:05

 1× 

### Why This Matters

We have built FastSet for a world where finality, trustlessness, and speed aren’t tradeoffs but a direct given. This pre-release marks a HUGE milestone for Pi Squared’s broader vision of a unified verifiability layer where execution is both provable and instant. Above all, our team is incredibly proud and excited to share this with all of you!

### What’s Next?

In the coming months, we’ll expand FastSet to:

*   Launch **OmniSet**, our multichain framework allowing users to leverage liquidity from any chain on any DeFi application
*   Be compatible with multiple chains through our **OmniSet protocol**
*   Execute bridgeless cross-chain swaps at the best available rate with **OmniSwap**, powered by Omniset
*   Release The Omni Arbitrage Delegate (**TOAD)**, an AI agent built on OmniSet and OmniSwap to identify and execute on cross-chain arbitrage opportunities

Connect with us on [Discord](https://discord.com/invite/NdBJBZMz4e?ref=blog.pi2.network)
 and [X](https://x.com/Pi_Squared_Pi2?ref=blog.pi2.network)
 to let us know what you love, what breaks, and where you want to see us go next and explore all FastSet’s capabilities [here](https://pi2.network/fastset-network?ref=blog.pi2.network)
.

---

# Introducing the VSL Devnet: A New Era of Fast Verifiability

**Introduction**
================

Today marks a major milestone in our journey to build a decentralized layer for transparent, provable execution.

We’re excited to announce the launch of the Pi Squared VSL devnet, a developer-first environment for building, testing, and exploring the future of composable AI and blockchain infrastructure. This is more than just a testbed. It’s the first real proving ground for the Verifiable Settlement Layer (VSL), our core infrastructure for on-chain state, AI execution, and cross-domain composability.

As we open up access, we’re inviting developers, researchers, and partners to dig into what we believe is the next frontier: programmable, verifiable computing across trust boundaries. From smart agents to mirrored blockchains and secure AI execution, the devnet is where Pi Squared’s vision comes to life.

The devnet is a foundational step on the road to mainnet, and a key part of our mission to make decentralized computation both accessible and programmable. Read on to explore how the devnet works, why it matters, and how you can start building with it today!

**What is the VSL Devnet?**
===========================

The Pi Squared VSL devnet is our first live environment where developers can interact with the foundational layer powering the [Verifiable Settlement Layer (VSL)](https://docs.pi2.network/verifiable-settlement-layer/what-is-vsl?ref=blog.pi2.network)
.

At its core, VSL is a decentralized network designed to bring scalable, affordable, and customizable verifiability to all corners of Web3. Through a system of **VSL claims**—statements that encode anything verifiable or provable—participants can securely exchange assets, data, or services across diverse platforms.

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXfEivqkxIh3Iv44RBlNIQ4TSDIrx-Y_Y6i58vr0IQG-UP0skb0dnXetgwx-6DN9kN8gBp7x-Ep2iMlJ8UFuqyVqTIGMua90t7FcANZe-tDq3sY7oFiATO8YMkazUUo74dk8F73ThQ?key=GQcDBh0zu-eORVZVy-95fA)

_**Figure 1**: The VSL Architecture_

These claims are validated by a set of homogeneous VSL validators, then settled on the VSL network with instant finality. Once settled, they become instantly accessible across ecosystems, enabling fast and secure cross-platform coordination.

The VSL devnet gives developers early access to this infrastructure: a chance to test how VSL powers new patterns of decentralized computing, AI orchestration, and blockchain interoperability. 

**Inside the VSL Devnet**
=========================

The Pi Squared VSL devnet consists of the VSL infrastructure, as well as three example applications running on top of it. 

### **The Core VSL**

This is the core VSL network itself. Developers can submit, verify, and settle claims directly on VSL. To do this, we’ll offer core toolings including the VSL [explorer](https://explorer.vsl.pi2.network/?ref=blog.pi2.network)
, [API endpoints](https://github.com/Pi-Squared-Inc/vsl-sdk/blob/main/docs/api/rpc.md?ref=blog.pi2.network)
, [CLI](https://github.com/Pi-Squared-Inc/vsl-cli?ref=blog.pi2.network)
, and [docs](https://docs.pi2.network/devnet?ref=blog.pi2.network)
 to help you inspect and interact with settled claims across environments.

The VSL core infrastructure powers a wide range of applications. These include, but are not limited to cross-chain token transfers, blockchain mirroring, and AI + Trusted Execution Environments (TEEs).

Read more about each of these below. 

### **1\. Multichain Interoperability** 

This live integration showcases VSL-powered cross-chain asset movement powered by [Wormhole](https://wormhole.com/?ref=blog.pi2.network)
, the leading interoperability platform connecting traditional finance and the internet economy.

Developers can send assets across chains and track the verifiable flow through VSL claims, demonstrating how decentralized coordination can be made fast, lightweight, and secure.

You can find a link to the demo here: [https://multichain.pi2.network/](https://multichain.pi2.network/?ref=blog.pi2.network)

You can learn more about Pi Squared’s integration with Wormhole NTT here: [https://blog.pi2.network/usl-wormhole/](https://blog.pi2.network/usl-wormhole/)

### **2\. Blockchain Mirroring**

Get a first look at our blockchain mirroring capability.

This demo mirrors the blocks and states of a blockchain into VSL, giving developers a glimpse of what’s coming for partners like [MegaETH](https://www.megaeth.com/?ref=blog.pi2.network)
—our long-term vision for global blockchain state composability.

You can find a link to a mirroring of the Ethereum network at: [https://mirroring.pi2.network](https://mirroring.pi2.network/dashboard?ref=blog.pi2.network)

### **3\. AI + TEEs**

Explore the intersection of confidential computing and composable AI agents.

This demo shows how VSL claims can wrap the input/output lifecycle of an AI agent running in a TEE, laying the groundwork for partners like [Kite AI](https://gokite.ai/?ref=blog.pi2.network)
, targeting improved confidentiality and integrity of critical code and sensitive data.

You can find a link to our TEE demo here: [https://tee.pi2.network/](https://tee.pi2.network/?ref=blog.pi2.network)

Each of these demos is designed to showcase just a glimpse of what’s possible with VSL. While we present three applications: multichain interoperability, mirroring, and AI pipelines, they’re not the limits of what you can build.

These are starting points, not boundaries. We encourage developers to think about how their own applications, systems, or services could leverage VSL’s verifiable infrastructure. 

**Beyond the VSL Devnet: What’s next?**
=======================================

The Pi Squared VSL devnet is just the beginning.

Over the next few months, we’ll be deepening the VSL network’s capabilities by expanding decentralization, improving validator coordination, and refining our claim validation flows.

We’re also actively working on features like signature aggregation and multi-client support to make integration seamless across both AI pipelines and blockchain networks.

As we move toward the testnet launch later this year, you can expect:

*   Greater decentralization of the VSL validator set
*   Expanded client integrations across AI, bridge protocols, and mirrored chains
*   Public developer tooling for building with and on top of VSL

Each step gets us closer to a world where verifiability isn’t an afterthought, but it’s built in from the start. And this journey from devnet to Mainnet isn’t just a product roadmap, it’s an open call for builders to shape the future of decentralized computing with us.

**Why this matters**
====================

Verifiability isn’t just a feature at Pi Squared; it’s our foundation. With Web3 still siloed across chains and ecosystems, we see a different path forward: one where correctness, performance, and trust are built in from the start.

The Pi Squared VSL devnet marks a major milestone toward that future. It’s a first glimpse at a verifiability-first platform that can unify chains, languages, and applications through fast, secure, and programmable infrastructure.

With VSL, we’re building the backbone for developers to move value, data, and logic across ecosystems without centralized intermediaries or unverifiable execution.

**Get involved**
================

The devnet is open.

Whether you're an infrastructure builder, AI developer, or protocol designer, now’s the time to get involved. As such, you can:

*   **Join the Devnet**: Explore live demos, try out apps, and see VSL in action. Learn more and request to join the devnet [**here**](https://pi2.network/devnet?ref=blog.pi2.network)
    **.** 
*   **Partner with Pi²**: Want to learn how to integrate with us? Fill out [**this form**](https://share-eu1.hsforms.com/1eMaZ9gYOQL6_AB8c7FImug2ewjl3?ref=blog.pi2.network)
     and we’ll get in touch. 
*   **Stay Connected:** [**Follow Pi Squared on X**](https://x.com/Pi_Squared_Pi2?ref=blog.pi2.network)
     for updates on the latest progress, demos, and dev drops.

This is your invitation to test, build, and shape the next era of verifiable, decentralized computing.

Let’s build the future together!

---

# Mirror to the Future: Why State Mirroring via the VSL is a Web3 Game Changer

At Pi Squared, we’re rethinking what it means for blockchains to interoperate not just through messaging or bridging, but through verifiable synchronization of state. That’s why today we’re sharing a deeper look at one of the most powerful primitives unlocked by our Verifiable Settlement Layer (VSL): State Mirroring. State mirroring redefines cross-chain connectivity. It enables one blockchain to mirror the state of another in a trustless and verifiable way without bridges, wrapped assets, and centralized sequencers. More importantly, it works both ways. 

This post explains what state mirroring is, how Pi Squared’s VSL makes it possible, and why it unlocks a new class of cross-chain use cases. 

### **What Is State Mirroring?**

In traditional Web3 infrastructure, syncing or referencing the state of one chain from another is complex, fragile, and full of trust assumptions. Most solutions rely on bridges that pass messages, delay finality, or require trusted intermediaries to vouch for correctness.

State mirroring flips that model.

With VSL, any blockchain can cryptographically prove the state of another chain has been mirrored, anchored, and verified. This isn’t just message passing, it’s verifiable synchronization of state.

**We support two models of state mirroring through the VSL:**

Single-Direction State Mirroring:

A blockchain publishes its state to the VSL. Other blockchains connected to the VSL can then query this state, enabling secure read access and verifiable interactions. This model facilitates interoperability without requiring mutual trust or full replication.

Bidirectional State Mirroring:

Two blockchains each publish their state to the VSL. Rather than directly mirroring each other, they mirror onto the VSL, which acts as a shared hub. Through the VSL, each chain can independently and verifiably access the other’s state. This enables natively interoperable applications and shared logic across chains without needing one chain to subsume or directly replicate the other.

In both models, the VSL serves as an active cryptographic layer that provides universal, verifiable state access across ecosystems.

This is done through VSL-anchored claims and membership proofs. Once a state snapshot or execution result is verified via signatures, ZK proofs, or TEEs, it is added to the VSL’s universal claim set. From there, any chain integrated with VSL can query, validate, and rely on that state with full cryptographic assurance.

### **Ethereum ↔ MegaETH: A Practical Example**

Let’s take a real-world scenario. Ethereum is the dominant L1 for liquidity and user activity, but MegaETH offers a highly optimized execution environment. Developers today must choose between ecosystems or rely on fragile bridges and split liquidity.

With VSL-enabled bidirectional state mirroring, this choice disappears:

*   Ethereum can mirror MegaETH state, allowing Ethereum contracts to directly access and validate execution results, balances, or positions from MegaETH.
*   MegaETH can mirror Ethereum state, meaning users can open positions, manage assets, or trigger events based on Ethereum smart contract logic, all while operating in MegaETH’s high-throughput zone.
*   Both chains can reference each other verifiably, unlocking atomic execution, shared oracles, and unified liquidity without needing any wrapper logic.

The VSL handles all verification and settlement, anchoring proofs of both chains’ state transitions in a shared trust layer. This unlocks new design space for applications:

*   A perp DEX on MegaETH could use Ethereum-based collateral in real-time.
*   A DAO on Ethereum could govern contracts deployed on MegaETH.
*   A game on either chain could read player data or asset ownership from the other instantly and provably.

### **Why This Changes the Game**

State mirroring via Pi Squared’s VSL brings _provability_ to the heart of cross-chain design. Instead of trusting messages or monitoring events across bridges, developers can:

*   **Verify once, use everywhere.** With VSL proofs, once a claim is verified, it can be used across all integrated chains.
*   **Achieve true composability.** Applications no longer live in isolated silos. State mirroring allows them to share logic, governance, assets, and liquidity natively.
*   **Build without trade-offs.** Developers no longer have to pick between ecosystems. With mirrored state, they can optimize execution on one chain and tap liquidity on another.

And because the VSL supports customizable verification layers from TEEs to ZKPs to signatures, developers can tailor their security model based on performance and cost needs.

### **Looking Forward**

State mirroring is more than a technical feature, it’s the cornerstone of a verifiably connected Web3. It opens the door to new kinds of applications:

*   Unified margin systems
*   Cross-chain DAOs
*   Modular execution environments
*   Real-time asset portability
*   Shared oracle and data layers

The VSL is not just making interoperability possible. It’s making it verifiable, scalable, and provably correct. We’re excited to see what developers build when they no longer have to worry about the limits of single-chain design.

[Sign up](https://share-eu1.hsforms.com/1CEtNMzMMTQKOfd5-GilKLQ2ewjl3?ref=blog.pi2.network)
 to get early access to the VSL Devnet, and reach out to us at contact@pi2.network to learn how to implement state mirroring in your own protocol. 

This is just the beginning. The chains are ready. Now, we mirror.

---

# Unpacking the VSL: What are Claims?

**Introduction**
----------------

Imagine trying to prove you completed a task, say, solving a complex math problem without anyone watching you do it. Instead of redoing the whole thing in front of someone, you hand them a short certificate that says, “I did it, and here’s proof.” They check the certificate, and if everything checks out, they trust your result instantly.

That’s the core idea behind verifiable computing: proving that work was done correctly, without redoing the work. It’s an approach that’s rapidly transforming how we think about [trust](https://blog.pi2.network/trust-in-web3/)
 in decentralized systems, especially in Web3, where verifying the correctness of off-chain computation and on-chain actions is essential.

At the center of this model is a concept called [**claims**](https://docs.pi2.network/verifiable-settlement-layer/what-is-vsl/claims?ref=blog.pi2.network)
.

In this article, we’ll unpack what a claim really is from its simplest form to how it works in complex cryptographic systems. We’ll explore why claims are essential to verifiable computing and how our Verifiable Settlement Layer (VSL) uses them to create a trustless, provable Web3.

**What is a claim?**
--------------------

In one simple sentence, a claim is any statement that can be evaluated as _true_ or _false_.

In the context of verifiable computing, a claim is something someone wants to prove. It might be a computational result, a state change, a data point, or even a cross-chain message. What matters is that the claim can be backed by proof.

Let’s take an example:

“Given input X, I ran program F and got result Y.”

That’s a claim. Now, to make it verifiable, you attach a **proof**—a signature, a zero-knowledge proof, or even a transcript of the computation—that a verifier can use to confirm the claim without redoing the entire process.

This model is powerful because it removes the need for blind trust or expensive re-computation. Instead, verifiers check proofs, not the full computation.

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXfo23ELCYeDgL5gpcNCbotC5rfdaixc0rmXqYViZv5H3e7K4C1Cvr1gfHH9IhAAJZlMgCxWHCb8VuSlOuD65hDwxWsRCrkjpbmn9IYw5Om2jcs-Fdz0NH7afe6uEi3MsitB-vd6?key=yud004NCpbJcHhi3QMrF7Q)

_**Figure 1**: A simplistic explanation of a claim_

**The importance of claims in verifiable computing**
----------------------------------------------------

In traditional computing, we trust results because we control the system or we trust the source. But in decentralized systems like Web3, that kind of trust doesn’t scale. You can’t rely on every node, contract, or user to be honest. You need proof.

That’s where claims come in. They allow systems to say, “This result is correct and here’s why,” without requiring blind trust or redundant computation.

The following are some reasons why claims are important:

**1\. Interoperability across systems:** Different blockchains, smart contracts, or decentralized applications can verify the same claim without needing to understand how it was originally created. This enables cross-chain communication and shared trust between otherwise siloed systems.

**2\. Efficiency and scale:** Verifiers can validate claims in milliseconds, even if the underlying computation took hours. That’s a huge gain for applications that require frequent or complex computations like zero-knowledge proofs, machine learning models, or transaction batching.

**3\. Privacy-preserving guarantees:** Claims can include only what's necessary to verify correctness without revealing sensitive data. This is especially powerful in zk-based systems, where the witness stays hidden but the claim remains verifiable.

**4\. Auditability and transparency:** Because claims are standardized and logged, they form a permanent, traceable record of what happened and when. This is critical for debugging, governance, compliance, and accountability.

**Examples of claims in Web3**
------------------------------

Claims are everywhere once you know what to look for:

|     |     |     |
| --- | --- | --- |
| Use Case | Example Claim | Example Proof |
| Blockchain state | “Alice sent Bob 0.1 ETH in block #22,279,696” | Merkle proof of the transaction |
| Computation result | “Program X produced result Y on input Z” | zkSNARK, signed output, or logs |
| Oracle data | “BTC price was $65,000 at time T” | Oracle signature or quorum agreement |
| Consensus check | “Chain A reached finality at block height 5000” | Validator signatures |
| Service request | “API call to service X was valid and completed” | Signed response from the service |

In each case, the structure of the proof and the verification process may differ but the principle is the same: someone made a claim, and that claim is backed by a verifiable method.

**How claims work in Pi Squared**
---------------------------------

At Pi Squared, we believe that **everything provable or verifiable is a claim**.

That’s why our Verifiable Settlement Layer (VSL) treats claims as the foundational building block. Whether it’s verifying a computation, confirming a state change, transferring assets, or just signaling intent, it all starts with a claim in VSL.

Unlike systems that expect specific proof types or verification methods, our VSL lets you define your own:

*   You define what a claim means.
*   You decide what kind of proof supports it.
*   You choose how that proof should be verified.

This flexibility is what makes VSL universal, modular, and adaptable to any domain from DeFi and oracles to AI and off-chain compute.

### **Claims, proofs, and verifiers**

Let’s simplify the mental model:

*   A **claim** is any verifiable statement.
*   A **proof** is the evidence used to support that claim.
*   A **verifier** checks the proof and decides whether to accept the claim.

That’s it.

Importantly, Pi Squared’s VSL doesn’t impose any restriction on what a claim or a proof must look like.

It doesn’t assume you’re using cryptography. It doesn’t require zero-knowledge proofs. You could be using digital signatures, logs, re-execution, or other verification methods.

As long as the claim is verifiable and follows the proper structure, the VSL accepts it.

### **How the VSL handles claims**

Our VSL has a lightweight, modular backend designed to **validate and store claims**, not execute complex logic. Here's how it works:

1.  Users or applications submit claims via the VSL client, specifying what needs to be verified.
2.  The VSL checks the claim’s structure and signatures, deducts a flat fee from the submitter’s account, and logs the claim.
3.  A designated verifier (an off-chain actor) picks up the claim and performs the required computation or check.
4.  The verifier then submits a result claim, stating whether the original claim was valid, along with a cryptographic proof.
5.  If valid, the VSL settles the claim. It credits the verifier, stores the result, and makes it queryable by any external system.

This architecture enables a powerful workflow: **Submit a claim once → verify it off-chain → use it anywhere.**

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXdH270xxkGfkKbpkWbrPqq-dsQKAKzwldLitwK6BeKt8y0DOK0biHAWdzp_0lsyuazWEa6zJ1C4Ihl0fi4R2as8lxQbXssJS0Xw1FO8rMBPyNSaVK8q8SKrrlri4HgdpvEV7LqVnA?key=yud004NCpbJcHhi3QMrF7Q)

_**Figure 2**: The VSL Architecture_

The VSL is purposefully minimal:

*   It doesn’t interpret or execute the logic behind a claim.
*   It only validates structure, manages balances, and stores verified claims.
*   The actual computation is delegated to verifiers, making the system faster, more secure, and easier to scale.

By separating verification from storage, the VSL becomes a **universal proof ledger**: a shared source of truth that any application, smart contract, or blockchain can rely on.

**Conclusion**
--------------

In verifiable computing, a claim is a compact, verifiable statement that a computation was done correctly. 

By building its VSL around the idea that everything is a claim, Pi Squared turns this concept into a foundation for scalable, interoperable, and trustless systems. From computation to consensus, claims unify how interactions are recorded, verified, and shared across chains and applications.

Whether you're validating a blockchain state, checking a computation, or syncing information across networks, it all begins with a claim.

You can learn more about how we use claims and the VSL architecture by exploring our [documentation](https://docs.pi2.network/verifiable-settlement-layer/what-is-vsl?ref=blog.pi2.network)
 or testing it out on our [Devnet](https://share-eu1.hsforms.com/1CEtNMzMMTQKOfd5-GilKLQ2ewjl3?ref=blog.pi2.network)
.

---

# From TVL to TVU: Why Web3 Needs a New Narrative

For the past several years, Web3 has been dominated by one metric: Total Value Locked (TVL). Entire ecosystems have been valued, ranked, and rewarded based on how much capital they can silo within their smart contracts and bridges. But while TVL has been an easy number to point to, it’s also led us down a narrow path that reinforces fragmentation, not freedom.

At Pi Squared, we believe it’s time to shift the narrative. Web3 shouldn’t be about how much value is locked away on isolated chains when it should be about how much value is unlocked and made usable _everywhere_. That’s why we’re proposing a new north star for the industry: Total Value Unlocked (TVU).

### **The Problem With TVL**

TVL incentivizes platforms to hoard liquidity. Chains, protocols, and applications compete to attract users and assets, often by introducing incentives that reward staying put. But this creates liquidity islands that serve as disconnected pools of capital, logic, and data that are difficult to move between or build across.

Instead of an open internet of value, we’ve created walled blockchain gardens. Developers are forced to choose sides. Users have to bridge value with isolation, complexity, and risk, and every new chain makes the fragmentation worse.

But the original promise of Web3 was interoperability, composability, and decentralization. Not siloed value. Not repeated infrastructure. Not incompatible smart contracts.

TVL may be an easy number to track, but it's the wrong thing to chase and is completely misaligned with the core ethos of Web3.

### **Introducing Total Value Unlocked (TVU)**

Total Value Unlocked (TVU) shifts the focus from isolation to accessibility.

TVU is a measure of how much _usable_, _verifiable_, and _interoperable_ value a blockchain ecosystem can unlock (not just on its own) but _in concert with others_. It’s about enabling liquidity, data, smart contracts, and infrastructure to be accessed _universally_, across all chains.

This is what Web3 needs now: the ability to use the best applications, the most relevant data, and the deepest liquidity, regardless of which chain they originated from.

To make this possible, we need more than bridges. We need a common foundation for verifiability and universality. That’s where Pi Squared’s Verifiable Settlement Layer (VSL) comes in.

### **How the VSL Unlocks Value**

Pi Squared’s Verifiable Settlement Layer (VSL) redefines how blockchain systems interact. Rather than forcing every chain to speak the same language or adopt the same standards, VSL acts as a universal verification hub, a layer where smart contracts, data, and claims from _any_ ecosystem can be validated and made accessible _everywhere else_.

Using our Proof of Proof system, VSL doesn’t just trust external data, it mathematically proves its correctness. Whether it’s a transaction from Ethereum, a smart contract execution on Solana, or an AI model inference on a Layer 3, VSL lets developers verify once and use it anywhere.

This is how we turn TVL into TVU:

*   Liquidity from one chain can be deployed cross-chain with no loss of integrity.
*   Smart contracts written in one language on one chain can be verified and referenced in another chain’s execution environment.
*   AI models and off-chain computations can be verified cryptographically and settled as well on the VSL, and thus be made usable across applications and chains.
*   Off-chain knowledge and on-chain state can be brought together under a single verifiable architecture.

With TVU, we stop measuring how much is trapped, we start measuring how much is empowered.

### **Why This Matters Now**

As more chains launch and as application-specific infrastructure proliferates, the fragmentation of Web3 will only accelerate. But if we can’t share liquidity, contracts, or data across these environments easily, the user experience will remain fractured, and adoption will inevitably stall.

TVU offers a new framework for thinking about growth. It prioritizes composability, reach, and usability over isolated numbers. It rewards developers who build interoperable systems, and it guides ecosystem architects to think about how their infrastructure connects, not just what it contains.

The shift from TVL to TVU is more than semantics. It’s a shift in values away from isolation, toward verifiable openness.

### **The Future We’re Building**

At Pi Squared, we believe that the future of Web3 isn’t about choosing a chain. It’s about making all of them usable, composable, and provably secure together.

By focusing on TVU, and building the infrastructure to support it through the Verifiable Settlement Layer, we can move beyond liquidity islands and toward a truly interconnected blockchain ecosystem.

TVU isn’t just a metric. It’s a mission.

Let’s unlock what’s next together!

---

# Pi Squared’s Integration with Wormhole NTT

_Seamless Cross-Chain Interoperability with Mathematical Certainty: Integrating **Pi Squared’s** **USL** with Wormhole’s Native Token Transfer Framework_

In the dynamic and swiftly evolving blockchain landscape, interoperability stands as both a critical challenge and catalyst for innovation. As applications aim to leverage the unique capabilities of multiple blockchains, developers face complexities arising from differing programming languages, VMs and consensus mechanisms. Wormhole addresses these challenges through its Native Token Transfers (NTT) framework — an open, flexible and modular token transfer mechanism facilitating secure asset transfers across numerous blockchain environments, securing tens of billions of dollars in value across the blockchain sphere.

Today we are thrilled to announce the integration of **Pi Squared’s** **Universal Settlement Layer (USL)** as a Transceiver within the NTT framework. By bringing the mathematical rigour of **Pi Squared’s** verifiable computing platform together with the robustness of Wormhole’s infrastructure, we are charting a course toward more interconnected, efficient and verifiably secure blockchain infrastructure.

**Understanding Wormhole’s Native Token Transfer Framework**
------------------------------------------------------------

NTT offers an elegant solution to interoperability across disparate networks, abstracting the complexities of transferring tokens between blockchains and enabling developers to focus on building applications that harness the unique properties of each chain without grappling the underlying mechanics of the VM.

At the heart of NTT is the concept of modular Transceivers — responsible for the transmission and reception of messages across blockchains. This modularity permits the integration of a range of attestation methods and any verification mechanism an integrator wishes to leverage, providing developers with the flexibility to tailor security and performance characteristics to their specific needs and future-proof their multichain messaging layer.

Its design prioritises scalability and extensibility, so as new blockchains emerge and existing ones evolve, NTT should continue to adapt to incorporate these changes. This approach enables developers to build blue-chip multichain applications that are capable of leveraging the latest technological advancements and enhancements.

**Introducing Pi Squared’s Universal Settlement Layer**
-------------------------------------------------------

**Pi Squared** is pioneering a new paradigm in verifiable computing through its **Universal Settlement Layer (USL)** and the **Proof of Proof** protocol. **USL** is a universal, decentralised network capable of validating and settling any mathematically provable claim. It facilitates true interoperability and trustlessness in blockchain interactions — transcending the limitations of traditional systems.

The core idea is that any computation or transaction that can be mathematically proven can be settled on **USL**. This includes proofs of program execution, instantiated transactions with pre-states and post-states, or even entire blocks; essentially any claim that can be represented mathematically. By leveraging formal semantics and programming languages, **USL** provides mathematical proof that a system started in one state and transitioned to another.

**USL** is not a traditional blockchain but a decentralized network where each claim is independently verifiable, forming a set of elements rather than a chain of blocks or transactions. The method of verifying these claims is flexible, allowing for various proof systems and verification methods. Validators can accept any type of proof provided with the claim, be it a SNARK, a STARK, or even re-execution of the computation. This design minimises the trust base and enhances security by allowing participants to choose their preferred method of verification.

Embracing a “**Bring Your Own Language**” philosophy, its universality is further enhanced by its language and VM agnosticism. It empowers developers to write smart contracts in any programming language, eliminating barriers to entry and laying the grounds for a diverse and expansive developer community to get involved.

The technical foundations of **USL** are deeply rooted in decades of research in formal semantics and logic spearheaded by Prof Grigore Rosu, particularly through the K Framework which allows for formal specification of programming languages and VMs, and Matching Logic which serves as the foundation for K.

**The USL Transceiver Implementation**
--------------------------------------

This integration represents a convergence of advanced technologies aimed at enhancing the security and efficiency of inter-chain operations, predicated on the recognition that mathematical certainty is a key to ushering in the maturation of blockchain infrastructure. Below detailed are the specifics of the integration:

**USL Transceiver Mechanics**

Within the NTT framework, **USL** is integrated as a custom Transceiver. This Transceiver handles the sending and receiving of NTT messages with **USL’s** flexible approach to claim verification.

1.  Transaction Initiation and Claim Construction:

*   A user initiates a token transfer on the source chain by interacting with the NTT Manager contract, which passes the transaction details to the **USL** Transceiver.
*   The **USL** Transceiver constructs a Transceiver Message containing the transfer details and forwards it to the **USL** core contract.

2\. Event Emission and Off-Chain Claim Generation:

*   The **USL** core contract stores the Transceiver Message and emits an event with data sufficient to reconstruct the claim.
*   An off-chain claim generator monitors these events, retrieves the necessary data from the source chain, and constructs the claim along with its validity proof.

3\. Claim Submission and Validation:

*   The claim and its validity proof are submitted to the **USL** network, where validators independently verify the claim based on the provided proof.
*   Validators do not need to store the entire blockchain state; they acquire only the data necessary to verify the claim.

4\. Inclusion Proof Generation and Relaying:

*   Once validated, an inclusion proof is generated to attest that the claim is part of the validated set within **USL**.
*   A relayer retrieves the validated claim and inclusion proof and submits them to the **USL** **Transceiver** on the destination chain.

5\. Verification and Transaction Finalization:

*   The **USL** **Transceiver** on the destination chain verifies the inclusion proof and processes the claim.
*   The corresponding NTT Manager contract on the destination chain finalizes the NTT transfer, resulting in the minting or unlocking of tokens for the user.

![](https://blog.pi2.network/content/images/size/w2400/2024/11/2024-10-03---Pi2-Wormhole-Diagram.png)

Click image for expanded view

This approach to cross-chain messaging introduces some bleeding-edge innovations worth considering:

*   **Elimination of Multiple Circuits:** By employing a single ZK circuit for mathematics, the **USL** eliminates the need for multiple specialized circuits. This streamlines the verification process and reduces complexity compared to existing systems.
*   **Flexible Trust Model:** Validators have the flexibility to choose their preferred method of claim verification, whether by accepting zero-knowledge proofs (e.g., SNARKs, STARKs) or by re-executing the computation independently.
*   **Scalability Through Independent Claim Verification:** Claims are self-contained and independently verifiable, allowing for parallel processing and increased throughput without the need for validators to maintain full blockchain states.
*   **Complementing Existing Infrastructure:** The integration enhances the NTT framework by introducing a mathematically rigorous method of claim verification, broadening the spectrum of available attestation methods.
*   **Mathematical Proofs as the Basis for Trust:** Central to **USL’s** approach is the notion that computation itself is proof. Every computational claim is treated as a theorem, and by generating formal proofs of these claims using K and Matching Logic, **USL** ensures correctness by construction.

With the **USL** Transceiver, integrators benefit from the scalability and efficiency introduced by its lightweight validation process. The adjustable trust base with flexibility in proof methods allows them to tailor security models according to varying risk tolerances and compliance needs.

For more detailed information on the Native Token Transfers architecture, please read the detailed [documentation](https://wormhole.com/docs/learn/fundamentals/architecture/?ref=blog.pi2.network)
 or reach out directly to the **Pi Squared** team if this technology is of interest to you or your project.

**Future Possibilities, Closing Thoughts**
------------------------------------------

While the current build focuses on token transfers through NTT, the underlying principles and technologies of **USL** open avenues for broader applications. The flexible approach to claim verification allows for the incorporation of new proof systems and verification methods as they emerge, ensuring the system remains at the forefront of advancements in a swiftly-evolving environment with robust demands and needs.

The ability to represent and verify any mathematically provable claim could also extend to more complex multichain interactions, such as smart contract calls and data exchanges. By enabling verification through any means possible, **USL** paves the way for sophisticated services requiring high degrees of computational integrity.

This integration marks a significant step toward achieving true interoperability and trust minimization in multichain interactions. Combining the principles of universality and formal verification with collaborative spirit, we are charting a course toward a more secure and interconnected ecosystem.

**Watch the Universal Settlement Layer for Wormhole Presentation at Devcon.**

---

# Matching logic and mathematical proofs of program execution

Pi Squared uses matching logic and the K framework to mathematically prove that program executions are correct, enabling trustworthy and language-agnostic development tools.

When you write code, it's usually pretty simple: you pick a language, type your program, and use tools like compilers or interpreters to make it run. That's the normal deal, and sometimes programmers simply take these tools for granted. 

But there's a catch. What if those tools get it wrong? What if they have bugs? And actually, they most likely do have bugs because these tools are built from complicated software, sometimes with millions of lines of code. If something’s off in how these tools are built or how they process your program, it could go haywire.

The people building these compilers and interpreters want them to be bulletproof, but proving every part works perfectly is nearly impossible. And that's a [trust](https://blog.pi2.network/trust-in-web3/)
 problem.

At Pi Squared, we're not trying to prove the whole system's perfect, but we are trying to prove that each job it does is right. We do this by using an approach called [matching logic.](http://www.matching-logic.org/?ref=blog.pi2.network)
 It's a way to formally, mathematically, and rigorously define the behaviors of any program in any programming language using finitely many semantic rules. Instead of writing code, we write these rules that say how code should work. These rules are like a blueprint for the language, and they're the key to building tools that you can trust.

In this post, we’ll walk you through how matching logic and the K framework team up to prove programs run the way they should. You’ll see how we define a language’s rules, build tools from them, and use math to check every step.

**What are Semantics?**
-----------------------

Semantics defines the meaning of your code—what it actually _does_ when it runs, not just how it’s written. While syntax is the structure, semantics is the **behavior**. A semantics of a programming language defines the behaviors of all programs written in that language, rigorously and mathematically. At Pi Squared, we use matching logic to define the semantics of any programming language. This lets us prove each job, like running code, is correct, and this capacity has been baked into the K framework.

**Watch our ETHDenver 2025 session below to learn more.**

**The K Framework: Building tools from rules**
----------------------------------------------

The [K framework](https://kframework.org/?ref=blog.pi2.network)
 is a tool that takes the rules of a programming language and builds tools from them. These tools can be anything from parsers that read your code to interpreters that run it. Instead of writing these tools yourself, the K framework creates them automatically based on the formal semantics. You just define how the language works — things like what a loop does or how variables get assigned — and K handles the rest.

The K framework is at the heart of what we do at Pi Squared. It lets us define the semantics of a language in a formal way and then use those semantics to automatically generate tools that run programs.

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXdDUlG_KR5l8PmV8NbE9I25j4taL7BULjhDmYpElzzI-FmAgJ9jxYHYEDJVVAiZaiaAY4H0c7UTMyid_vHKvucVLKu-BJr3oaIKBxHTF4zJhCXJyK7Jgu7hrGqHQZIbye-WuOSXkQ?key=Aj-K2HjDPVskB3lzd8K1lmK4)

**Figure 1**_: The K framework generating tools to run programs_ 

It has generated tools for C and Java, for example, straight from their semantics in a fully automatic way. This way, we can separate the design of a language from the tools that make it work. Language designers can focus on making a language that's easy to use, and K takes care of the hard part of building tools that run it.

**Matching logic**
------------------

Matching logic is a way to turn the correctness of program execution into proving math theorems. It takes the semantics of a language and describes what's supposed to happen when you run your code. We use matching logic to write down exactly how a program should work in a clear, logical way. It's the foundation of how K understands languages — it lets us take the rules we defined and describe what's supposed to happen when you run your code.

Here's how it works. When you write a program, you're telling the computer to do something. You're giving it a set of instructions, and you expect it to follow them. Matching logic lets us write down these instructions in a formal way. We can say things like, "If you see this, then do that," or "This should happen before that." These rules are like a blueprint for how a program should run, and they're the key to proving that a program does what it's supposed to.

**Proving it works**
--------------------

At Pi Squared, we don't try to prove the whole K framework is perfect—that's next to impossible with over half a million lines of code that's always changing. Instead, we focus on each thing it does, like running your program or checking if it's correct. For every task, we use matching logic to create a proof—a mathematical way to show that this one job went exactly as planned.

When K runs your code, it keeps track of every step—where it starts, what rules it follows, and where it lands. Matching logic takes that and turns it into a formula we can prove, like saying, "This program starts here and ends there, and every move in between checks out."

These proofs are like certificates—you can look at them and know they're legit. We tested it with a simple program that ran 100 steps, and it made a huge proof, 1.6 million lines long, but our checker confirmed it in just 5.6 seconds. That speed matters—it shows this isn't just theory; it can work for real.

This is how we were able to achieve this. First, K gives us what we call proof parameters—a log of what it did, like the exact steps and rules it used. Then we take that log and turn it into a full proof with matching logic. After that, we hand it to a matching logic proof checker, a small, fast tool that double-checks everything.

We trust this matching logic proof checker because it's simple and solid—perfect for catching mistakes. Some parts of these proofs, like the basic logic rules, only need to be checked once and can be reused. The rest, tied to your specific program or language, gets built fresh each time. It's a smart way to skip wrestling with all of K and just nail down what's happening right now. 

**Wrapping it up**
------------------

We’ve walked you through how we use matching logic and the K framework to prove programs work the way they’re supposed to. It starts with semantics—defining what code really means—then moves to building tools from those rules with K.

Matching logic turns that into math we can prove, step by step, so you know every job, like running a program, is solid. It’s all about trusting tools that are fast, reliable, and work for any language, right from the ground up. That’s what we’re doing at Pi Squared.

Want to know more? Our [whitepapers](https://pi2.network/papers?ref=blog.pi2.network)
 provide deep insights into all the parts of our technology. For a simpler breakdown, check out our [docs](https://docs.pi2.network/?ref=blog.pi2.network)
 — they'll give you the big picture without the heavy details. If you want to join our developer community, you can sign up on our [developer portal](https://pi2.network/developer?ref=blog.pi2.network)
.

---

# Pi Squared + pod: Faster Finality and Trustless Verification

While blockchains promise decentralization, they come with frustrating trade-offs like slow finality, expensive transactions, and networks that crumble under real demand. For developers, this means building user-friendly applications remains a significant challenge.

[**pod**](https://pod.network/?ref=blog.pi2.network)
 takes a different approach. Instead of enforcing a rigid, total order of transactions like traditional blockchains, **pod** is a **layer-one primitive** designed for speed and efficiency. By embracing **partial ordering**, it removes unnecessary bottlenecks, allowing transactions to settle faster and scale better.

Now, **Pi Squared** is integrating **pod** into its infrastructure by deploying the smart contracts on the **pod** network. For a start, we’re using **pod** as the backend for our [Universal Settlement Layer](https://docs.pi2.network/universal-settlement-layer/what-is-usl?ref=blog.pi2.network)
 (USL), leveraging its performance to enhance how we handle transactions.

Let’s explore how this works and how it’ll benefit the Web3 community.

**How will Pi Squared and pod work together?**
----------------------------------------------

### **Understanding pod**

First, let’s break down what **pod** is all about.

As earlier stated, **pod** is a layer-one primitive, which is designed to take transactions as input and produce a log (a sequence of transactions) as output. Unlike traditional blockchains that enforce a total order of transactions, **pod** introduces a weak consensus protocol where transactions are only **partially ordered**. This means that while transactions are arranged in a sequence, their exact positions may shift slightly over time—a concept often referred to as "wiggle room."

By allowing for this flexibility, **pod** achieves both latency-optimal and throughput-optimal performance. It eliminates inter-validator communication, allowing clients to submit transactions directly to the network, where they are ordered in an efficient and scalable manner. This makes **pod** a powerful backend for decentralized applications that need high-speed, verifiable data without the bottlenecks of traditional consensus mechanisms.

### **Pi Squared’s Universal Settlement Layer (USL)**

Now, let’s shift our focus to **Pi Squared’s** [Universal Settlement Layer](https://docs.pi2.network/universal-settlement-layer/what-is-usl?ref=blog.pi2.network)
 (USL).

The USL is **Pi Squared’s** solution to blockchain interoperability. It acts as a universal settlement layer that allows different blockchain ecosystems to communicate and validate information without relying on centralized intermediaries.

At its core, the **USL** is built around claims—mathematically provable statements that can be verified by various proof mechanisms. These claims cover a wide range of use cases, from verifying computation results to confirming blockchain states or transactions. Once verified, claims are permanently stored within the **USL**, forming a growing set of trusted data that different applications can query and use.

One of the key strengths of the **USL** is its flexibility: it doesn’t enforce any particular or specific proof mechanism. Instead, it’s configurable to work with any existing proof mechanisms, from the simplest validation-by-re-execution (as in traditional blockchains) to validation-by-proof-certificates (using zero-knowledge proofs or [Proof of Proof](https://blog.pi2.network/guide-to-proof-of-proof/)
). This allows developers to choose the verification method that best fits their needs while maintaining the benefits of a shared settlement layer.

![](https://blog.pi2.network/content/images/size/w2400/2025/02/2025-02-19---Universality-Module-Stack-Fig-8-Version-2-1.png)

The image above illustrates how different blockchain components interact with the **USL**. Blockchains, bridges, decentralized applications (dApps), and light clients submit various types of claims to the **USL**. Each claim is accompanied by a proof mechanism that ensures its validity.

Once inside the **USL**, these claims form a **Validated Claim Set**. After verification, the claims can be accessed by dApps via a **Membership Verifier**, which checks the inclusion of specific claims within the validated set. 

### **Why USL and pod are a perfect match**

The integration of **pod** with **USL** wasn’t just a technical decision; it was a natural fit that enhanced both systems.

The reason is that in **USL**, claims are self-contained. This means that they can be verified independently and in any order. Unlike traditional blockchain systems that require a strict sequence, **USL** maintains a **validated claim set** rather than a **total-ordered claim list**.

**pod**, on the other hand, achieves latency-optimal and throughput-optimal processing by weakening the total order requirement of transactions. That means, transactions in **pod** aren’t locked into a rigid sequence—they “wiggle” within a predictable range, ensuring speed without compromising integrity.

Because **USL** doesn’t require strict ordering for claim verification, integrating with **pod** allows **USL** to achieve **faster finality**. At the same time, **pod** generates certificates that confirm a claim’s verification and inclusion in the log. These certificates can then serve as membership inclusion proofs within **USL**, reinforcing trust and efficiency.

**The integration: Using pod as the backend for USL**
-----------------------------------------------------

Now, here’s where things get interesting. **Pi Squared** is integrating **pod** as the backend for the **USL** component of its infrastructure. This means that when claims are generated within the **USL**, they will be stored, retrieved, and validated using **pod's** decentralized network.

### **How it works**

![](https://blog.pi2.network/content/images/size/w2400/2025/02/2025-02-19---Pod-Blog-Diagram-3.png)

Click to zoom

*   The **USL** claim verification logic is deployed as a contract on the **pod** network. A user calls the “verify” function with claims and proof on the **USL** contract.
*   The **pod** protocol verifies the claim verification result and appends it to its logs.
*   A **USL** client can subscribe to the events on the **USL** contract on **pod**, enabling it to track and query verified claims.
*   The verified claim, along with its membership inclusion proof (**pod** receipt certificate), can then be used across various dApps.

By leveraging **pod's** storage and verification capabilities, the **USL** gains a more robust, scalable, and censorship-resistant backend. This integration enhances the reliability of cross-chain claims, ensuring that dApps and blockchain ecosystems can trust the data they query from the **USL**.

For now, more focus is on this backend integration, but this is just the beginning. The collaboration between **Pi Squared** and **pod** has the potential to evolve further, with more innovations on the horizon.

**How this collaboration benefits the Web3 ecosystem**
------------------------------------------------------

The integration between **Pi Squared** and **pod** introduces several key advantages for the broader Web3 space:

*   **Enhanced trust and security**: With **pod** acting as a decentralized verification layer, dApps and blockchains can validate claims without relying on centralized intermediaries, reducing points of failure and censorship risks.
*   **Greater interoperability**: **USL** facilitates seamless communication between different blockchain networks, enabling a more unified Web3 experience where assets, data, and applications can move freely across ecosystems.
*   **Scalability and efficiency**: Instead of performing expensive on-chain computations, dApps can rely on **pod's** verified claims to access trusted data, reducing gas costs and improving performance.
*   **Developer flexibility**: The **USL’s** support for multiple proof mechanisms, combined with **pod's** decentralized storage, provides developers with more options to build secure, cross-chain applications tailored to their needs.

**Looking ahead**
-----------------

As stated earlier, while this integration is a significant step forward, it’s only the beginning. As **Pi Squared** and **pod** continue to collaborate, we can expect further innovations. The Web3 ecosystem is evolving, and partnerships like this will play a crucial role in shaping its future.

Our integration isn't just talk. See the fully functional demo presented at ETHDenver below.

---

# Why Web3 Needs a Universal Settlement Layer

In an age of growing dependence on distributed computing, trust is widely given by developers and users in Web3. This is particularly concerning when it comes to the Programming Languages (PLs) and Virtual Machines (VMs) that are core to blockchain development and operations. As Web3 grows into a fragmented space of various PLs and VMs, each will potentially come with its own Zero Knowledge (ZK) circuit in order to offer the desirable benefits of [verifiable computing](https://en.wikipedia.org/wiki/Verifiable_computing?ref=blog.pi2.network)
. As developers, we’re forced to trust that these critical yet very complex systems will operate accurately and efficiently. How do we verify that these critical systems are working as intended?

With billions of lines of code and continuous updates to keep infrastructure aligned with technological advancements, verification of accurate and correct operations becomes a daunting task. Verifiable computing promises correct results for computations done in completely untrusted remote computing environments, which is particularly important for decentralized Web3 infrastructure.

At **Pi Squared**, we term the present as Verifiable Computing 1.0. Where the challenge lies not only in maintaining trust in the current versions but also in every new update. 

We aim to usher in a new era of verifiable computing. An era where correctness and universality are paramount. We call this Verifiable Computing 2.0, and it’s why we’re introducing **Pi Squared’s** **Universal Settlement Layer** (**USL**), a groundbreaking project designed to revolutionize the process of building apps that are multi-chain and multi-language.

What is USL?
------------

**USL** makes it easier for any developer to create interoperable smart contracts for any blockchain or Programming Language. With **USL,** developers can identify and minimize trust bases. Additionally, it connects blockchains without moving assets, which means **USL** limits the possibility of bridging hacks. Furthermore, developers can create higher quality applications, resulting in better and more secure user experiences.

**USL** brings universal settlement to modular blockchains, settling any claim that is provably correct. It uses the novel [**Proof of Proof**](https://blog.pi2.network/guide-to-proof-of-proof/)
 protocol, making it the first project constructed on top of **Pi Squared’s** core technology. In a decentralized lending application, for instance, a borrow operation is deemed valid only if the claim that the borrower is sufficiently collateralized is mathematically provable, which is checked by verifying the corresponding ZK proof. As a result, **USL’s** “transactions” are in fact mathematically provable claims, whose correctness is witnessed by independently and efficiently checkable [Zero-Knowledge proofs](https://en.wikipedia.org/wiki/Zero-knowledge_proof?ref=blog.pi2.network)
 (ZKPs).

Why Does Web3 Need USL?
-----------------------

In simple terms, **USL** acts as a common verifiable database of true facts, making it unnecessary for developers to use messaging platforms and bridges. This change can significantly simplify the process of building multi-chain applications. It also allows for abstraction of cross-chain capabilities that decentralized applications (dApps) would typically be required to build.

One of the unique features of **USL** is its ability to explicitly highlight trust assumptions. It exposes the _trust base_ underlying each application, thereby offering a clearer view of the trust dynamics involved in every transaction or any on-chain operation. 

The fragmentation within the world of Layer 2 (L2) solutions has become increasingly apparent and poses a significant challenge in blockchain development. **USL** aims to mitigate this fragmentation, paving the way for a more unified and efficient blockchain ecosystem.

What are the Benefits for Web3
------------------------------

The benefits of **USL** extend far beyond convenience. For Web3, **USL** can identify trust bases which will allow builders to minimize trust. It empowers users and developers to make conscious decisions about these trust assumptions. 

With **USL,** developers can use different front ends, wallets, sequencers, and allow users to choose the components _they_ trust. This gives developers _and_ users the freedom to make a conscious decision and take control of their trust assumptions. This flexibility makes trust choices explicit and allows developers to see which components in the generation or execution of a transaction were trusted.

**USL** is not limited to benefitting developers. Various stakeholders stand to gain from its implementation, including Data Availability (DA) customers, dApps that require a common database, Layer 2 and Layer 3 solutions, and even bridges.

Applications Powered by USL
---------------------------

USL is envisioned to enable the building of new and unique applications for its settlement service. Below, we highlight four application types enabled by USL:

**Rollup-in-a-box**  
Enables the development of L2/L3 rollups and appchains, providing support for various programming languages and virtual machines for both off-chain code and on-chain smart contracts.

**Multi-chain bridging**  
Enables rollups and applications on USL to seamlessly bridge tokens across multiple chains on-chain, eliminating the need for off-chain code.

**Cross-chain financial applications**  
Enables DeFi applications to seamlessly transition between various rollups and appchains by settling transactions on USL, regardless of the differing VMs and platforms used by the involved chains.

**Heterogeneous ZK verification**  
Enables builders to use the ZK platform of their choosing, as USL validates transactions through a zero-knowledge (ZK) proof verification process, utilizing the appropriate ZK backend.

❗️ Learn more about use USL cases - [https://docs.pi2.network/verifiable-settlement-layer/what-is-vsl#use-cases](https://docs.pi2.network/verifiable-settlement-layer/what-is-vsl?ref=blog.pi2.network#use-cases)

Benefits outside of Web3
------------------------

In addition to these, the AI space can significantly benefit from **USL**. Its ability to validate any claim, even in non-blockchain systems, can be invaluable in Artificial Intelligence (AI) operations.

In the rapidly evolving world of Web3, **USL** stands as a beacon of interoperability and trust. It serves as a vital tool for multi-chain applications, fragmented ecosystems, and AI model providers. As we continue to explore and expand the boundaries of what’s possible, **USL** will undoubtedly play a pivotal role. If you’re intrigued and want to discover more about **USL**, we invite you to [reach out](https://pi2.network/contact?ref=blog.pi2.network)
 and check out our [docs](http://docs.pi2.network/?ref=blog.pi2.network)
.

[Reach out to Pi Squared](mailto:contact@pi2.network)

---

# Pi Squared’s Universal Language Machine (ULM): Revolutionizing Web3 Development

During Devcon 7, we unveiled a groundbreaking innovation that’s set to redefine Web3 development: the **Universal Language Machine (ULM)**. This revolutionary platform empowers developers to write and execute programs in _any_ programming language on _any_ blockchain, shattering barriers that have long hindered adoption.

Watch our ULM Workshop from Devcon!

By leveraging over five decades of research in formal semantics, **ULM** eliminates the need for traditional language implementations such as compilers and interpreters. Its “**Bring Your Own Language**” (**BYOL**) feature allows developers to use familiar languages - C, Python, Rust, or even domain-specific languages - to create smart contracts and decentralized applications (dApps). With **ULM**, universality is no longer an abstract concept but a practical reality, transforming every developer into a potential Web3 innovator.

### **The Power of Formal Semantics**

At the heart of **ULM’s** innovation lies the concept of formal semantics—a rigorous, mathematical definition of a programming language’s behavior. This approach bypasses the need for language-specific tools like compilers or interpreters, replacing them with computation based on mathematical proof. The integrity of these proofs can be verified using simple proof checkers, ensuring reliability and eliminating bugs. **ULM** transforms this theoretical foundation into a practical solution, enabling developers to define and upload the semantics of their preferred languages to the platform. Once uploaded, these semantics allow anyone to execute programs written in that language, fostering a collaborative and efficient ecosystem.

### **Breaking Barriers for Web3 Adoption**

Imagine a game developer wanting to migrate their project, built in Unity, Unreal, or JavaScript, to the blockchain. Traditionally, this would require the team to learn a blockchain-specific language like Solidity - a significant barrier to entry. With **ULM**, developers can write both the game and its smart contracts in their preferred languages, streamlining the process and preserving existing workflows. This flexibility makes Web3 more accessible, empowering developers to transition seamlessly from Web2 to blockchain-enabled ecosystems.

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXfpmj4x3S968oZY2sJn8uc46NLqy7LN-EIvTMin3G6bk9CDjp3OpPDiRNZYf7-oHfcmve5gbuX0XeT4nV5sOO35aF-zcrIRCXZrKJ0hUnDtDymXKl75vtTbzu_q_Jv-kfPhAT_a2w?key=xuwIsYwnhmNrut4RTHlx96y1)

Universality is more than a technical achievement - it’s a paradigm shift. Just as human languages can marginalize those who don’t speak a dominant tongue, programming languages create barriers for developers. **ULM** addresses this challenge by offering a universal framework where any language can be integrated and executed. Inspired by the K framework, **ULM** separates language design from tool implementation, allowing developers to upload formal language semantics and automatically generate tools like compilers, interpreters, and verifiers. This innovation reduces complexity, accelerates development, and democratizes Web3 access.

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXehuA5ol_vVjJWDUZVXhl6qTahli3YqedBhFw-NLl3dVdZ0l01V2sQjdi1BUqA8VmDiMTi43x7bgw6WYsPPRil0OprUFt1HbRqx7s3Z5zErAHwivr-IoRXJflOwLRm_i85HcOTlCw?key=xuwIsYwnhmNrut4RTHlx96y1)

### **Expanding the Web3 Developer Ecosystem**

Web3 currently boasts around 26,000 developers, a number dwarfed by more than 38 million Web2 developers worldwide. **ULM** has the potential to bridge this gap, enabling millions of developers who know and love working with popular languages like Python, C, and Rust to seamlessly create smart contracts and dApps. Removing the need for specialized blockchain knowledge, **ULM** opens the door for tens of millions of developers to enter the Web3 space, unlocking unprecedented growth for the ecosystem.

![](https://blog.pi2.network/content/images/size/w2400/2024/12/Screenshot-2024-12-10-at-1.32.02-PM.png)

****Data Sources:**** [SlashData, State of the Developer Nation, 25th Edition, Q3 2023](https://www.developernation.net/resources/reports/state-of-the-developer-nation-25th-edition-q3-20231/?ref=blog.pi2.network)
 and [Electric Capital, Developer Report, July 2024](https://www.developerreport.com/ecosystems/ethereum?ref=blog.pi2.network)

**Pi Squared’s** **Universal Language Machine (ULM)** is more than a product—it’s a movement to make Web3 development universally accessible. Whether you’re a seasoned blockchain developer or new to the space, **ULM** empowers you to innovate without limits. Visit our [Developer Portal](https://pi2.network/developer?ref=blog.pi2.network)
 to learn more, and explore our [documentation](https://docs.pi2.network/?ref=blog.pi2.network)
. Together, we can turn every app into a dApp and make the future of Web3 a reality for all.

Stay tuned for more updates, and thank you for joining us on this exciting journey!

---

# Why We’re Renaming the Universal Settlement Layer / Introducing the VSL

At Pi Squared, our work has always centered around one thing: building trustworthy foundations for the next generation of blockchain applications. We believe that [trust](https://blog.pi2.network/trust-in-web3/)
 doesn’t come from promises; it comes from proofs. That’s why today, we’re renaming the **universal settlement layer (USL)** to the **verifiable settlement layer (VSL)**. This is not only a name change, but more importantly, a shift to emphasize our commitment to verifiability, correctness, and security as the pillars of a new Web3 infrastructure.

We didn’t set out to build yet another protocol. We set out to build something deeper, a settlement layer that could connect blockchains, programming languages, and virtual machines in a verifiable way, through mathematical guarantees. The word “universal” captures our ambition but “verifiable” captures the essence.

Verifiability is what makes trustless systems actually trustworthy. It’s what separates noise from signal, speculation from certainty. In a world where the complexity of multi-chain applications is growing faster than ever (faster than any of us can keep up), correctness and verifiability are no longer optional; they are requirements.

The role of a settlement layer in Web3
--------------------------------------

To understand why [VSL](https://docs.pi2.network/verifiable-settlement-layer/what-is-vsl?ref=blog.pi2.network)
 is so crucial, we need to talk about how blockchains talk to each other, and why most of them still don’t.

Today’s Web3 ecosystem is fragmented. Each chain runs on its own virtual machine, its own consensus protocol, and its own assumptions about correctness. Cross-chain communication is typically handled by bridges and middleware that introduce more trust base and assumptions, not less.

To address the issue of Web3 fragmentation, VSL unifies the mathematical sound guarantees for computation, transactions, and vetted information as VSL claims, which can be verified. Instead of enforcing any particular verification mechanisms for these computation claims, transaction claims, and vetted information claims, VSL allows users and applications to freely pick the most suitable verification mechanisms for them, based on their budgets and requirements, with a variety of options ranging from digital signatures and re-execution to mathematical and zero-knowledge proofs (ZKPs).

Once a claim is verified, VSL settles it for good by adding it to a universal set of all claims that have been verified so far. At any time, users or applications can query the VSL about the status of a claim of interest, and if that claim has been settled, VSL returns a short VSL membership proof, which can be easily verified by the VSL smart contracts. This VSL membership proof shows that the said claim is indeed a member of the universal set of settled claims. The validation of the VSL membership proofs is sufficiently simple to be implemented as on-chain smart contracts. 

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXdEq1_FSHiHFRbedwYXcytAz7xlZsB79q4UefnzIlihPL1JlyTgkcw-5Q3euuSk6BHtwai2ZY0z-qqSwoXC9CwQHacgVZX0iwX458lCvwhnkhQFgA7l1KfagIDTKizVPYyzwQI29A?key=kntDB0V5nf2UUmg_78_k8Vk2)

**Figure 1**: _The verifiable settlement layer (VSL) architecture_

And thus, our VSL slogan is “Verify **once**, use **everywhere**.” 

Why is this name change important?
----------------------------------

The name “universal settlement layer” reflected a vision of broad applicability. It spoke to a layer that could support any chain, any language, any VM. That part still remains true. However, we realized the name was missing something critical. “Universal” suggests reach, but it doesn’t communicate how that reach is achieved or why it matters.

The name “verifiable settlement layer” makes it clear that our priority is not just breadth but, more importantly, trustworthiness at scale. Verifiability is the key to addressing the issue of fragmentation in the Web3 space and is what sets Pi Squared apart from the existing solutions. VSL is the common settlement layer that connects the fragmented Web3 ecosystem islands via verifiability, only through which we can safely bring in and interact with data, information, and knowledge off/outside-chain. 

What does this mean for developers and protocol builders?
---------------------------------------------------------

For developers, the verifiable settlement layer (VSL) allows your applications to interact with other applications in any ecosystem written in any programming language, in a verifiable way, as you specify. 

For protocol and infrastructure builders, VSL enables more efficient and customizable realizations of cross-chain components. We envision a new spoke–hub distribution paradigm, with VSL being the hub that verifiably connects ecosystems, applications, protocols, and users, thus reducing the interconnectivity complexity from quadratic to linear.

Looking ahead
-------------

The renaming of the universal settlement layer to the verifiable settlement layer (VSL) marks a turning point in how we think about Web3’s foundational infrastructure. We’re not just imagining a more connected world. We’re engineering one that’s provably correct from the ground up.

Verifiability is the new universality. And with it, we’re building a blockchain future that developers can trust, users can rely on, and communities can grow with, securely, confidently, and without compromise.

And we’re only just getting started!

[Follow us on X](https://x.com/Pi_Squared_Pi2?ref=blog.pi2.network)
 to learn about the latest VSL updates.

---

# Trust in Today's Blockchain Space

What's your first memory of riding a bike as a child? Maybe it was the sound of air hissing as you pumped up the tires, cruising through the neighborhood, or taking a fun dirt path through the woods. For me, it started with a dream — a shiny bike hanging in my father's garage. It was old and creaky, but I didn't care. At seven years old, it became mine.

That joy was short-lived. First, I broke it. Then, after getting a brand-new one, something worse happened — someone asked to hold it for a moment, and that was the last time I saw it. If you've ever lived in a tough neighborhood, you know how that story ends. My mother's comforting words and a police officer's _half-hearted_ search didn't bring it back, but I walked away with a lesson: **trust is fragile.**

And in Web3, that lesson still holds.

**What does trust in Web3 look like?**
--------------------------------------

![](https://blog.pi2.network/content/images/2025/03/2024-11-1---Kid-astro-with-bike.jpeg)

__Credit: Image created on__ [__Grok by xAI__](https://x.ai/?ref=blog.pi2.network)

When I started writing this blog, I dug deep into trust models — both in software and social systems. But no matter how much I researched, my mind kept circling back to that stolen bike.

Today, Web3 feels a lot like my old neighborhood: locked doors, high fences, and big dogs. We have audits, monitoring, and endless security tools — yet scams, exploits, and failures still happen. When an environment needs constant protection, it signals a lack of trust, and without trust, doing business becomes difficult and unwelcoming.

We’re missing out on billions of potential users who hesitate to step into Web3. Not because they don’t understand it but because they don’t trust it.

### **Trust in tools and intentions**

Trust comes in two forms: **trust in tools** and **trust in intentions.**

The first is straightforward — would you ride a bike if you didn’t trust its brakes? In Web3, we trust tools like [Geth](https://developers.moralis.com/what-is-geth-and-geth-nodes/?ref=blog.pi2.network)
 because they’re _battle-tested_. But any new implementation? That takes time to earn trust.

The second is trickier. You can trust an audit, a smart contract, or a protocol, but do you trust the people’s claims about interaction with such protocols? Would you buy a brand-new bike from a stranger off the street? 

At **Pi Squared**, we understand the nuances of trust. Our team brings deep experience in formal methods, infrastructure, and security auditing — but we’re not just adding more fences and locks to Web3.

Instead, we focus on mathematical and proof mechanisms that are seamless, transparent, and explicit when it comes to proving intent. Because for Web3 to scale, trust can’t be an afterthought — it has to be built in.

**Trust in tools and Proof of Proof**
-------------------------------------

Building trust in Web3 means reducing blind faith in tools. If you have an execution of a transaction in a virtual machine (VM), you need to trust that the VM operates correctly. If you compile a program and run it with certain inputs, the so-called trust base would now include the compiler and the program itself.

In the modern blockchain stack, we have various VMs, protocols and components that are used for executing transactions. The trust base has immense size and formal verification is almost impossible in this case.

But even if it were possible, we also would have to trust the verification tool, and many of those are huge and developed by academic communities that don't have the resources or priorities to ensure the highest level of correctness.

That's where [**Proof of Proof**](https://docs.pi2.network/proof-of-proof/what-is-pop?ref=blog.pi2.network)
 — **Pi Squared's** approach to verifiable computing — comes into play. **Proof of Proof** allows us to drastically reduce the trust base required for executing transactions to a tiny proof checker with less than several hundred lines of code by making what previously constituted the trust base verifiable. 

Every major innovation builds on either mature technologies or new application domains. **Proof of Proof** does both, standing on three key pillars:

![](https://blog.pi2.network/content/images/2025/02/2024-10-25-Pillars-of-Proof-of-Proof.png)

1.  **Formal semantics** for your favorite programming language.
2.  **Mathematical proofs** that verify the correctness of program execution traces.
3.  **Zero-knowledge proofs** that compress large math proofs into compact, easy-to-store cryptographic artifacts.

Among the three components, the formal semantics of programming languages is a must for a trustless toolchain and infrastructure. 

When you write code, you trust your compiler to execute it correctly — but compilers are massive black boxes filled with millions of lines of code (and plenty of bugs). **Formal semantics** brings clarity by defining, in strict mathematical terms, all the behaviors of all the programs in the programming language; no compilers or interpreters need to be trusted.

At **Pi Squared**, we use the [**K framework**](https://kframework.org/?ref=blog.pi2.network)
, a system that's been in development for 20 years and is even used by [NASA](https://siebelschool.illinois.edu/news/rosu-sharpens-company-vision-with-third-nasa-sbir-grant?ref=blog.pi2.network)
. K-based transactions are already fast — nearly 90% as fast as Geth depending on a smart contract —and with further optimization, we've even hit 157% for certain protocols. And we're not stopping there; every month, we're improving performance.

But trust isn't just about execution — it's also about proof.

Even if K correctly executes your program, can you trust K itself? After all, it's another black box. That's where [**Matching Logic**](http://www.matching-logic.org/?ref=blog.pi2.network)
 comes in. Matching Logic allows K to generate **mathematical proofs** of execution that are fully machine-checkable. Proof checkers, in contrast to full compilers, are tiny — just a few hundred lines of code. So, the trust base gets reduced to a tiny checker instead of a huge K.

With formal semantics, K, and mathematical proofs, we don't need to blindly trust millions of lines of code anymore. Proof of Proof minimizes the trust base to formal semantics and a tiny proof checker.

**Verifying intentions with USL**
---------------------------------

When interacting with blockchain systems, we’re constantly asked to trust claims about computation, blockchain state, or even consensus. But how do we know these claims are true?

That’s where one of the three core components of Pi Squared’s architecture comes in**:** [**The Universal Settlement Layer (USL)**](https://docs.pi2.network/universal-settlement-layer/what-is-usl?ref=blog.pi2.network)
**.** USL enables multiple ways to verify these facts, and **Proof of Proof** is one of them.

**USL** introduces the concept of various claims, an evolution of traditional blockchain transactions. For example, a block transition claim is not just a transaction or set of transactions; it also specifies conditions for the blockchain's **before** and **after** states. This means that when you sign a transaction, you're not just trusting code — you're verifying guarantees.

![](https://blog.pi2.network/content/images/size/w2400/2025/02/2025-02-19---Universality-Module-Stack-Fig-8-Version-2-2.png)

__Structure of a Universal Settlement Layer (USL) claim__

However, as seen in the figure above, block transition claims are just one part of the picture. **USL** supports multiple types of claims, each designed to enhance trust in different aspects of blockchain interactions.

**USL** is a distributed network for everyone to submit, verify, settle, store, and use claims about anything. In particular, computation claims and their **Proof of Proof**\-generated proofs can be used in the **USL**, making **verifiable claims** a reality.

**Bringing trust to every ecosystem**

**USL** isn't another blockchain — it's a distributed verification service that integrates with existing ecosystems. Any protocol can generate **claims** and their corresponding proof for users to settle and once settled, any application can use it.

We're already taking the first steps — [**Wormhole**](https://blog.pi2.network/usl-wormhole/)
 is integrating **Pi Squared's USL**, bringing these principles to cross-chain interactions. We've integrated [**pod**](https://blog.pi2.network/pi2-pod/)
 with **USL** to leverage its performance to enhance how the USL handles transactions. And this is just the beginning. The foundation is proven, the technology is ready, and the next step is expanding this across the entire blockchain industry.

**Conclusion**
--------------

When verification is seamless and built into the foundation of Web3, trust stops being a barrier—and people, businesses, and innovation thrive.

At **Pi Squared**, we’re making trust visible by reducing reliance on black-box tools and ensuring that intentions are verifiable.

With **Proof of Proof**, you no longer need to blindly trust execution, and with **USL**, you don’t have to guess the outcome of a transaction. These technologies aren’t just theoretical; they’re real, working solutions that are already shaping the future of blockchain.

To learn more about **Proof of Proof**, [review our documentation](https://docs.pi2.network/?ref=blog.pi2.network)
 and read our [Pi Squared white papers](https://pi2.network/papers?ref=blog.pi2.network)
.

---

# Revolutionizing Blockchain Interoperability: Insights from Pi Squared and Wormhole

In a joint workshop during Devcon, **Pi Squared** and Wormhole unveiled the integration of the **Universal Settlement Layer (USL)** into the Wormhole Native Transfer Token (NTT) Framework. Together we provided a compelling integration that highlighted the transformative implications of the **USL**—a modular and universal protocol set to redefine blockchain interoperability. By leveraging **Pi Squared’s USL** and Wormhole’s advanced NTT framework, developers and blockchain enthusiasts are now equipped with tools to achieve unprecedented scalability, security, and efficiency in cross-chain communication.

**Watch our workshop with Wormhole:**

### **Tackling Cross-Chain Complexities**

[Ossie Amir](https://www.linkedin.com/in/ossieamir/?ref=blog.pi2.network)
, Global Integrations Lead at the Wormhole Foundation, opened by addressing one of blockchain’s most persistent challenges: the fragmentation and complexity of cross-chain operations. With hundreds of blockchain networks, rollups, and diverse runtime environments, establishing seamless communication and trust across these ecosystems has remained a daunting task.

The **USL** was introduced as an elegant solution to this problem. This modular framework empowers developers to tailor security models, performance metrics, and trade-offs to their specific needs. By decoupling the messaging and verification layers, the **USL** achieves a secure and efficient architecture that simplifies the development of scalable blockchain applications. This separation not only ensures robust security but also enhances the adaptability of blockchain systems to evolving technological demands.

### **The Universality Advantage**

A standout feature of the **USL** is its universal compatibility, which removes long standing barriers to blockchain adoption. Developers can use any programming language, from Solidity to Python, making blockchain development more accessible to a diverse pool of talent. Additionally, the **USL** supports a wide array of proof mechanisms—ranging from zero-knowledge proofs to traditional mathematical validations—allowing developers to choose the best-suited tools for their projects.

This universality has profound implications. By democratizing blockchain development, the **USL** not only broadens the talent base but also accelerates innovation. The ability to integrate a variety of languages and proofs fosters collaboration and creativity, enhancing the scalability and utility of blockchain technology across industries.

### **Real-World Applications and Vision**

The joint workshop showcased **USL’s** integration with Wormhole’s transceiver technology, emphasizing practical applications such as seamless cross-chain token transfers. The demo led by Pi Squared Chief Architect, [Yi Zhang](https://pi2.network/team?ref=blog.pi2.network)
, highlighted **USL’s** robustness, efficiency, and potential to drive real-world adoption of blockchain solutions.

**Pi Squared** and Wormhole’s shared vision extends beyond technical integration. Their commitment to universal compatibility and modularity positions the **USL** as a cornerstone for attracting millions of Web2 developers into the Web3 space. By lowering the barriers to entry and providing a flexible, developer-friendly framework, the **USL** aims to revolutionize application development and deployment in decentralized ecosystems.

### **Shaping the Future of Blockchain Interoperability**

**Pi Squared’s Universal Settlement Layer** represents a significant leap forward in blockchain technology. Eliminating programming language and proof mechanism constraints, the **USL** sets a new standard for secure, scalable, and efficient blockchain interoperability. Backed by rigorous formal semantics and a commitment to universality, this modular approach paves the way for a more interconnected, trustless, and innovative blockchain ecosystem.

For developers, enterprises, and blockchain enthusiasts, the **USL** offers a compelling framework to unlock the full potential of decentralized applications. As the blockchain landscape continues to evolve, innovations like the **USL** will play a pivotal role in shaping the future of interconnected digital infrastructure.

We invite [developers](https://pi2.network/developer?ref=blog.pi2.network)
, integrators, and members of the blockchain community to explore this integration further. Reach out to the Pi Squared team to [learn more](https://pi2.network/contact?ref=blog.pi2.network)
, and discover how you can leverage these advanced inter-chain operations in your own projects.

---

# How to Bring a Million Developers to Web3

Before Web3 can reach a billion users, we face a critical challenge: the ecosystem lacks the necessary developers to make it truly viable. Most developers are disengaged from Web3, hesitant to invest the time needed to learn entirely new programming languages. Having built their careers and expertise in Web2, they’re more comfortable sticking with established technologies that offer larger user bases and more secure job prospects.

Web3 technologies, on the other hand, are perceived as unstable and risky, making it hard for developers to justify committing their time. Many fear that mastering a new language in this space could lead to dead ends, offering no guarantee of long-term employment.

At **Pi Squared**, we believe that the key to overcoming this obstacle is enabling universal language interoperability within blockchain technology. By allowing developers to leverage their existing skills, we can break down barriers and unlock opportunities for them to explore Web3 development. In this post, we discuss how universal language support can bring a surge of talent and innovation to the Web3 ecosystem.

Why Developers and Users are Important
--------------------------------------

How do we onboard the next million developers to Web3, and by doing so, attract the next billion users? If chain-specific programming languages pose a major obstacle to onboarding new developers, then achieving universal language interoperability across chains can break down that barrier.

Developers are the driving force behind every technological revolution. They create the tools, dApps, and services that users interact with. Without a thriving and expanding developer ecosystem, Web3’s growth will be stifled.

Think about it this way: Blockchains capable of processing 100,000 transactions per second will only matter if there are enough developers building the dApps to utilize that capacity. Without a strong developer community creating valuable services, even the most high-performance blockchain systems will be underutilized and miss their potential.

To drive Web3 forward, we must prioritize building a robust infrastructure for developers while simultaneously advancing blockchain capabilities. By empowering developers, we lay the foundation for the next wave of user adoption and innovation.

​​How can Universal Language Interoperability bring Developers
--------------------------------------------------------------

Let’s explore how universal language interoperability offers a developer-centric solution that will drive both the growth and sustainability of blockchain ecosystems.

With universal language interoperability, developers can build smart contracts and blockchain applications using the programming languages they already excel in. Instead of being forced to learn niche Web3 languages like Solidity or Rust, they can apply their expertise in widely used languages such as Python, C++, and Java. This approach is far more than a convenience—it's about breaking down the barriers that have kept developers out of Web3. By empowering them to use the tools they know and trust, we make it exponentially easier for developers to onboard and contribute to blockchain projects.

The impact of this will be profound. Allowing developers to work with familiar languages will unleash a wave of innovation in the Web3 space, rapidly increasing the pace of development. Millions of developers will be enabled to join the blockchain ecosystem, bringing with them a flood of new projects and applications. This surge in development will, in turn, attract more users and push blockchain technology closer to realizing its full potential.

When fully implemented, universal language interoperability will spark a new era of Web3 innovation. It will not only attract developers migrating current Web2 projects but also create fertile ground for new services, particularly those driven by artificial intelligence, to thrive in the Web3 landscape. This is the key to unlocking the future of blockchain and ensuring its long-term success.

How Does It Work?
-----------------

How does universal language interoperability function in practice? It empowers developers to build smart contracts and dApps using any programming language they are proficient in. These applications are then seamlessly verified and executed across multiple blockchains, removing the need for specialized Web3 languages.

At the heart of this innovation is Pi Squared’s groundbreaking Proof of Proof protocol. Proof of Proof generates mathematical proofs of correctness for any language or virtual machine (VM), allowing developers to use their preferred languages in Web3 development. Instead of reinventing the wheel for each blockchain, they can continue coding in languages they know and trust.

Proof of Proof is transformative—it unifies all programming languages under one roof by translating computations into mathematical proofs. And mathematics, as the foundation of all computer code, becomes the true universal language. This shift isn’t just about bridging gaps; it's about fundamentally changing how developers interact with blockchain, making Web3 accessible, efficient, and scalable for everyone.

Additional Benefits of Universal Language Interoperability
----------------------------------------------------------

Major blockchain foundations like Ethereum, Starknet, and Solana invest heavily in training developers in specialized languages like Solidity and Cairo. While this has yielded some success, it comes with significant limitations. Relying on niche languages restricts the scalability of these platforms and constrains the growth of the entire Web3 ecosystem.

Universal language interoperability completely eliminates the need for blockchain foundations to retrain developers. Instead, it taps into the vast, existing educational infrastructure of global computer science programs, which already train hundreds of thousands of developers each year in widely-used programming languages. These programs offer a far more comprehensive and higher-quality learning experience than the rapid boot camps offered by Web3 companies. By reducing the focus on retraining, blockchain foundations can redirect resources toward advancing their technology and ecosystem services, rather than pouring funds into developer education.

This strategy unlocks a massive talent pool of over 25 million developers worldwide, plus an additional million new graduates each year. Without the hurdle of learning new, blockchain-specific languages, developers can immediately contribute to Web3 projects using their existing skills. This will lead to a rapid surge in development, with more dApps, tools, and on-chain content being created, vastly improving user experiences. The increased number of developers will result in more meaningful applications, enhanced engagement, and stronger user retention, all of which will drive long-term growth for blockchain technology.

Moreover, universal language interoperability will make it easier for Web2 companies to transition into Web3, enabling them to leverage their current teams and expertise to build blockchain applications. This will fuel innovation and enrich the Web3 experience, making it more attractive, accessible, and user-friendly for both developers and end users.

The Bigger Picture
------------------

Universal language interoperability isn't just about simplifying things for developers—it's about unlocking the full transformative potential of Web3. By making blockchain technologies accessible to a global community of developers and companies, we will ignite a wave of innovation that reshapes industries, elevates user experiences, and drives the widespread adoption of decentralized technologies.

Our vision is a future where anyone, regardless of their programming background, can seamlessly build in Web3. Universal language interoperability is the key to expanding blockchain’s reach, providing a clear and efficient path to onboard the next billion users—starting with the next million developers. This is more than just technological progress; it’s about unleashing creativity and collaboration on a global scale.

As we stand at the threshold of a new era in Web3, universal language interoperability will be the driving force that reshapes how blockchain applications are built and by whom. By breaking down language barriers and tapping into a vast, untapped pool of global talent, we will revolutionize the Web3 landscape, accelerating its evolution into a more dynamic, inclusive ecosystem.

The journey to a billion Web3 users may seem ambitious, but with universal language interoperability, it becomes not only attainable but inevitable. By removing the roadblocks to Web3 development, we’re not just building the next internet—we’re creating a more inclusive, accessible, and powerful digital future for everyone. This is how we redefine the internet, and this is how we change the world.

---

# How Formal Semantics Will Bring More Developers to Web3

_Creating Universal Programming Languages for Blockchains_

Formal semantics, a subfield of formal methods, refers to the meaning behind computer code or the behavior of a program. Formal semantics define how instructions should be executed by an application. While syntax relates to whether code is _written_ correctly, formal semantics ensures code _functions_ correctly. Without a clear understanding of the formal semantics of a programming language, developers run the risk of creating software that malfunctions, leading to bugs, inefficiencies_,_ and potential failures. 

_\*Note: we will refer to “_[_formal semantics_](https://en.wikipedia.org/wiki/Semantics_(computer_science)?ref=blog.pi2.network)
_” as “semantics” for simplicity._

In this post, we explore the importance of semantics in programming, particularly in modern blockchain development. This deep dive into semantics is crucial for our work at **Pi Squared,** as it forms the foundation of our approach to Verifiable Computing 2.0. You can read more about the **Pi Squared** vision [here](https://blog.pi2.network/pi-squared-the-next-generation-of-verifiable-computing/)
.

In the fast-paced world of software development, proper syntax is often emphasized to ensure code runs correctly. A syntactic mistake such as a misplaced semicolon, errant bracket, or typo in a variable can cause a compilation error or worse, for an application to pass the compilation process yet behave unexpectedly. But semantics of a programming language are another crucial aspect that many programmers do not consider. 

Semantics-Based Programming in Web3
-----------------------------------

Semantics play a pivotal role in providing a mathematical framework to define the behavior of programming languages. This formal approach is invaluable in defining the reasoning of computer applications, verifying their correctness, and ensuring they meet preset specifications. By understanding a programming language’s semantics, developers can better predict how their application will behave in different scenarios, making semantics a cornerstone of reliable software development. 

Smart contract development is a high-risk programming environment where bugs in your code can lead to high-profile hacks, potentially costing millions of dollars. This heightened risk has led to the adaptation of formal methods to help make smart contract development safer. By applying rigorous mathematical techniques to specify, design, and verify software systems, formal methods can significantly reduce the likelihood of critical errors in smart contracts.

Semantics play a critical role in simplifying blockchain development. This is because each ecosystem has its own unique syntax and semantics. To build on a blockchain framework, a developer needs to choose and commit to building within a single blockchain ecosystem despite uncertainties surrounding its future benefits and risks. Blockchains are evolving rapidly, so they present a significant challenge for developers to keep up-to-date with the chosen blockchain’s requirements. 

Choosing a blockchain ecosystem is far from trivial for developers. It involves investing limited time and resources to develop expertise into a platform that may not guarantee long-term success. Developers are essentially betting on the future, with significant implications for the sustainability and security of their applications. This is where semantics-based programming offers a potential solution.

Semantics Bring Universality to Web3 Development
------------------------------------------------

Semantics-Based Program Execution offers a groundbreaking approach to software development. Traditionally, applications rely on compilers or interpreters tailored to specific programming languages. However, in semantics-based execution, compilers or interpreters are no longer needed. The interpreter, which turns programming code into machine code, is _generated directly from the formal semantics_ of a language. This allows for a more precise and universally applicable execution model. As a result, developers can execute applications written in any language, provided its semantics are defined. Put simply, this enables developers to use the programming language of their choice, so their application can run on any blockchain. 

This universality in programming is made possible by using the [K framework](https://kframework.org/?ref=blog.pi2.network)
. The K framework enables any app written in any programming language to run on any blockchain. This is done by using the defined semantics within the K framework, of that chosen programming language. This universality provides developers with unprecedented flexibility and correctness, ensuring that their applications behave as intended across different blockchains and environments.

Semantics-Based Program Execution offers developers the benefits of correctness, testability, generality and most importantly, universality. 

*   **Correctness:** Since the interpreter is generated from formal semantics, it’s inherently more accurate and less error-prone. Developers can be more confident that their programs will behave as expected, reducing bugs and unexpected behaviors. 
*   **Testability:** Because semantics are executable, they can be tested against existing test suites and verified for correctness based on the expected behavior of programs in the language. 
*   **Generality:** Developers can work across different programming languages and blockchain ecosystems without being tied to a single language or platform.
*   **Universality:** Provided the semantics of a language are available, the semantics based approach provides a flexible and universally applicable solution making it a versatile tool for developers.

The Future for Semantics in Web3 Development
--------------------------------------------

As blockchain technology continues to evolve, the ability to quickly support new blockchains and create new language semantics will become increasingly critical to bringing millions of new developers to Web3. Developing semantics for complicated languages like C or Rust will take time, but it’s achievable and the long-term benefits will be significant.

Semantics-based programming will revolutionize blockchain development, providing developers with the tools to build more flexible, secure, and maintainable applications. As Web3 continues to grow, the importance of semantics in ensuring the integrity and functionality of code can’t be overstated. By embracing semantics, developers new to Web3 can avoid the complexities of blockchain ecosystems. Building with greater confidence and precision, and ultimately delivering better experiences for users.

If you’re interested in learning more about how Pi Squared can bring more developers to your ecosystem, [reach out any time](https://pi2.network/contact?ref=blog.pi2.network)
 to our team.

---

# Pi Squared’s Integration with EigenLayer

_Revolutionizing Multi-Language Execution and Settlement for dApps_

The Pi Squared Modular Stack
============================

Pi Squared’s Modular Stack consists of our Universal Language Machine (ULM), and our Universal Settlement Layer, (USL). ULM enables fast and efficient execution of programs written in any programming language, including [bring your own language (BYOL)](https://blog.pi2.network/byol/)
. USL enables trustless certification and settlement of program execution carried out by the ULM. 

Together, ULM and USL bring multi-language execution and settlement to Web3. Together, they revolutionize the development and deployment of dApps, making any app a dApp. And together, they bring millions of developers and trillions of TVL to crypto, making any developer, a Web3 developer.

Pi Squared ULM
==============

ULM is a universal language machine. As its name suggests, it is a machine that knows how to execute programs written in any programming language. It is universal. How is that even possible? Well, we give credit to the 50+ years of research and study in the area of [formal semantics](https://blog.pi2.network/how-formal-semantics-will-bring-more-developers-to-web3/)
. 

![](https://blog.pi2.network/content/images/2025/01/2024-09-10---BlogPost-Universality-Hero-R4.png)

A formal semantics of a programming language is a finite, complete, and rigorous mathematical definition of the behaviors of all programs written in that language. So in theory, if we have a formal semantics of a programming language, we have all the information that we need to execute programs written in that language. No compilers, interpreters, or other ad hoc (and usually buggy) language implementations required. Moreover, being a mathematical definition, a formal semantics reduces computation to mathematical proof, whose integrity can be checked with [notoriously simple proof checkers](https://x.com/RosuGrigore/status/1279252137705439235?ref=blog.pi2.network)
.

ULM turns this theory into a reality. Allowing anyone to define and upload formal language semantics and enable semantics-based program execution. One developer can define and upload a semantics of C, for example, to the ULM and then every subsequent ULM developer can execute their programs written in C. Someone else can define and upload a semantics of Python to ULM and then every other ULM developer can execute their programs written in Python. [Many](https://github.com/kframework/c-semantics?ref=blog.pi2.network)
 [mainstream](https://github.com/kframework/java-semantics?ref=blog.pi2.network)
 [programming](https://github.com/kframework/javascript-semantics?ref=blog.pi2.network)
 [languages](https://github.com/runtimeverification/python-semantics?ref=blog.pi2.network)
 already have formal semantic definitions that are readily available to be plugged into ULM.

ULM enables any developer to write smart contracts in any programming language, including BYOL. Developers can use the programming languages they’re most comfortable with. This flexibility lets developers leverage existing knowledge and codebases, making it easier to transition to or experiment with ULM. According to recent reports by [SlashData](https://www.developernation.net/resources/reports/state-of-the-developer-nation-25th-edition-q3-20231/?ref=blog.pi2.network)
 and [Electric Capital](https://www.developerreport.com/ecosystems/ethereum?ref=blog.pi2.network)
, there are 8,000+ Solidity developers and 26,000 Web3 developers. Soon, ULM can simply boost that number to 26,000,000, that is, **1000x** bigger, by embracing C, Python, and Rust developers and enabling them to develop and deploy smart contracts. In the long term, ULM opens a door for all Web2 developers to the Web3 and crypto world.

![](https://blog.pi2.network/content/images/size/w2400/2025/01/2025-01-08-Pi2-Market-Opportunity-1.png)

Data Sources:   
1.  [SlashData, State of the Developer Nation, 25th Edition, Q3 2023](https://www.developernation.net/resources/reports/state-of-the-developer-nation-25th-edition-q3-20231/?ref=blog.pi2.network)
  
2\. [Electric Capital, Developer Report, July 2024](https://www.developerreport.com/ecosystems/ethereum?ref=blog.pi2.network)

Multi-language support is highly desired in Web3. Imagine you’re a game developer and want to publish your game to the blockchain to take advantage of player-driven economics. Your game is written in Unity, Unreal, or JavaScript. To migrate your game to Web3, your entire development team would need to learn a new “blockchain native” language such as Solidity to write smart contracts for your game. With ULM, you can use your favorite and most familiar languages to write the entire game and the smart contracts in one codebase, again, using your existing development team. This is the fastest and easiest way for you to build, manage, deploy, and maintain your on-chain Web3 game. 

Our vision is to make every developer a Web3 developer. ULM brings developers that need not know anything about Web3 to Web3. People can use their favorite and most familiar programming languages and technology stacks, as well as domain-specific languages or even totally new ones that were not even invented yet. This makes Web3 adoption and democratization immensely faster. Making every app a dApp. 

Pi Squared USL
==============

USL is a [universal settlement layer](https://blog.pi2.network/why-web3-needs-usl/)
. As its name suggests, it’s a settlement layer that works across all programming languages. It is universal, and its universality is made possible by formal semantics. Using formal semantics, we generate machine-checkable proof certificates for programs and smart contracts running on ULM. Using these machine-checkable certificates, we maintain a common verifiable database of truths. A correct transaction ([AAVE](https://aave.com/?ref=blog.pi2.network)
, [EigenLayer](https://www.eigenlayer.xyz/?ref=blog.pi2.network)
, and [Uniswap](https://app.uniswap.org/?ref=blog.pi2.network)
), an honest vote ([Polymarket](https://polymarket.com/?ref=blog.pi2.network)
, [Aragon](https://aragon.org/?ref=blog.pi2.network)
, and [Tally](https://www.tally.xyz/?ref=blog.pi2.network)
), a valid bid ([OpenSea](https://opensea.io/?ref=blog.pi2.network)
, [CoinList](https://coinlist.co/?ref=blog.pi2.network)
, and [Rarible](https://rarible.com/?ref=blog.pi2.network)
): they are all part of the truth base, submitted to, verified by, and settled on USL. Users and dApps can examine all the truths on USL or query USL whether a transaction, a vote, or a bid has been settled. USL changes the ways communities and dApps work together within and across ecosystems.

![](https://blog.pi2.network/content/images/size/w2400/2025/01/2025-01-08---Galaxy-with-icons.png)

Unlike any other settlement mechanism, USL settles _claims_. Claims are a central component of USL. They are the minimal independent verifiable computation unit of a dApp, produced by ULM. A claim includes a piece of code with a pre-state and a post-state of the dApp before and after executing the code. Therefore, a claim can be validated and settled independently, without relying on the validation or settlement of other claims. Sequencing, consensus, and data availability: all of these essential and critical components of dApps happen outside USL. In other words, USL separates validation and settlement from everything else, significantly improving latency, performance, and interoperability. USL and its universal settlement services bring assets across Web2 and Web3 together.

USL is compatible with any proof mechanism or verifiable computing approaches. USL allows validating-by-reexecuting, which is the canonical computation validation approach in most of the state-of-the-art layer-1 blockchains. USL allows validating-by-proof-certificates, where proof certificates are generated by the ULM and checked on USL. Ultimately, USL allows validating-by-ZKPs and is not tied to any specific ZK engines or backends, thus enabling verifiable computing, open or secure, for the whole Web3 world through a versatile set of proofs. 

Pi Squared Meets EigenLayer
===========================

0:00

/0:10

 1× 

Pi Squared is working together with EigenLayer to make the above vision a reality and bring it to the AVS community, integrating EigenDA as the data availability enabling layer within ULM and USL. By enabling developers to use any language with ULM, EigenLayer can attract a new range of innovators interested in building on Ethereum’s security layer without any programming language constraints, potentially leading to unique applications in areas like finance, governance, and identity.

_“We are excited about the integration with Pi Squared. ULM introduces new programming primitives for application developers and AVSs. Today, AVSs can write slashing contracts on Pi Squared and settle responses back on Ethereum. This enables slashing conditions to be written in any language and allows for formal verification. We look forward to more experimentation within the Pi Squared ecosystem. This is the win-win we aim for at EigenLayer,”_ said **Sreeram Kannan, Founder and CEO of Eigen Labs**.

ULM could serve as a testbed for developers to experiment with cutting-edge decentralized solutions in their language of choice, leading to novel applications on EigenLayer and potentially advancing the entire Ethereum ecosystem.

---

# Benchmarking zkVMs on Metamath Proof Checking

In a previous post, we [introduced zkVMs](https://blog.pi2.network/intro-to-zkvms/)
 as virtual machines that rely on zero-knowledge proofs to enable verifiable computation. We established their importance for building secure and efficient on-chain applications, allowing developers to prove the correctness of program execution without exposing sensitive information.

In this post, we’ll explore the zkVM ecosystem, dissecting some of the most prominent zkVMs, their tradeoffs, and how they contribute to implementing a core component of our [proof-of-proof](https://blog.pi2.network/guide-to-proof-of-proof/)
 protocol.

Exploring zkVMs
---------------

The zkVM ecosystem has grown significantly in recent years, and this has introduced a variety of systems with unique designs and tradeoffs. As part of implementing our proof-of-proof protocol, we conducted an in-depth exploration of these zkVMs.

The goal of this research was twofold: to evaluate their performance against the tasks our protocol demands and to understand how different approaches to zero-knowledge computation compare in practice.

Through this analysis, we focused on seven prominent zkVMs, each bringing something unique to the table:

*   [**Risc Zero**](https://risczero.com/?ref=blog.pi2.network)
     - The original RISC-V based zkVM. It uses a STARK proving system, and features GPU support. Risc Zero has multiple modes for creating proofs depending on verifier requirements, which we investigated separately:
    *   **Composite**: Breaks computation into segments, producing a STARK for each segment.
    *   **Succinct**: Reduces a composite proof into a single, more efficient STARK.
*   [**Jolt**](https://jolt.a16zcrypto.com/?ref=blog.pi2.network)
     -  A zkVM created by a16z that centers its design around cryptographic lookup tables.
*   [**zkWasm**](https://zkwasmdoc.gitbook.io/delphinus-zkwasm?ref=blog.pi2.network)
     - A zkVM designed for the web assembly binary format.  zkWasm utilizes a Halo2 circuit to enable verifiable computation.
*   [**Cairo**](https://www.cairo-lang.org/?ref=blog.pi2.network)
     - Unlike the others, Cairo is a domain-specific language from StarkWare, optimized for cryptographic computation rather than general-purpose programming.
*   [**Nexus**](https://nexus.xyz/?ref=blog.pi2.network)
     -  A zkVM supporting the RISC-V architecture, but using the Hypernova proof system to differentiate itself.
*   [**SP1**](https://docs.succinct.xyz/?ref=blog.pi2.network)
     - Developed by Succinct Labs, SP1 is another RISC-V zkVM leveraging Plonky3 cryptographic tooling. Like Risc Zero, it features two proof modes which are **Core** and **Compressed**.
*   [**Lurk**](https://docs.argument.xyz/?ref=blog.pi2.network)
     - A domain-specific ZK language rooted in LISP. Lurk is designed with recursion in mind, offering a unique approach to verifiable computation.

Our Application: A Metamath Proof Checker
-----------------------------------------

To encode mathematical proofs, our proof-of-proof system uses a formal system called [Metamath](https://us.metamath.org/?ref=blog.pi2.network)
. This system is flexible enough to represent any claim, while being simple enough that a Rust implementation of the checker is only several hundred lines of code.

We implemented checkers for Metamath in all of the zkVMs we tried, and ran them on a variety of Metamath files. These included simple files, (for example, [hol\_wov.mm](https://github.com/Pi-Squared-Inc/zk-benchmark/blob/main/mm-files/hol_wov.mm?ref=blog.pi2.network)
 proves a basic application of [modus ponens](https://en.wikipedia.org/wiki/Modus_ponens?ref=blog.pi2.network)
), as well as files representing specific tasks from runs of our Proof of Proof system, like verifications of ERC20 transfers implemented in IMP and Solidity. We ran these checker codes using open source provers, following the recommendations of teams involved regarding which provers would be easiest to install and run on our system.

Comparison of zkVMs
-------------------

Our overview of all the data we collected, along with the code that produced it, can be found in [Pi Squared’s zk-benchmark repository](https://github.com/Pi-Squared-Inc/zk-benchmark?ref=blog.pi2.network)
.

Below, we present a comparative analysis of prover times for some of the most performant zkVMs we inspected and tested on various Metamath files.

### Important Notes on the Data

There are a few important caveats in discussing results. The following are some of them:

1.  **Programming models**: Most zkVMs tested here use our Rust implementation of the Metamath checker. However, the Cairo and Lurk systems operate with their own domain-specific languages (DSLs). These differences mean the comparisons are not always one-to-one. Detailed documentation of these DSL-based zkVMs can be found [here](https://docs.argument.xyz/?ref=blog.pi2.network)
     and [here](https://book.cairo-lang.org/?ref=blog.pi2.network)
    .
2.  **Prover variations**: For some zkVMs, multiple versions were tested. For instance, we compared CPU and GPU-based provers, and those that compress proofs cryptographically or produce larger proofs more quickly. Compression impacts both prover and verification time.
3.  **Cairo deprecation**: The Cairo prover tested here is based on an open-source prover from [Lambdaworks](https://github.com/lambdaclass/lambdaworks?ref=blog.pi2.network)
    . The latest prover from StarkWare, Stwo, is still a work in progress, so we opted for this prover as an alternative, but because this prover is now deprecated, the associated numbers may be outdated.
4.  **zkVM evolution**: The zkVM space evolves rapidly, with new provers frequently offering improved performance. Therefore, the benchmarks presented here may not remain valid for long. We encourage PRs to our benchmarking repository that add new versions of provers to the mix!

### Experiment Design

We conducted two main experiments:

1.  **Basic logic files**: These are simple Metamath files encoding basic logical proofs.
2.  **ERC20 transfer components**: These represent segments of an ERC20 transaction executed within Pi Squared's Proof-of-Proof system.

### Results

![](https://blog.pi2.network/content/images/size/w2400/2025/02/2025-02-03---UPDATED3-zk-benchmark-comparison-table.png)

Note that some data is missing in cases where the prover ran out of memory or otherwise could not complete the proof of the benchmark file within the 15-minute timeout window we set. To see the full CSV data for this table, you can refer to the [zk-benchmark-repository](https://github.com/Pi-Squared-Inc/zk-benchmark/blob/main/data/zk_measurements.csv?ref=blog.pi2.network)
.

(The relevant files are `hol_idi.mm, hol_wov.mm, hol_ax13.mm, hol_cbvf.mm, 45.erc20transfer_success_tm_0_6.mm, 25.erc20transfer_success_tm_0_9.mm, 3.erc20transfer_success_tm_0.mm, and 9.erc20transfer_success.mm`)

The four smallest files are demonstrations of simple logical facts within Metamath. The latter four files are segments of an execution of an EVM transaction from Pi Squared’s own proof generation framework.

### Bulk Experiments on Metamath Files

In addition, we ran bulk tests on 1225 Metamath files generated by our system. These results provide further insights into the performance of zkVMs under various conditions.

We summarize results for these tests in the following charts:

**Input Size vs Prover Time:** This chart illustrates prover time plotted against input size across all tested zkVMs, along with a linear trendline computed for each zkVM.

![](https://blog.pi2.network/content/images/2025/02/2025-02-03---UPDATED3-tokens_prover-1.svg)

**Metamath Size vs ZK Proof Time:** This chart focuses exclusively on GPU-based zkVMs, demonstrating how they handle Metamath files of varying complexity.

![](https://blog.pi2.network/content/images/2025/02/2025-02-03---UPDATED3-tokens_prover_gpu_only.svg)

### Takeaways and Lessons

Through this process, we’ve gained valuable insights into the capabilities and limitations of current zkVMs:

1.  **GPU acceleration matters:** When supported, GPU acceleration significantly improves prover performance, particularly for larger or more complex files. This makes it a critical consideration for applications requiring scalability.
2.  **Memory constraints:** Many zkVMs have strict memory limits by design. For memory-intensive applications, it’s essential to choose a system that can handle your workload without compromising efficiency or reliability.
3.  **Development environment and optimization:** Leveraging a familiar programming environment (like Rust in our case) can greatly enhance the ability to fine-tune performance. Familiarity with the ecosystem often translates into improved productivity and optimized outcomes.

Building the Future with zkVMs
------------------------------

One of the best things about the zkVM space is that the software is getting faster all the time! Thanks to the work these teams put in, users can expect their code to perform better with every update to the stack and application-specific optimization. We are looking forward to the ZK space continuing to improve as refinements to both the cryptography and the applications programmed on top of it accumulate over time.

At Pi Squared, we’re excited to be part of this journey. We envision a world where users of our [Universal Settlement Layer](https://blog.pi2.network/why-web3-needs-usl/)
 can come to the space with their own trust levels in existing zkVM systems, consider tradeoffs between performance, and ultimately decide what is best for them.

Ready to dive into zkVMs? Check out our [zk-benchmark repository](https://github.com/Pi-Squared-Inc/zk-benchmark?ref=blog.pi2.network)
 to explore the data behind this post, or head to our [docs](https://docs.pi2.network/?ref=blog.pi2.network)
 to learn more about how we’re driving interoperability and innovation in the zkVM space.

---

# ABCDE: Why we invested in Pi Squared

We believe that Verifiable Computing is a core technology for expanding the computational power and application scenarios of Blockchain in the future. Pi Squared is developing its own unique and effective approach to Verifiable Computing. Supported by world-class engineering and research teams, as well as robust partnerships, Pi Squared will deliver greater efficiency and security for Web3 with its Universal Settlement Layer. It’s for these reasons we chose to support Professor Grigore Roșu and the Pi Squared team from the outset.

**Building Scalable Blockchains**
---------------------------------

Blockchains provide trusted computation without the need for trusted counterparties, ranging from basic token transfers to Turing-complete program functions via a pure P2P network. The most amazing part of blockchain networks is that they’re constructed and run by individuals’ devices, so anyone can participate, and they’re free to leave at any time and join a different blockchain project. Trillions of dollars of assets are successfully owned, transferred, or used as currency by millions of users around the world on such infrastructure today.

Unfortunately, like every cool system, it usually has its own trade-offs. Let’s review the three core features of blockchain networks and those tradeoffs:

1.  Making consensus without trusting any party, but this requires significant computational requirements to achieve consensus.

2.  Communicating via P2P networks, but has a dependence or the limited bandwidth of users (least common denominator)

3.  Infrastructure running on consumer-grade devices, some of which have limited computation and storage capacity.

These characteristics lead to the undeniable fact that on-chain computational resources are truly scarce, which ultimately highlights the downside of blockchain: the performance problem.

The performance issues for blockchains have been one of the central topics of heated discussion over the past few years to the present. Let us bypass the historical retrospection and proceed directly to the conclusion. Currently, the most promising approach to blockchain scalability is the combination of off-chain computation with on-chain verification, or in other words, _**Verifiable Computing****.**_

**With a world-class** [**R&D team**](https://pi2.network/team?ref=blog.pi2.network)
\[1\], **Pi-Squared is building Verifiable Computing 2.0, which could position it as a giant in Web3.**

**The leading tech stack: Proof of Proof**
------------------------------------------

**In short, Pi-Squared provides a novel, unique and effective solution based on Mathematical Proofs + Zero-Knowledge Proofs.**

Let's start with the basic model of verifiable computing. Typically, there are two roles here, **Prover** and **Verifier**; and we use Alice and Bob to represent them respectively.

Assuming Alex wants to prove to Bob that "she knows the solution to 2^30 is 1,073,741,824." In this statement, 2 and 30 are the input values, **exponentiation** is the relevant operation within the statement, and 1,073,741,824 is the calculation result. So, how can Bob verify that Alice’s statement is correct? Of course, the simplest way is for Bob to directly calculate the result of 2 to the power of 30 according to the given inputs and outputs, following the rules of calculation. Then, by comparing the result he obtained through his own computation with the result provided by Alice, Bob can determine if Alice has made a correct statement. If the result of Bob's own computation matches the one declared by Alice, then Bob can be certain that Alice has informed him of the correct statement.

Let's consider a situation: 1. If Bob is an elementary school student, his computational ability is very limited, and exponentiation is just too complex for him. He does not have the capacity to calculate something as complex as 2^30. So, how can he verify that what Alice says is correct? Or suppose it takes Bob a week, calculating non-stop 24/7, to reach a conclusion, is there any way for Bob to quickly verify and trust that Alice's statement about the computation is correct?

Let's abstract the problem: Is there a solution that allows a computing device **with very limited computational power** to verify the correctness of a very complex computation result in a short period of time and at a very low computational cost?

Solving this problem has strong practical significance in the field of Crypto. As we mentioned earlier, blockchain networks have very limited computational power, especially compared to the computing devices we use daily, such as smartphones, laptops, and professional computing devices such as servers and large-scale datacenters. Therefore, it is difficult for us to directly perform complex computations on-chain, such as LLM inference and the state settlement of large-scale games. With the increasing recognition of blockchain network limitations, bringing more general and complex computations on-chain has become a very urgent demand. For this reason, over the past few years, researchers and engineers have been exploring relevant solutions to this problem. One of the most feasible technical means to solve this problem is through **Verifiable Computing.**

We continue to use the example mentioned above to explain the basic implementation principle of Verifiable Computing. To solve the problem between Alice and Bob, we can construct a simple special-purpose machine: the only function of this machine is to verify whether the solution to 2^30 is 1,073,741,824. This machine is divided into two parts, one given to Alice and one to Bob. Alice's part of the machine has three inputs and one output, as shown in the figure below. When we input 2, 30, and x, the machine will make a judgement and return a proof Pi (𝝿).

![](https://blog.pi2.network/content/images/size/w2400/2024/09/2024-09-23---Proof-Pi-Diagram.png)

For Bob's part of the machine, there is only one input: Pi (in actual scenarios, both Pi and the Statement would be sent to Bob, here we have simplified it a bit), as shown in the figure below. If Alice inputs **_x = 1,073,741,824_**, then when Bob inputs the Pi provided by Alice, Bob's part of the machine will show “pass”; otherwise, it will show “fail.”

Through this magical machine we've created, Bob can determine whether Alice’s claim about calculating 2^30 is correct without having to compute 2^30 himself.

In the example above, the magical machine we made only deals with a single type of computational verification problem. _So, is there a way to extend this magical proof machine to any computation_? In other words, for any computational statement proposed by Alice, can the proof generated by our machine allow Bob to verify the correctness of Alice's Statement at an extremely low computational cost?

**Magical Proof Machines**
--------------------------

The answer is a big yes. Over the past few years, this technology has made significant breakthroughs and has begun to enter the practical application phase. A typical application scenario is zkRollup \[2\]. In the Rollup scenario, the Alice-Bob challenge we need to address is: _how to let Layer 1 (L1) verify the correctness of hundreds or even thousands of transactions on Layer 2 (L2) under the execution conditions of a single Transaction._

Most current zkRollup projects, such as Scroll, zkSync, and StarkNet, are based on this pattern, constructing a magical machine known as a zkVM for a specific virtual machine language (VM), for example zkEVM\[3\]. This magical component can prove whether the execution of on-chain smart contracts is correct. The zkVM/zkEVM is equivalent to the machine held by Alice, responsible for providing proof for the execution of multiple transactions executed on L2. The contract deployed on L1 is equivalent to the part of the machine held by Bob, responsible for verifying the correctness of the proof provided by the L2 operator. In this way, the L1 can verify the correctness of L2 transactions at a very low computational cost without having to re-run a large number of L2 transactions, thereby alleviating the computational pressure on L1\[3\].

At the same time, due to the effectiveness of zkVM/zkEVM in proving Verifiable Computing for complex computations, more companies, such as RISC0, SUCCINCT, Delphinus, are beginning to explore proving more complex computations through this method, such as the complex of programs written in Rust.

However, there is a question here: for Bob, he is shifting trust from his own computations to the proof generated by the magical machine we made. So, is our magical machine really that reliable? The answer is unknown.

Currently, most Verifiable Computing projects are based on low-level machine language-like methods to construct such complex proof machines, such as R1CS, Plonkish, etc. You can search for "how to write ZK circuits" to find them. As the proof capability of the magical machine for computations increases, the more general the computations it can prove, the more complex the ZK circuits required to construct it become. This process is very similar to the making of precision instruments, akin to the production of high-end Swiss watches. Ultimately, the performance and security of the machine largely depend on the programming capabilities of the engineers. Therefore, the auditing of large-scale zkVMs remains a core challenge at present.

**The Pi Squared Approach**
---------------------------

Pi Squared's _**novel solution can effectively resolve this predicament**._ Under the guidance of [Professor Grigore Rosu from UIUC](https://en.wikipedia.org/wiki/Grigore_Ro%C8%99u?ref=blog.pi2.network)
 \[4\], the Pi Squared team builds upon the open-source K-Framework \[5\], created by Professor Rosu more than 20 years ago, and improved ever since by his UIUC lab and researchers at Runtime Verification and Pi Squared among many others, which provides formal mathematical proofs for programs through the semantics of programming languages. In the field of computer science, **formal verification is a method that can mathematically prove the correctness of code.**

Thanks to years of research and development, the K-Framework can first be used to construct a Mathematical Proof, and then a small Zero-Knowledge (ZK) circuit can be used to prove the Mathematical Proof. The construction of the Mathematical Proof based on the formal verification of the K-Framework is mathematically demonstrable. The final small-scale circuit for proving the Mathematical Proof is compact, significantly reducing the likelihood of errors in the proof component. In this process, a ZK Proof is generated from a Mathematical Proof. This is also the origin of the project's name, **Pi Squared (𝝿2)**.

![](https://blog.pi2.network/content/images/size/w2400/2024/09/2024-08-29---PoP-Blog---Proof-of-Proof-Diagram---Purple-Mode-1.png)

Ultimately, through the **Universal Settlement Layer (USL)** developed by Pi Squared, a broader range of ubiquitous computations, such as proofs of AI programs written in Python, are brought onto the blockchain.

For more information on the technical aspects of Pi Squared and the principles behind the K-Framework, you can refer to the team's official [documentation](https://docs.pi2.network/?ref=blog.pi2.network)
. \[5\]\[6\]

**A World-Class team**
----------------------

Prior to founding Pi Squared, Professor Rosu and his team established [_Runtime Verification_](https://runtimeverification.com/?ref=blog.pi2.network)
. Runtime Verification is an industry-leading formal verification and security company that has provided services to leading Web3 projects and companies, such as the Ethereum Foundation, Uniswap, Lido, Optimism, NASA, and many others \[7\]. The Pi Squared team, led by Professor Rosu and consisting of several former core researchers and engineers from Runtime Verification enriched with fresh talent from [UIUC](https://csrankings.org/?ref=blog.pi2.network#/index?all&world)
 and other top universities, offers fast and efficient verifiable computing services based on years of development.

![](https://blog.pi2.network/content/images/size/w2400/2024/09/2024-09-23---Runtime-Verification-Partners-Customers.png)

In addition, Eigenlayer founder **Sreeram Kannan** (UIUC alum), MegaETH co-founder **Yilong Li** (UIUC alum), UIUC Professor and renowned cryptography expert **Andrew Miller**, and University of Pennsylvania Professor and Aleo Founding Scientist **Pratyush Mishra** serve as advisors for Pi Squared.

![](https://blog.pi2.network/content/images/size/w2400/2024/09/2024-09-24---Pi-Squared-Advisors.png)

**Partnership**
---------------

Through a world-class team of research experts and numerous connections accumulated in the Runtime Verification project and UIUC, Pi Squared has established strong cooperative relationships with projects such as MegaETH and EigenLayer from Day 1. In this round of financing, it was led by Polychain, with investments from multiple institutions including ABCDE, Robot Ventures, Generative Ventures, Samsung Next. The round also included several prominent angel investors such as EF Core Researcher Justin Drake, MegaETH co-founder Yilong Li, Polychain General Partner Karthik Raju, and DAO5 General Partner George Lambeth.

**ABCDE and Pi Squared Vision**
-------------------------------

At ABCDE, we are keen to support projects that are driven by technology to improve efficiencies and reduce costs, and the Pi Squared vision is highly aligned with our investment thesis. We expect that the Pi Squared team's solutions will create real value for the industry.

### **References**

\[1\] Pi Squared Universal verified computing for all [https://pi2.network/team](https://pi2.network/team?ref=blog.pi2.network)
 

\[2\] An overview of Scroll’s architecture [https://scroll.io/blog/architecture](https://scroll.io/blog/architecture?ref=blog.pi2.network)
 

\[3\] zkEVM [https://scroll.io/blog/zkevm](https://scroll.io/blog/zkevm?ref=blog.pi2.network)

\[4\] [https://en.wikipedia.org/wiki/Grigore\_Ro%C8%99u](https://en.wikipedia.org/wiki/Grigore_Ro%C8%99u?ref=blog.pi2.network)

\[5\] K Semantic Framework [https://kframework.org/](https://kframework.org/?ref=blog.pi2.network)

\[6\] The Beginner's Guide To Proof Of Proof [https://blog.pi2.network/guide-to-proof-of-proof/](https://blog.pi2.network/guide-to-proof-of-proof/)

\[7\] Runtime Verification, [https://runtimeverification.com/](https://runtimeverification.com/?ref=blog.pi2.network)

---

# BYOL (Bring Your Own Language) to Web3

In the evolution of Web3, we’ve seen a steady increase in developer openness and a better developer experience. Initially, Ethereum developers were limited to coding in Solidity. Today, the landscape has expanded to include languages like Rust, WASM, and Move, with the variety of languages and virtual machines (VMs) continuing to grow.

Pi Squared is advancing this evolution by driving the Web3 ecosystem toward a truly ‘VM agnostic’ future. Pi Squared’s goal is to empower developers to write secure, verifiable programs in any language, VM, or zkVM. Pi Squared envisions a future where millions of verifiable programs run asynchronously, all seamlessly interoperating through a [‘Universal Settlement Layer.’](https://blog.pi2.network/why-web3-needs-usl/)

What sets Pi Squared apart is its use of an innovative mathematical proof design known as [‘Proof of Proof.’](https://blog.pi2.network/guide-to-proof-of-proof/)
 Here’s a brief overview of how it works:

1.  A mathematical proof of execution is generated.
2.  This proof is then input into a cryptographic system, producing a zero-knowledge (ZK) proof that certifies the correctness of the mathematical proof.
3.  Finally, any smart contract can verify this ZK-proof certificate through a simple circuit.

![](https://blog.pi2.network/content/images/size/w2400/2024/09/2024-08-29---PoP-Blog---Proof-of-Proof-Diagram---Purple-Mode.png)

In this article, we delve into the K Framework, a critical tool for generating these mathematical proofs. We’ll explore the advantages that mathematical proofs offer developers, and discuss how this technology is poised to drive the future of Web3.

**K Framework**
---------------

The [K framework](https://kframework.org/?ref=blog.pi2.network)
 is a formal framework for defining programming languages and analyzing programs written in those languages. It was created by Pi Squared CEO Grigore Rosu in 2003 and developed and refined over years of work in both academia and industry. The value of K has been proven by practical deployment in the industry at Grigore's first company, Runtime Verification, which has used K to verify the correctness of smart contracts and other software systems. The core logical framework of K is \*[matching logic](http://www.matching-logic.org/?ref=blog.pi2.network)
\*, a minimalistic but expressive and versatile logical framework that captures other logical frameworks used in language semantics and program analysis as _theories_ (i.e., sets of matching logic axioms, or patterns). Any mathematical statement, in particular the result of a program execution, can be expressed in matching logic as a _theorem_, and the K framework provides an automatic and efficient way to formulate such theorem statements about the programs written in a given programming language and extract a mathematical proof of it constructively, from the program execution itself. Matching logic can capture any mathematical statements, but we here limit ourselves to statements corresponding to program execution — but in arbitrary programming or VM languages.

Pi Squared uses matching logic to prove statements about execution traces and other aspects of programs. This approach has a few benefits. Dealing with the mathematical representations of these programs allows us to bring any programming language into the same proof system. Mathematical proofs have capabilities that naive (cryptographic) proofs of execution do not. For example, mathematical proofs can encode arguments about optimisations to a base program that allows its execution to be proved faster. Mathematical proofs have the potential to prove things beyond execution. Through techniques like formal verification, we have the potential to put proofs of security properties for smart contracts onto the chain. The key innovation above and beyond all of these is that Pi Squared uses ZK proofs to make these proofs as efficient as possible, simultaneously achieving expressivity and efficiency.

**BYOL (Bring Your Own Language)**
----------------------------------

If you’re a developer looking to use a specific language, like Rust, integrating with Pi Squared is straightforward. To get started, you’ll need a description of Rust’s semantics—or those of a lower-level language that Rust compiles to—within the K Framework. Once these semantics are specified, you can create a proof-of-proof that verifies the execution of your Rust program. This is the same process for turning any VM into a zkVM!

At launch, Pi Squared plans to support several zkVMs as backends for Pi Squared, that is, as ZK proof generators for the correctness of matching logic proofs. If you’re developing on one of these supported zkVMs, integrating with Pi Squared could be as simple as replacing your program’s cryptographic commitment with our proof-of-proof system’s commitment.

Using your program with Pi Squared offers numerous benefits, primarily centered around two key advantages:

1.  **Succinct Verification:** With Pi Squared, you no longer need to rely on a centralized server or operator to ensure your program has run correctly. The ‘Proof of Proof’ system allows you to continue using your preferred programming language while also verifying the program’s execution. Because this verification is based on a zero-knowledge (ZK) proof, it is both succinct and efficient, enabling almost instant verification. This capability also enhances interoperability between different programs via the Universal Settlement Layer, which we’ll discuss further later.
2.  **Enhanced Security:** In addition to ensuring correct execution, the K Framework seamlessly provides formal verification capabilities which are also language-parametric and can be instantiated with any programming language or VM. Although not enforced to prove correct execution, formal verification helps users prove much more complex properties of their programs, such as conformance with requirements specifications, functional correctness, and the security of the programs they interact with.  All these can then be incorporated in the final ZK proof, which thus guarantees not only the correct execution of a program according to its language semantics but also the correctness of the program itself that produced that execution concerning its formally verified properties. Moreover, it establishes a new standard for multi-language support and interoperability, based on language semantics rather than ad-hoc aggregations of multiple VMs. By reducing the risk of hacks and cross-domain vulnerabilities, Pi Squared minimises potential security breaches and cross-platform damage.

**A Million Verifiable Programs**
---------------------------------

Pi Squared envisions a future where Pi Squared programs challenge the centralized nature of Web2, empowering users with greater sovereignty and control. Imagine a world with millions of programs running simultaneously, all seamlessly producing Pi2 proofs and interoperating. To support this vision, a scalable and minimal base layer is essential—one that serves as the ultimate source of truth. This is where the [‘Universal Settlement Layer’](https://blog.pi2.network/why-web3-needs-usl/)
 comes in. As one of the first projects built on Pi Squared’s technology, it provides a unified, minimal base layer optimized for Proof of Proof verification across multiple programs.

* * *

**If you're a developer, ZK project or just curious to learn more about Pi Squared, we would love to chat! Feel free to reach out at** [**contact@pi2.network**](mailto:contact@pi2.network)
**.**

---

# Universality for Web3: Settling Transactions in Any Language or VM without Compilers

In this post, we explore how our USL (Universal Settlement Layer) makes cross-chain interactions universal and why [Bring Your Own Language](https://blog.pi2.network/byol/)
 (BYOL) is the key to blockchain interoperability.

Interoperability remains challenging in Web3 infrastructure due to reliance on blockchain-specific compilers, transpilers, and interpreters. Hundreds of blockchains, each using different smart contract languages and virtual machines (VMs), create significant fragmentation. This fragmentation makes cross-platform asset transfers and contract executions difficult for developers to enable within their dApps. With Pi Squared, we’re building **USL** to bring universal interoperability to blockchains and eliminate the need for traditional and often error-prone language implementations. With **USL**, we’ll enable transaction settlement _regardless_ of the language or VM used by a developer.

How We Achieve Universality
---------------------------

Traditionally, compilers are needed to translate code between languages or VMs to execute a transaction. **USL** removes the dependence on specialized compilers or interpreters by settling transactions using formal semantics. To understand how **USL** achieves compiler-free transaction settlement, check out our [Formal Semantics](https://blog.pi2.network/how-formal-semantics-will-bring-more-developers-to-web3/)
 blog post. 

Our vision for **USL** extends beyond just replacing compilers with formal semantics. It aims to capture a truly universal system _without_ any language-specific tools. Instead, the formal semantics of programming languages will drive the process. This universality is further generalized through _trust specifications_, which determine how a transaction should be correctly executed. These specifications allow flexible execution methods, including traditional VMs, specialized compilers, or [K](https://kframework.org/?ref=blog.pi2.network)
\-driven formal semantics, enabling **USL** to be universal.

Current methods of cross-chain interoperability, such as atomic swaps and cross-chain bridges, often rely on trusted intermediaries with huge trust bases and complex smart contracts tied to a specific language or VM. **USL** approaches this differently, removing trust bases and focusing on proving _claims._

What is a Claim?
----------------

_Claims_ represent transactions and their _effects_, forming the core mechanism for **USL's** universality. A _claim_ consists of just four major components: an initial state, a transaction, a final state, and additional _trust specifications_. Here’s an example of a _claim_:

*   Initial State: Account A has **10** tokens, and Account B has **0** tokens.
*   Transaction: Account A transfers **1** token to Account B.
*   Final State: Account A has **9** tokens, and Account B has **1** token.
*   Trust Specification: The initial State is verified to be correct by a smart contract

In this example, the transaction is a transfer of tokens from one blockchain to another. The _effect_ of the transaction is the state change that occurs from the transfer. This approach simplifies cross-chain interactions by focusing on the essential state changes rather than the specific details of a blockchain’s implementations.

_Claims_ are structured to allow universal interpretation and include integrated trust specifications. They serve as a tool for simplifying complex transactions, enabling validation and settlement across blockchains. 

Trust specifications are an integral part of a _claim_ and are essential to universality. They abstract transaction complexity, allowing validation and settlement across different environments. Trust specifications define rules and conditions for claim validation, outlining how a transaction will be interpreted, verified, and settled. 

After a _claim_ is submitted, the claim validation process begins. **USL** uses the trust specification as instruction on how to verify the authenticity and correctness of the _claim_ and how to settle it. This process can be completed by **USL** very quickly, for a very low cost, and with enough resources done massively in parallel. 

Because all the information needed to validate the claim is included within the claim, you don’t need to trust **USL**, as any external entity can confirm the correctness of the claim themselves. This function takes the input state and incoming transaction as inputs. The validation is reproducible and can be independently verified by any external entity that correctly implements **USL’s** state transition function.

It is worth noting that _claims_ and trust specifications are the key components of **USL** and require a deep technical understanding to appreciate how **USL** is universal. This explanation has been brief. If you want to learn more about the outlined process check out our [**USL** documentation](https://docs.pi2.network/verifiable-settlement-layer/what-is-vsl?ref=blog.pi2.network)
.

USL Use Case: Cross-Chain Activities
------------------------------------

To better illustrate the benefits of **USL**, consider cross-chain activities where users are transferring assets across blockchains. Users may see an opportunity to take advantage of better staking or borrowing rates on another chain. In this case, all staking and borrowing transactions are settled on **USL**, even as the two chains use different VMs and platforms for execution. Additionally, **USL** validates all the accumulated trust dependencies in this transaction sequence, ensuring the user is fully aware of all the trust assumptions.

**USL** acts as a trustless clearing house, ensuring secure validation and settlement of both transaction sides. Through its trust base validation, it eliminates the need for intermediaries or compilers. The goal for **USL** is to avoid trusting any counterparty or infrastructure and replace that trust with provable code.

Bring Your Own Language (BYOL)
------------------------------

**USL** will bring universality to Web3 in an innovative way that empowers developers to focus on logic and functionality instead of cross-chain compatibility. Developers can build in Web3 using the programming languages they already know and love. Blockchains that were previously isolated due to limited developer support can now interact seamlessly with others, and expand their pool of liquidity and users. 

With this new programming paradigm, developers won’t need to worry about language-specific constraints or learning new languages to work on different blockchains. This brings greater flexibility to Web3, allowing apps to be free from specific programming languages or VMs. The trustless nature of **USL** will also boost developer and user confidence and promote an environment where **USL** becomes foundational technology for future blockchain-based applications.  

Want to learn more about how universality will impact your dApps and services? Join our workshops at [Hack Seasons](https://lu.ma/hack_bangkok?ref=blog.pi2.network)
 and [Multichain Day](https://lu.ma/multichaindaydevcon?ref=blog.pi2.network)
 during the week of Devcon 7 in Bangkok, Thailand. 

Won’t make it to Devcon? Reach out to our team to [learn more](https://pi2.network/contact?ref=blog.pi2.network)
!

---

# The Beginner's Guide To Proof Of Proof

_Proof of Proof is a critical pillar for Pi Squared—so much so that our company’s name “Pi Squared” actually stands for “Proof of Proof.”_

In this post, we’ll dive deeper into **Proof of Proof** to provide background for new entrants into the expanding **Pi Squared** universe. We’ll cover why we see a need for **Proof of Proof**, how it works, and the main benefits it will bring to Web3 developers and end users.

Why Proof of Proof?
-------------------

**Proof of Proof** introduces a universal computing environment that is designed to smooth interoperability for all programming languages and/or virtual machines (VMs). By minimizing the trust required for correctness certificates, **Proof of Proof** removes dependencies and trust in cumbersome and error-prone traditional language tools like compilers and interpreters. This simplifies development and reduces the impact of program updates, with the goal of creating a plug-and-play experience for developers. **Pi Squared’s** ultimate goal is to bring a larger population of developers into Web3, who will build smoother user experiences for all blockchain applications.

![](https://blog.pi2.network/content/images/2024/08/2020-08-05-Vitalik-tweet-on-L2-smoothness-2.png)

Source: [x.com/VitalikButerin](https://x.com/VitalikButerin/status/1820404774493110309?ref=blog.pi2.network)

What Is Proof Of Proof?
-----------------------

In the Web3 ecosystem, verifying the correct execution of programs is crucial to ensuring the integrity and reliability of transactions and smart contracts. Existing approaches to verifiable computing are based on compilation or translation to a designated, well-chosen language or VM, so they only work with specific VMs or programming languages. As programming languages and VMs are always evolving (continuous updates and patches), including the designated, well-chosen languages and VMs, all existing approaches to verifiable computing face a high risk of introducing compilation/translation or implementation bugs.

**Proof of Proof** is designed to avoid these risks. **Proof of Proof** starts with a [formal semantics](https://en.wikipedia.org/wiki/Semantics_(computer_science)?ref=blog.pi2.network)
 of any programming language (we regard VMs as particular languages). A formal semantics of a programming language is a complete, rigorous, and executable mathematical definition that specifies the behaviors of any programs written in the said language. 

Using formal programming language semantics, **Proof of Proof** converts computation into [formal mathematical proofs](https://en.wikipedia.org/wiki/Formal_proof?ref=blog.pi2.network)
. Any program execution trace yields a mathematical claim. Any correct program execution trace admits a mathematical proof of the said claim. These mathematical proofs are directly based on the formal programming language semantics and are machine-checkable by any blockchain node to verify the correctness of that program. 

The benefit of creating this mathematical proof is that it can then be automatically checked by a tiny program, known as the mathematical proof checker. From that checker, we generate a [zero-knowledge proof](https://en.wikipedia.org/wiki/Zero-knowledge_proof?ref=blog.pi2.network)
 (ZKP) that verifies the existence of the mathematical proof. The process of obtaining and verifying a ZKP of a mathematical proof ensures the correctness of a program’s execution. 

The creation of a (ZK) proof of a (mathematical) proof is the inspiration for our name, **Pi Squared** (𝝿2).

![](https://blog.pi2.network/content/images/2024/08/2024-08-12---Pi2-Blog-PoP-Proof-of-Proof-Diagram-Animated.gif)

How Does Proof Of Proof Work?
-----------------------------

In our **Proof of Proof** system, computational claims are generated by the [K Framework](https://kframework.org/?ref=blog.pi2.network)
. While the mathematical proofs verify the correctness of the execution trace of any program, they create precise but huge proofs. To make the proof in question smaller and more efficient for use with Blockchains, **Proof of Proof** also produces a smaller proof in the form of a ZKP. The ZKP is then sent to a blockchain as part of a transaction, where the proof is included to verify the correctness of that transaction. Any L1, L2, dApp, and our own **USL** that is running our cryptographic proof checker as a smart contract, can then post and verify their claims on any blockchain. 

In **Proof of Proof**, programs are executed directly using the formal semantics of the underlying programming languages. Both the mathematical proofs and the final ZKPs are based on the complete, rigorous, and executable formal semantics of the programming languages, correct-by-construction. 

The core technology behind **Proof of Proof** is based on the [K framework](http://kframework.org/?ref=blog.pi2.network)
 and [matching logic](http://matching-logic.org/?ref=blog.pi2.network)
, that represents over 20 years of research and industrial application in the area of programming languages and formal methods that’s currently overlooked by the emerging verifiable computing community. **Pi Squared** is bringing it to life.

Proof of Proof Generates Global Benefits
----------------------------------------

**Proof of Proof** will give rise to new cross-chain applications and use cases while improving liquidity access across appchains, enabling builders to—instead of focusing on the hunt for fragmented liquidity and users—prioritize the technology stack that generates the best products and services.

This includes our own [**Universal Settlement Layer (USL)**](https://docs.pi2.network/universal-settlement-layer/what-is-usl?ref=blog.pi2.network)
, which will enable all blockchains (L1s and L2s) to be universal, correct, interoperable, and efficient. Ultimately, the **Pi Squared** mission is to leverage **Proof of Proof** to settle all science and knowledge on **USL**.

An Innovation To Elevate Web3
-----------------------------

By creating a universal computing environment that seamlessly integrates with various languages and virtual machines, **Proof of Proof** aims to elevate the entire Web3 ecosystem, making it more secure, efficient, and interconnected.

**Proof of Proof** provides benefits to developers and end users in three ways:  

**Universality**

**Proof of Proof** enables developers to bring their favorite languages to Web3. Instead of developing for each blockchain, they can build in the programming languages they know and love. **Proof of Proof** unifies programming languages - as all computations become mathematics. Mathematics is the universal language of computer code.

**Interoperability**

Currently cross chain dApps use different languages to communicate and interact with each other. This means everyone is doing something on their own, creating fragmentation and ultimately security vulnerabilities. **Proof of Proof** provides a more uniform way for cross chain apps to communicate with a single standard and protocol.

**Trust Base Minimization**

Decentralization will not succeed without verified computing. **Proof of Proof** identifies and replaces components of transactions users have to trust with infrastructure that is continuously checked and verified. **Proof of Proof** not only provides verification, but our infrastructure provides the smallest number of trust assumptions. Thereby giving Web3 users a more secure experience in which to transact. 

We’re excited to see how developers and users in Web3 will benefit from greater access to liquidity and a stronger framework for building cross-chain applications. At the same time we believe researchers and enterprises will also find **Proof of Proof** valuable for advancing secure computing and AI, in addition to enhancing blockchain operations.

To learn more about **Proof of Proof**, [review our documentation](https://docs.pi2.network/?ref=blog.pi2.network)
, come see the **Pi Squared** team at a [conference in the future](https://pi2.network/events?ref=blog.pi2.network)
 and browse our [Pi Squared paper](https://www.ideals.illinois.edu/items/129949?ref=blog.pi2.network)
.

[Reach out to Pi Squared](mailto:contact@pi2.network)

---

# Pi Squared: The Next Generation of Verifiable Computing

_How Pi Squared’s Universal Settlement Layer will unify the fractured Web3 space._

**Grigore Roșu**  
Founder & CEO at **Pi Squared**  
Professor, University of Illinois Urbana Champaign

[Verifiable computing](https://en.wikipedia.org/wiki/Verifiable_computing?ref=blog.pi2.network)
 is emerging as the future of computing. It is the only scientific method known that promises correct results for computations done in completely untrusted remote computing environments, which is particularly important for decentralized Web3 infrastructure. Unfortunately, state-of-the-art verifiable computing solutions suffer from a series of technological limitations that reduce their applicability or our trust in them:

*   They are specific to a particular computing model, e.g. a programming language (PL), a virtual machine (VM), an instruction set architecture (ISA), or even a program or algorithm;
*   They require translations from one language to another, e.g. compilers, known to have errors unless they are formally verified, which is very expensive and thus usually not done in practice; 
*   They are not provably correct, so their results can be and sometimes are indeed wrong — unless they are formally verified, which is an even harder problem than formally verifying compilers; and finally, 
*   They are excruciatingly slow.

**Pi Squared** proposes a major overhaul of the verifiable computing field, which we refer to as _Verifiable Computing 2.0_. Instead of relying on adhoc solutions and languages, **Pi Squared** builds upon one of the oldest and most well-established fields in computer science, [formal semantics](https://en.wikipedia.org/wiki/Semantics_(computer_science)?ref=blog.pi2.network)
, which is the only scientific method known that allows us to rigorously reason about programs and computations. Specifically, formal semantics of a particular computing model, e.g. a PL, a VM, an ISA or even a particular program or algorithm, is a mathematical theory in a mathematical logic, which allows us to mechanically reduce any computation in that model to a rigorous mathematical proof. This allows us to shift focus from proving adhoc computations in adhoc languages to uniformly proving the integrity of mathematical proofs cryptographically, which is a simpler yet more general problem than proving computing.

The Core Innovation: Proof of Proof
-----------------------------------

There are many semantic frameworks developed by the computer science and mathematics community over the last decades. All of them allow us to define formal semantics and reduce computation to mathematical proofs. We prefer to use the [K Framework](https://kframework.org/?ref=blog.pi2.network)
 in **Pi Squared**, which was invented in 2003 by the [Formal Systems Laboratory](https://fsl.cs.illinois.edu/?ref=blog.pi2.network)
 at the University of Illinois at Urbana-Champaign (UIUC). It has been advanced and improved ever since by [Runtime Verification](https://runtimeverification.com/?ref=blog.pi2.network)
 as well as by an international community of students, researchers and enthusiasts.

The picture below illustrates how K works at a high level:

![](https://blog.pi2.network/content/images/2024/08/2024-08-06---Pi2-Vision-Blog-PoP-Proof-1.jpg)

First, K takes as input a formal semantics (yellow box in the picture) as a mathematical theory, which usually defines a particular computational model, such as a programming language like Python or a virtual machine like an EVM (a good example is the K EVM semantics at [https://jellopaper.org/](https://jellopaper.org/?ref=blog.pi2.network)
), as well as a claim made about that semantics, such as a particular program on a particular input generates a particular output. K then constructs a rigorous mathematical proof of the claim, attesting to the mathematical correctness of the claim. Internally, K generates specialized interpreters and proof automation triggered by them, but ultimately what matters is the generated mathematical proof, which can be checked independently of K and its internal tools. This is done using mathematical proof checkers, which check the integrity of the mathematical proof independently of how the proof was produced. Anybody and anything can generate the mathematical proof, even ChatGPT, provided that the proof checks as correct. However, anecdotal evidence in the formal semantics community tells us that it is a non-trivial engineering challenge to actually produce such rigorous and complete mathematical proofs. Indeed, it took K more than 20 years of community development to get there.

In theory, we could use such mathematical proofs as ultimate correctness certificates of computational claims. In practice, such mathematical proofs tend to be huge, because they go all the way down to the axioms defining the language and the proof rules of mathematical reasoning, so it is rather impractical to send them across a network in order to be checked. The second major component of **Pi Squared** is a zero-knowledge (ZK) cryptographic circuit that implements a checker for the integrity of mathematical proofs:

![](https://blog.pi2.network/content/images/size/w2400/2024/08/2024-08-06---Pi2-Vision-Blog-PoP-Proof-2-2.jpg)

The ZK-ed mathematical checker yields a succinct cryptographic argument that a mathematical proof of the claim was presented to it as input and checked, which therefore acts as a small certificate, or ZK proof, that attests with a very high probability that the claim is indeed correct. The creation of a (ZK) proof of a (mathematical) proof is the inspiration for our name, **Pi Squared** (𝝿**2**).

The community recognizes that there is no silver-bullet PL, VM, or ISA, and there never will be. Any robust PL or VM worth its salt is continuously updated, with new versions released every few months. Keeping up with these changes is a significant challenge on its own. End-to-end, **Pi Squared** achieves the same overall result as the existing verifiable computing approaches, but instead uses a general and universal pipeline that works with all PLs and VMs alike, without a need for compilers and/or translators. Its trust base is minimal, consisting of only the formal semantics of the language, which is unavoidable in any approach that claims correctness, and a small cryptographic circuit for checking the integrity of mathematical logic proofs. There is nothing specific to any particular programming language or virtual machine that requires to be formally verified, that is, **Pi Squared** yields universal and [correct by construction](https://wiki.c2.com/?CorrectByConstruction=&ref=blog.pi2.network)
 verifiable computing.

Uniting Web3: The Universal Settlement Layer
--------------------------------------------

Web3 is plagued by fragmentation of both liquidity and attention. There are now countless unique blockchains, often with unique programming languages or virtual machines, that users and developers must choose from. Through its language universality and correctness by construction, **Pi Squared** offers a unique opportunity to unify these siloed ecosystems for both users and developers, in a trust-minimized manner. We are accomplishing this unification by creating a **Universal Settlement Layer** (**USL**) that can be used to settle transactions and contract interactions between disparate blockchains using different programming and/or virtual machine languages. The languages themselves are settled on the **USL**, through their formal semantics: 

![](https://blog.pi2.network/content/images/size/w2400/2024/08/2024-08-06---Pi2-Vision-Blog-PoP-Proof-3-1.png)

While our primary goal at **Pi Squared** is to revolutionize verifiable computing, the **USL’s** short-term goal is to empower developers to build interoperable smart contracts across any blockchain VMs or languages. Longer-term, the **USL’s** goal is to embrace **Pi Squared’s** generality to prove any mathematical truth, not only computations, and thus provide us and future generations with the ideal infrastructure to settle the entirety of science and knowledge. Indeed, there is no fundamental difference between EVM and Euclidean Geometry in **Pi Squared**, they are both mathematical theories defined axiomatically, and no difference between “Alice transfers one ERC20 token to Bob” and “Pythagoras theorem”, they are both mathematically provable claims.

By using the **USL**, developers will be able to build applications that span any blockchain. Layer-1s and Layer-2s will become more universal and efficient, and users will be able to avoid traditional bridging risks. Because the **USL** can settle any computational claims, it also creates a way for remote computing provided by centralized companies like Amazon or Google to become trustless and verifiable without the excessive costs associated with existing settlement layers. At **Pi Squared**, we envision the **USL** first being used to assist crypto applications that are either inherently multi-chain in nature or would benefit from being multi-chain, and crypto ecosystems (Layer-1s and Layer-2s) that are suffering from fragmentation. However, the concept of **Proof of Proof** and the **USL** both offer lots of potential for developers to use them in new and unique ways. It’s impossible to predict all the ways in which dApp builders can use the technology in imaginative ways to improve and expand the reach of their applications.

To learn more about **Pi Squared**, the idea of “**Proof of Proof**,” and the **USL**, check out [this presentation](https://www.youtube.com/watch?v=DiNoyGhWhx8&ref=blog.pi2.network)
, along with the [whitepaper](https://hdl.handle.net/2142/122761?ref=blog.pi2.network)
 as well as **Pi Squared’s** [Documentation](https://docs.pi2.network/?ref=blog.pi2.network)
.

[Reach out to Pi Squared](mailto:contact@pi2.network)

---

# What are zkVMs?

_Why zkVMs are important for Web3 and how they work_

Pi Squared is fundamentally based on Zero Knowledge (ZK) technology - it’s core to our [Proof-of-proof protocol](https://blog.pi2.network/guide-to-proof-of-proof/)
 that can validate any mathematical proof and ultimately any application in Web3. In this post, we’ll discuss why this technology is so important for developers, and explain the concept of a “zkVM.”

Why ZK is important to Web2 and Web3 developers
-----------------------------------------------

Central to what makes computing technology so powerful is its _reliability_. When you browse a website, check your email, or query a search engine, your computer and the computers on the internet to which you connect will carry out millions of operations to ensure that the right information gets to your screen. Each of these operations has to be done correctly to give you a good experience as a user. When operating across a network, it can be hard to know and trust that the data provided is what it seems: Is the person you’re chatting with who they claim to be? Is the image or video you’re looking at a real person, or is it a deepfake created by AI?

This is why [verifiable computing](https://en.wikipedia.org/wiki/Verifiable_computing?ref=blog.pi2.network)
 is becoming increasingly important in Web3. This is a new paradigm in computing where the data you receive is authenticated with respect to the computations that constructed it. The data you receive is _proven_ to be correct. 

The archetypal application for verifiable computing is in Web3 technology. Blockchains protect financial value, making them prime targets for attack, and this necessitates high standards for reliability. But verifiable computing is important to Web2 as well: As attackers become more sophisticated, tighter security is needed in applications such as identity management, image authentication, and machine learning.

Luckily, years of research in computer security have honed techniques in verifiable computing. The pinnacle of this research has resulted in the integration of many desirable security properties into a single technique: The “_zk-SNARK_.” zk-SNARKs combine the best properties of security, privacy, and efficiency, making them ideal for use in essentially any verifiable computing application.

What is a **zk-SNARK**?
-----------------------

You can think of a zk-SNARK as a certification stamp you can put on the output of your computation. This stamp guarantees to anyone who sees it that the data was produced in the way the stamp claims.

There are a few things that the zk-SNARK stamp should and shouldn’t be able to do:

1.  It shouldn’t be possible to put a stamp on a piece of data that says it was created in a certain way, when it wasn’t. Otherwise, the stamp would be meaningless.
2.  We would like to always be able to create the stamp successfully for any data that a program outputs, so that whatever program we are authenticating, others will be able to verify our stamp if we make it correctly.
3.  The stamp shouldn’t reveal anything about its creator. Constructing a piece of data might require personal information or data that needs to be cryptographically protected. The stamping process should ensure that no one can learn this information from the stamp alone.
4.  The stamp should not take up too much space. We might ideally like to store multitudes of stamps for many different pieces of data. If the stamp takes up more space than the data it’s attached to, that will be a concern for the efficiency of the system.
5.  The stamp should be quick to check. This is particularly important in the web3 space, when we might want to check a stamp on a blockchain. The harder it is to check the stamp, the more gas this process will consume, which becomes expensive very quickly.

What is a **zkVM**?
-------------------

These properties of a zk-SNARK give us the important factors for verifiable computation. But just as important is the programming language in which the computation is specified. Without a programming language to express what is being verified, the system is meaningless. And moreover, it’s an important quality-of-life feature that the programming language be widely-accepted, otherwise even if the programmer knows what they want to do, they won’t have the experience to be able to do it. Generic zk-SNARKs use languages like Circom which are very domain-specific, making them hard to use for a wide number of developers.

This is where “ZK Virtual Machines” or _zkVM_s come in. A zkVM is what you get when you apply a zk-SNARK to all the steps of computation that a typical program might run through. This involves keeping track of data and what actions the program is doing, and updating those data and actions as the program runs.

This lets us create a verifiable computing framework for any programming language, as long as we can build a “virtual machine” to run it. We create this virtual machine, which describes all the things the program does when it runs, and we then use a zk-SNARK on top of this virtual machine to make the computation verifiable as correct or not. This lets the programmer get the protection of zk-SNARK in the language for which a zkVM has been made.

How do zkVMs work?
------------------

Let’s describe zkVMs in a little more detail: A typical program operates on data which is held in _registers_. Each register is a slot for a few bytes of data which corresponds to some value that the program needs to think about to carry out its purpose. During each step of the program, a single operation is carried out on the data in those registers.

In a zkVM, we operate a zk-SNARK to check that each of these updates is correct. As an example, consider the following short program that computes the [Collatz function](https://en.wikipedia.org/wiki/Collatz_conjecture?ref=blog.pi2.network)
.

`0 WHILE x is EVEN: x /= 2   1 IF x == 1: y = 1   2 x *= 3    3 x += 1   4 GOTO 0`

We can write out, at each time step of the program:

*   The number of the currently-executing instruction.
*   The value of x.
*   The value of y. 

This information, taken together, is called an execution trace.

![](https://blog.pi2.network/content/images/size/w2400/2024/08/zkVM-Blog-Execution-Trace.png)

In order to make a zkVM proof for this execution trace, we make a ZK proof for each step of this trace.

![](https://blog.pi2.network/content/images/size/w2400/2024/08/zkVM---SNARK-Proof.png)

This lets us use the zk-SNARK technique to create verified computation for a program.

Conclusion
----------

zk-SNARKs and zkVMs are core to enabling a wider range of developers to build on-chain applications, however they are hampered by being tied to specific languages. The number of Web3 users will not grow without first making it easier for more developers to build useful and compelling Web3 applications. For this reason, it is our mission at Pi Squared to expand the capabilities of zk-SNARKs and zkVMs for all programming languages through our Proof of Proof protocol. In a subsequent blog post, we’ll discuss some of the considerations that make this proving process as performant as possible.

If you want to learn more about Pi Squared ZK technology, check our [introductory blog on Proof of Proof](https://blog.pi2.network/guide-to-proof-of-proof/)
, or if you want to go deeper, read our [documentation](https://docs.pi2.network/proof-of-proof/what-is-pop?ref=blog.pi2.network)
. Think Proof of Proof will help your dApp or other project? Reach out to [our team](https://pi2.network/contact?ref=blog.pi2.network)
. 

[Reach out to Pi Squared](mailto:contact@pi2.network)

---