# Prove the world’s software. By [koca](https://paragraph.com/@kocality) · 2025-07-02 --- Undoubtedly, one of the most striking breakout projects of 2025 is [Succinct](https://www.succinct.xyz/). With its unconventional testnet process, the general-purpose proving engine SP1, and the motto "**Prove the world’s software**," Succinct offers more than just ZK infrastructure. It introduces a new standard for the future of verification. I have been following its development closely since 2023, and the progress it has made is remarkable. From real-time [Ethereum](https://ethereum.org) proofs to a decentralized prover network and a system architecture capable of directly verifying software execution, Succinct is reshaping the landscape of ZK. **After a short break from writing, this piece takes a deep look at Succinct’s technical architecture, real-world use cases, and why its emergence is so timely:** ### Before diving into our in-depth, let’s define a few key terms that Succinct builds upon and that we’ll frequently reference throughout this article. These concepts are essential to understanding how software can prove its own execution: **Proof:** Stating the outcome of a process is not sufficient to prove that it was executed correctly. What truly matters is demonstrating how that outcome was reached and under which rules. A mathematically defined “proof” captures this process end to end in a transparent and verifiable manner. For example, saying “the pizza is ready” doesn't mean much on its own; you also need to prove that the ingredients were added correctly and it was baked at the right temperature and duration. a proof validates the integrity of the entire process, not just the final result. **ZK Proof (Zero Knowledge Proof):** Zero-knowledge proofs are cryptographic techniques that allow someone to prove a statement is true without revealing the statement itself or how they know it. This enables both strong privacy and secure verification. **Let’s take a real-world analogy:** imagine you’re a barman and need to verify that a customer is over 18. Instead of showing their date of birth, the customer says, “I can prove I’m over 18, but I don’t want to show you my actual birth date.” ZK proofs formalize this logic into a secure, mathematical process. (Thanks [L2BEAT](https://l2beat.com/scaling/summary) for example) [https://x.com/l2beat/status/1448556881686024192](https://x.com/l2beat/status/1448556881686024192) **Prover:** A prover is the component responsible for generating a ZK proof. It executes a computation off-chain and produces a cryptographic proof that the computation was performed correctly. Instead of revealing the details of the execution, it outputs a succinct summary that attests to the validity of the result. In the Succinct ecosystem, provers generate these proofs and make them verifiable on chains like Ethereum, enabling a model where security, not raw transaction data, travels onchain. **VM & zkVM:** Virtual machines, or VMs, are environments that run software in an isolated and controlled manner, based on defined rules and system calls. [Ethereum Virtual Machine (EVM)](https://ethereum.org/en/developers/docs/evm/) is a specific example that deterministically executes smart contracts on the Ethereum. **zkVMs** are modified versions of general-purpose virtual machines designed to work with ZK proofs. These systems not only execute a program but also make it provable that every step was carried out correctly. zkVMs are usually built on minimal and deterministic architectures such as RISC-V, which enables the generation of cryptographic proofs from execution traces. This allows computations to be verified in a secure, privacy-preserving, and off-chain manner. **Now that we’ve covered the key ZK concepts, let’s begin:** **What is Succinct?** --------------------- ![](https://storage.googleapis.com/papyrus_images/a1f8dab47132aa1b2341713928f56146d5999a9c3645349a0f4bc1d06a8a9ce6.png) Succinct is an infrastructure that verifies the correctness of off-chain computations using ZK proofs. By doing so, it enables Ethereum-based apps to operate more cheaply, more efficiently and with stronger security guarantees. At the heart of the system lies [SP1](https://github.com/succinctlabs/sp1), a general-purpose virtual machine (zkVM) designed to both execute any software and generate a ZK proof that the execution was correct. Built on the RISC-V architecture, **SP1** allows devs to write their programs in familiar languages like Rust. When an apps runs on SP1, it produces not only an output but also a mathematical proof that the result is trustworthy. This means that even if the logic runs off-chain, its outcome can still be verified onchain. However, generating these proofs requires computation and an always-on infrastructure. This is where the S**uccinct Prover Network** comes in. It is a decentralized network of nodes that generate proofs for SP1-based applications and submit them to Ethereum. Each prover executes a task off-chain and submits the resulting succinct proof to the Ethereum settlement layer. This reduces the onchain load, cuts costs and allows apps to be more scalable, efficient and resistant to MEV. **In the rest of this article, we’ll dive deeper into how SP1 works and how the Prover Network fits into this system. We’ll also explore real-world projects that are already using this infrastructure.** Succinct Prover Network ----------------------- One of Succinct’s boldest moves is building a decentralized, permissionless proof generation network. The Prover Network allows anyone to independently execute computations defined by SP1 and generate a ZK proof that is verified on Ethereum. Each prover runs a task off-chain and submits the resulting proof onchain. This is not just a technical improvement. It marks a fundamental shift toward democratizing ZK proving. In the past, generating proofs was limited to a few “elite teams” with specialized hardware. Succinct is turning this into an open marketplace where anyone can run a node and become a prover. [The Recent “Stage 2.5” Testnet](https://blog.succinct.xyz/stage-2-5-2/) demonstrated this vision clearly. Hundreds of participants and leading hardware teams joined the network, completed tasks and generated proofs. With this system, apps are no longer restricted to onchain execution. we now have a secure off-chain execution layer. the long-term goal is to create the largest and most efficient ZK proving cluster in the world. [https://x.com/SuccinctLabs/status/1938282464310591607](https://x.com/SuccinctLabs/status/1938282464310591607) This system is also much lighter thanks to “stateless execution”. A prover does not need to store the entire chain state. Instead, it uses a minimal set of witness data specific to the computation it is proving. This design makes the network more accessible and also ideal for crosschain interoperability. Auctions: Real-Time Competition Among Provers --------------------------------------------- Succinct’s Prover Network is not just a proving layer, it also functions as a marketplace. Each proof request is matched with the most suitable prover through an open auction mechanism. This approach not only decentralizes verification power but also optimizes it through healthy competition. Let’s break it down with a Koca-type example: ### **Step 1: Making a Proof Request** [Uma](https://x.com/pumatheuma) (our CEO) wants to prove a program but she doesn’t want to overspend or wait too long. So she broadcasts a request to the “Succinct Prover Network”: > **_“Who’s fast enough to prove this in 5 minutes for under 100 PROVE?”_** Behind the scenes, this request includes the program to be proven, the deadline (5 mins) and the maximum fee she’s willing to pay (100 PROVE). She sends it to the Auctioneer, an offchain component that handles real-time auctions between provers. The auctioneer will now match this request to eligible provers willing to compete. ![](https://storage.googleapis.com/papyrus_images/49d321dd98f46f310d80ff149f46a6d62115b0e2f53d43c89898d317c9fc8aa8.png) ### Step 2: Bidding & Assignment Uma’s request enters the Succinct Prover Network, where eligible provers like Koca and Utku compete to win the job. Each prover has staked PROVE tokens to participate in auctions. In this case: * **Koca has staked 100 PROVE and bids 60 PROVE to do the job.** * [**Utku**](https://x.com/pls_giveup)**, with a larger stake of 150 PROVE, bids 70 PROVE.** The offchain **Auctioneer** runs a reverse auction and selects the **lowest eligible bid** (in this case, Koca) _Staking determines eligibility, but the bid amount determines who wins._ ![](https://storage.googleapis.com/papyrus_images/6ad4bd5cb6064e5edd595147977e98d0835483ef9ed3eb36f87c2753c49763c7.png) ### Step 3: Proof Fulfillment After winning the auction, Koca now has 5 minutes to generate and deliver the proof. The countdown starts as soon as the assignment is confirmed. Koca runs the proof generation process and submits it back to the offchain auctioneer within the deadline. * **If the proof is delivered on time, it moves to the verification step.** * **If not, the request is canceled and a portion of Koca’s staked PROVE tokens is slashed as a penalty.** ![](https://storage.googleapis.com/papyrus_images/747218949c3ce9e1353ee12637758a6dbdd4e7392f18d9b15dc789122b0e79db.png) ### Step 4: Payment & Verification Once the proof is successfully submitted, it gets verified and the payment is released. The auctioneer checks the validity of the proof and transfers the agreed 60 PROVE from Uma to Koca. The transfer happens via a smart contract, and the entire balance update is wrapped in a ZK proof, making it verifiable on Ethereum without trusting any offchain actor. * **Uma receives her verified proof.** * **Koca receives his reward.** ![](https://storage.googleapis.com/papyrus_images/3ebf718648dfc4b5677909535a82aa9fb2a5c3e30a469b41148b14e001fbf6c8.png) **Thanks Succinct!** **What is SP1?** ---------------- ![](https://storage.googleapis.com/papyrus_images/355b7202440062de23f52e55208b7f713aef373893e5c68ef2cbc8dbf94770d2.png) [SP1](https://github.com/succinctlabs/sp1) is a general-purpose zkVM capable of executing any Rust program and generating a ZK proof that verifies the correctness of that execution. This proof ensures that a program has executed correctly on a specific input without revealing the input, output, or intermediate computation steps. Imagine you want to prove that a program worked as intended without showing how it works or what data it processed, SP1 makes that possible. But SP1’s significance goes beyond this. Most existing zkVMs are closed-source, slow, and difficult to customize. SP1 represents a fundamental shift in this paradigm: * Fully open source (MIT/Apache 2.0 license) * Programmable in Rust and other LLVM-based languages * Capable of near-hardware performance with “precompiled modules” * Supports sharded proving for parallel execution of large programs Thanks to these features, SP1 can handle not just small demos but real-world workloads like SSZ Merkle proof verification or Tendermint light client operations, spanning millions of cycles. In some cases, SP1 even outperforms hand-written ZK circuits. It prioritizes developer experience alongside performance, programs that once took weeks to build and prove can now be implemented and verified in a single afternoon. Through a flexible precompile system, performance bottlenecks can be addressed with targeted VM-level optimizations, making SP1 ideal for infrastructure like rollups, bridges and coprocessors. SP1 marks the end of the slow, closed, handcrafted zkVM era. In its place, it introduces an open, sustainable, contributor-friendly virtual machine architecture. **SP1 Hypercube: Succinct’s Real-Time zkVM Milestone** ------------------------------------------------------ ![](https://storage.googleapis.com/papyrus_images/0b70c1e9c81740e460ec4c9045ec027ddaaf6a09c90f640ce1f36c2917cc2578.png) [SP1 Hypercube](https://blog.succinct.xyz/sp1-hypercube/) is the first general-purpose zkVM capable of proving Ethereum blocks in real time that is, in under 12 seconds. Developed by Succinct, this upgraded architecture can prove 93% of Ethereum mainnet blocks in an average of just 10.3 seconds. this is a major breakthrough, making rollup-level scalability and trust-minimized interoperability achievable at Layer 1. ![](https://storage.googleapis.com/papyrus_images/3f1a0e0a4bea00c166862da7ab76f8206ebe53de5d4dc237b834ea5cafb0846e.png) This speed is not simply the result of more hardware. It is the product of architectural innovation. Unlike earlier SP1 versions and traditional STARK-based systems that rely on univariate polynomials, SP1 Hypercube is built entirely on **multilinear polynomial** encodings. This structure enables compact data representation and efficient handling of conditional branching. **As a result, Hypercube can generate proofs in seconds, even for block traces that include many precompiles** ![](https://storage.googleapis.com/papyrus_images/a071ebedaf65ab523f961f30ea4c75bdd512e2508f833bceda094d23212a6ff3.png) At the core of Hypercube are 2 key innovations: * [**Jagged PCS (Polynomial Commitment Scheme)**](https://github.com/succinctlabs/hypercube-verifier/blob/main/jagged-polynomial-commitments.pdf?ref=blog.succinct.xyz)**:** A flexible “pay-as-you-go” commitment system that only commits to necessary data, dramatically reducing resource usage and proving time. * **LogUp GKR:** A proof protocol specifically optimized for multilinear encodings, enabling fast verification of large computational traces with minimal overhead. This system allows Hypercube to sustain high throughput while keeping latency low. **These innovations bring not just speed, but accessibility:** According to benchmark results, a 160 GPU cluster using RTX 4090s can prove over 90% of Ethereum blocks in real time. This system costs roughly $300,000–400,000 today, but it is expected to become even more affordable, potentially down to ~$100,000 with further hardware and software optimizations. Succinct plans to open source the full stack after a formal audit, allowing developers anywhere in the world to run their own high-performance Ethereum provers. Where Is It Used? ----------------- Below are example applications built by different teams using Succinct’s technology. Each demonstrates how ZK proofs can be applied effectively in different domains. **Let’s take a closer look at these projects and how they are leveraging Succinct:** ### 1\. **Private and Fast CLOBs: Hibachi** [Hibachi](https://hibachi.xyz/) combines ZK proofs from Succinct with encrypted state on [Celestia](https://celestia.org/) to bring CEX-like speed (5ms) and full privacy to onchain trading. Every action is proven offchain and verified onchain. [Source](https://blog.succinct.xyz/hibachi/) ### 2\. Upgrading Blobstream to SP1 Celestia’s Blobstream bridge to Ethereum now leverages SP1, Succinct’s zkVM. With less than 300 lines of Rust, SP1-Blobstream verifies [Celestia](https://celestia.org/) data roots on EVM chains like Ethereum, [Arbitrum](https://arbitrum.io/) One and [Base](https://www.base.org/), achieving gas-efficient (~280k gas) verification. [Source](https://blog.succinct.xyz/celestia-sp1/) ### 3\. SP1 is Bitcoin-ready: Succinct brings ZK proofs to Bitcoin Succinct and BitVM now enable native ZK proof verification directly on Bitcoin. With SP1’s optimized support for BLAKE3 hashing, verifying Groth16 proofs is cheaper and faster, unlocking trust-minimized Bitcoin rollups, bridges, sidechains and more. [Source](https://blog.succinct.xyz/bitcoin-sp1/) ### 4\. Succinct Connects Cosmos to Ethereum with ZK-powered IBC Succinct now enables trustless and efficient bridging between 120+ [Cosmos](https://cosmos.network/) chains and Ethereum via [IBC Eureka](https://cosmos.network/ibc-eureka/). Leveraging SP1 and Succinct’s decentralized prover network, Cosmos consensus verification is compressed into a single ZK proof, cutting onchain costs by 25x and making IBC to Ethereum practical at scale for the first time. [Source](https://blog.succinct.xyz/ibc/) ### And Beyond... [Succinct ecosystem](https://www.succinct.xyz/ecosystem) continues to grow rapidly, with new teams and ideas building on top of its open infrastructure every day. ![](https://storage.googleapis.com/papyrus_images/8bb82a94c100b76e2bf782c775663a66347d0ce5876d04293ddb527c707874be.png) **Conclusion** -------------- Succinct doesn’t just offer a ZK infrastructure. It marks the beginning of a new era in software verification, guided by its motto: “prove the world’s software.” With SP1 zkVM and the decentralized Prover Network, Succinct powers real-world applications across a broad ecosystem including [Polygon](https://polygon.technology/), [Celestia](https://celestia.org/), [Avail](https://www.availproject.org/), and more.. As someone who has followed and contributed to the project since its early days (2023), i can confidently say that Succinct ran one of the most impressive Testnets I’ve ever seen. Its real-time proof architecture, open-source philosophy and community-driven design are not just technical achievements. they redefine what’s possible in the ZK space. I’m genuinely excited for the mainnet launch. > **To explore and learn more about Eclipse, I suggest you join the** [**Discord**](https://discord.com/invite/succinctlabs)**, check out** [**Succinct Documentation**](https://docs.succinct.xyz/) **and** [**Blog**](https://blog.succinct.xyz/)**.** ![](https://storage.googleapis.com/papyrus_images/8d457cd8b0fdb7b71e5265d14443ede7c46f9c72f942b5da80411bf56b301793.png) --- *Originally published on [koca](https://paragraph.com/@kocality/prove-the-world-s-software)*