Boundless has launched its mainnet alongside a token generation event (TGE) that values the network’s ZKC token at ~$900 million fully diluted, at the time of writing. Built by the team behind Risc Zero—the first fully open-source, general-purpose zkVM—Boundless extends years of ZK engineering into a decentralized proving marketplace.

The launch introduces Proof of Verifiable Work (PoVW) and ZK Coin (ZKC), a token mined by proofs themselves. By rewarding provers for generating zero-knowledge proofs and collateralizing them with ZKC, Boundless creates the economic layer that turns verifiable computation into an abundant, shared resource for blockchains, rollups, and applications across ecosystems.

This moment reflects the natural progression of RISC Zero’s work: from developing core zkVM infrastructure to now operating a universal proving network, where capacity grows as more provers join.

In this article, we’ll explore the foundations of zero-knowledge proofs, RISC Zero’s contributions to the field, and how those efforts now culminate in Boundless.

Zero-Knowledge Proofs: The Foundation For RISC Zero & Boundless

A classic way to understand zero-knowledge proofs (ZKPs) is through the “Where’s Waldo” analogy¹. Imagine trying to prove you’ve found Waldo without revealing where he is: you cut out the character from the puzzle, hand the cutout to a friend, and throw away the board. Your friend can verify it’s Waldo, but not his location. That’s the essence of a ZKP: proving knowledge of something without revealing the underlying data.

This is kind of like a zero-knowledge proof (with less cryptography and more craft supplies). In the world of blockchain, they enable a prover to convince a verifier of the knowledge of a claim (such as the execution of a program with optionally private inputs) with a proof that is much shorter than the claim itself. This allows blockchains to scale their throughput by separating transaction execution, which is expensive. 

ZKPs break this bottleneck by decoupling execution from verification²:

• Execution (expensive): A subset of participants (provers) perform the heavy computation - e.g., running thousands of transactions or a smart contract program.
• Proof generation (constantly improving exponentially): These provers produce a succinct cryptographic proof attesting to the correctness of the execution.
• Verification (cheap): All other participants (verifiers) only need to check the proof, which is orders of magnitude faster than re-running the computation.

This architecture allows throughput to scale: the system can process more transactions without requiring every node to redo all the work. Beyond scalability, zero-knowledge proofs (ZKPs) also unlock privacy. The key property is that a prover can convince a verifier that a statement is true without revealing the underlying data. This means blockchains can support confidential computation: transactions or smart contract executions can be verified as correct, while sensitive details remain hidden.

Both Ethereum and Solana are consciously evolving toward better ZK-friendliness, making them natural homes for rollups, zk-coprocessors, and privacy-preserving apps. Ethereum’s roadmap has long assumed that zk-proofs will be central to scaling:

• zk-Rollups: The canonical L2 scaling solution (alongside optimistic rollups), already deployed (zkSync, Scroll, Starknet, Polygon zkEVM, etc.), uses succinct validity proofs to batch execution off-chain and verify on-chain cheaply.
• Precompiles for elliptic curve operations: Ethereum L1 includes precompiled contracts that provide efficient cryptographic primitives necessary for zk-proof verification

While Solana pursues scalability primarily through parallel execution (its Sealevel runtime) rather than making ZK the centerpiece of its end‑state roadmap, the ecosystem has steadily added ZK‑friendly primitives at the runtime level. Through Solana Improvement Documents (SIMDs 222, 284, 302, 334 adding and improving elliptic group arithmetics and pairing) and core runtime updates, Solana now exposes built‑in crypto programs and syscalls that make on‑chain proof verification and ZK‑centric app logic practical.

Risc0 in the ZK world

RISC Zero is the first fully open‑source, general‑purpose zero‑knowledge computing stack centered on a RISC‑V zkVM. That receipt can be verified off‑chain or on‑chain.

Let’s analyse the limitations of some proving systems that existed before Risc0

• Starknet is not a zkEVM. It runs the Cairo VM and requires smart contracts in the Cairo language. This gives it freedom to optimize for proofs, but it means learning a new toolchain rather than plain Solidity/EVM.
  
  
• Scroll aims for EVM‑equivalence, but in practice documents behavioral differences (opcodes, precompiles, limits, etc.) between Ethereum mainnet and Scroll’s zkEVM. Most apps deploy as‑is, but there are edge‑case mismatches to mind.
  
  
• zkSync Era runs a ZK‑optimized VM (EraVM) and, as of 2025, ships an EVM bytecode interpreter so EVM bytecode can run. zkSync’s own docs still call out differences and limitations versus Ethereum, like gas metering, opcode support, and execution‑model nuances, so “equivalence” comes with caveats until their next proving system lands.

In Risc0, you write “guest” programs (Rust/C/C++ today) that compile to RISC‑V; when they run inside the zkVM, they emit a receipt—a succinct proof that the code executed on specific inputs and produced specific outputs. The revm crate is a Rust-based EVM interpreter. Like most Rust crates, the revm crate can be run in the RISC Zero zkVM. As a result, RISC Zero’s approach avoids EVM‑specific constraints entirely. Under the hood, RISC Zero proves execution with a STARK system and then “shrink‑wraps” it into a Groth16 proof so EVM contracts can verify results cheaply (constant‑time verification with small calldata). This STARK→SNARK wrapping is part of the official developer workflow for Ethereum integration. 

Earlier revm could only prove small transactions without hitting cycle cap; in particular, it was unlikely to be able to prove transactions with elliptic curve precompiles. With “continuations,” we no longer have this limitation. Continuations are a mechanism for splitting a large program into several smaller segments that can be computed and proven independently. This has many benefits, for example, parallelizing proving, enabling pausing and resuming of the proof generation process, limiting memory requirements to a fixed amount, regardless of program size. Building on top of revm and continuations, Risc0 has also released Zeth, which could prove the validity of the whole Ethereum block in minutes during release and in tens of seconds as of the latest developments. 

Beyond its L1 work, RISC Zero has introduced OP Kailua for OP Stack rollups. Transactions are posted optimistically as usual, but if a block is challenged, the dispute is resolved with a single zero‑knowledge proof rather than a multi‑round fault game, cutting collateral/operational overhead and shortening time‑to‑finality from days to hours.

Citrea is a Bitcoin Layer‑2 zk‑rollup built by Chainway Labs and powered by RISC Zero’s zkVM. Transactions run in a Type‑2 zkEVM; Citrea then publishes a succinct validity proof and compact state‑diffs to Bitcoin L1 for data availability and settlement. The ZK proof is verified on Bitcoin via BitVM (an optimistic verification of the ZK proof), enabling a trust‑minimized two‑way peg called Clementine. The design keeps Bitcoin as the source of truth while delivering EVM‑equivalent programmability. Besides Citrea, BOB, another Bitcoin ZK layer 2, also uses OP Kailua inside its tech stack for dispute resolution, combined with its own BitVM3 for proof generation.

Boundless, A ZK computing power marketplace 

Designed by the Risc0 team, Boundless is a decentralized market, aggregation, and smart contract settlement protocol to scale ZK-powered verifiable computation for every chain. In Boundless, operators of GPUs and other commodity hardware called provers compete for on or off-chain requests for zero-knowledge proofs issued by requestors via an efficient and open market. Such requests might occur either in the spot market or as part of a service agreement contract. In either case, payment is settled in conjunction with the verification of the proof on the destination chain specified by the requester.

Boundless solves the following problem: teams seeking to adopt ZK must build their own pipeline for proofs. This is a non-trivial challenge, encompassing the lack of suitable decentralized infrastructure, differences in the control flow between standard on-chain execution

and ZK-powered execution, incentive management, and issues associated with bootstrapping and retaining proving capacity.

One novelty that Boundless brought is proof of verifiable work. This feature gives provers the ability to include metadata about the number of cycles that went into the proof. This metadata is cryptographically secure, meaning that the prover cannot manipulate/alter it without invalidating the proof. This provides a fair measurement of work to either determine the price of computation or platform token rewards.

Competing with already existing Succint, which by contrast, runs a single Ethereum‑settled verifiable application (vApp) - the Succinct Prover Network - where an off‑chain auctioneer runs proof‑contests (a reverse auction), requesters pay in PROVE, provers stake PROVE (with slashing for missed deadlines), and the network periodically posts a ZK proof of its updated state root and receipts to Ethereum for settlement. 

Both ecosystems also ship OP‑Stack upgrades: OP Kailua (Boundless/RISC Zero) adds ZK fault‑proof or full‑validity modes without leaving OP Stack, while OP Succinct offers analogous ZK‑fault‑proof and validity configurations.

Risc0 and the future

RISC Zero is building out our real-time proving cluster for Ethereum, meaning proof generation time is under one block on Ethereum mainnet, i.e., 12 seconds, unlocking:

• 100 - 1000x gas limit: since proofs can be verified in constant time, despite the large computation being proven, Ethereum no longer needs a restrictive gas size limit.
• Cross-rollup synchronous composability: The pain point with rollups is managing interoperability between chains. Real-time proving enables atomic composability between rollups
• More secure light clients: today, light clients check validator signatures but don’t actually check the validity of the EVM state update. With RTP, light clients can confirm the integrity of the state update, rather than needing to trust the validators. 

Generating a block proof in under 12 seconds is the entry ticket to “real-time” status, but the ticket is worthless if only a handful of operators can afford it. To ZK-ify Ethereum L1, generating proofs becomes an essential piece of the block proposal process. If real-time proving requires million-dollar rigs or proprietary stacks, Ethereum would centralize overnight. This is why accessibility matters just as much as speed.  Risc0’s profiling shows that our upcoming ~$120K proving cluster will push RISC Zero’s Ethereum proving times to ~9.25s.

At RockawayX, we believe RISC Zero has established itself as a reputable leader in the ZK landscape. The team’s consistent shipping cadence and pragmatic architecture - spanning a production‑grade zkVM, a decentralized proof market, and rollup upgrades - make ZK practical for real applications today. 

As these components compound, we expect RISC Zero to enable increasingly diverse use cases, from faster‑finality and higher‑security L2s to verifiable off‑chain computation, privacy‑preserving workflows, and interoperable settlement between ecosystems.

Sources: 

1. https://www.rockawayx.com/insights/bob-becomes-first-hybrid-zk-rollup 
2. https://github.com/risc0/risc0
3. https://www.reddit.com/r/ethereum/comments/1f81ntr/ama_we_are_ef_research_pt_12_05_september_2024/
4. https://read.beboundless.xyz/
5. https://risczero.com/blog

‍