The Problem: Blockchains are terrible computers
Blockchains were engineered for state consensus, not high-throughput computation. By design, every validator must deterministically re-execute each transaction before it can be committed to the ledger. This guarantees correctness, but forces overall performance to match the slowest node on the network.
Practical consequences
- Execution is capped. Gas/block size limits exist to keep verification latency bounded so that nodes can remain in sync. Any transaction that would push execution time or memory beyond those limits is rejected.
- Compute is needlessly replicated. Thousands of nodes perform the same transactions, so total re-execution grows linearly with node count, while the amount of “real” work stays constant.
- Scaling paths fragment state. New networks increase execution through parallelization of state machines, however these create separate liquidity pools, state silos, and introduce bridging risk, rather than removing the bottleneck altogether.
In practice, blockchains are good at payments and simple DeFi primitives, yet can’t handle more expressive applications and complex workloads like large-scale historical state queries, or complex pricing algorithms. Developers resort to aggressive micro-optimizations (gas golf) or access offchain compute that re-introduce new trust assumptions.
To support advanced markets, games, and data-rich applications, blockchains need a standard mechanism for accessing high-volume, verifiable compute without sacrificing trust guarantees. Until that exists, onchain expressivity will remain constrained by the narrow lane of re-execution.
Introducing Boundless: The Universal ZK Protocol
Boundless is a universal zero-knowledge protocol where anyone can access abundant verifiable compute . Boundless provides a network of nodes dedicated solely for execution, producing ZK proofs that the work was done correctly, verified on every chain at a low, constant cost. By decoupling execution from consensus, Boundless lets every chain keep its native security while escaping gas ceilings and re-execution.
The Boundless Market: How you plug in
Access to Boundless begins through The Boundless Market contracts, deployed natively on every major chain. The Boundless Market acts as a permissionless clearing house that matches proof requests from applications with compute capacity supplied by Boundless prover nodes. Because the market contracts exist on every chain, developers can stay in their home ecosystem: they interact with a local contract address, pay in the chain’s native token, and receive a proof they can verify on the spot.
How the Boundless Market Works
1. Create & broadcast a proof request
- A developer constructs a proof request that specifies:
- The zkVM program (URL)
- Input - either inline or a URL
- Requirements on proven execution output (e.g. an expected journal hash)
- Offered price and required stake - as auction parameters (min/max price, ramp-up time, time-outs, and slashing stake)
- The request can be posted onchain with BoundlessMarket.submitRequest() or sent offchain after pre-funding the Market contract.
2. Reverse-Dutch Auction
- At the time specified in the request, a reverse Dutch auction starts. Price begins at minPrice, rises linearly during the ramp-up period, then stays at maxPrice until expiry.
- Boundless prover nodes execute the program, to estimate cycles, and decide whether the current price exceeds proving cost.
- The first Boundless prover node to accept the price by placing a bid locks the request, giving them exclusive rights to be paid for fulfillment. In exchange, they must provide stake that will be forfeit if they do not deliver by the lock expiration.
- At any time, a prover may also directly fulfill an unlocked job without bidding first. If they do, they will receive the current auction price. No stake is required.
- When a prover fails to deliver on a locked request, their stake becomes a bounty. The first prover to provide a proof gets the bounty.
3. Proof generation & batching
- Provers can batch multiple jobs
- Individual execution receipts become leaves in a Merkle tree; a single Groth16 proof attests to the root.
- Batching amortises on-chain verification gas across all included requests.
4. Settlement
- The market contract:
- Verifies the Groth16 proof once
- Checks each Merkle inclusion proof against its corresponding request
- Pays the prover from the locked funds (or the requestor’s deposit) and returns stake
- An event is emitted when the proof is delivered. The proof is made available in calldata.
- Additionally, requestors can receive a callback to a contract on proof delivery.`
The Boundless Incentive Mechanism: Proof of Verifiable Work
Existing protocols reward either probabilistic effort (hashes → PoW) or idle capital (stake → PoS). PoVW is the first mechanism that can measure the complexity of each ZK proof on-chain and pay provers exactly for the work they complete.
How the meter works
- Immutable Cycle Tag
- Every Boundless proof embeds an immutable tag that records the number of cycles proven, plus a unique nonce to prevent replay. The tag is part of the proof’s public claim, so neither the prover nor the requestor can tamper with it.
- Epoch tally
- At the end of each epoch, the PoVW contract sums the cycle tags from all proof finalized during that window.
- Deterministic payout:
- A fixed amount of $ZKC (Boundless’ native token) is minted for the epoch and distributed pro-rata to cycle share (e.g., a prover who delivered 2% of total cycles, receives 2% of the mint).
PoVW turns zero-knowledge proofs into the first digitally native, metered resource that a protocol can reward, closing the loop between supply, demand, and verifiable output.
Why PoVW Matters
- Accuracy over guesswork: Rewards scale with cryptographically verified work; no more treating a 10-cycle proof the same as a 10-million-cycle proof.
- Permissionless meritocracy: Any node that meets latency and stake requirements can earn exactly what it proves.
- Transparent economics: Because the meter is onchain and tamper-proof, anyone can audit payouts down to the last cycle.
What teams are shipping today with Boundless
(Check out our ecosystem page for more)
ZK Rollups
- Taiko is a based type-1 zkEVM rollup. Taiko’s multi-prover leverages Boundless for validity proofs.
- Citrea is building a ZK rollup that enhances the capabilities of Bitcoin blockspace. Citrea records roll-up commitments directly on Bitcoin and relies on Boundless to generate the heavy zero-knowledge proofs that cover both smart-contract execution and Bitcoin block-space inclusion. This architecture adds EVM-style programmability to BTC while inheriting Bitcoin’s finality.
Hybrid Rollups
- SOON is building an SVM-based rollup stack that lets teams keep Solana’s tooling and performance while settling on any chain. The stack relies on ZK Fraud proofs generated though OP Kailua on Boundless, so the rollup’s challenge window shrinks from seven days to about three hours. Users withdraw the same day they deposit, without crossing a bridge.
- BOB is creating a hybrid Bitcoin rollup that runs EVM contracts but anchors finality to Bitcoin. Validity proofs are produced with OP Kailua on Boundless, unlocking 1-hour finality.
Verifiable Exchanges
- Hibachi built the first provable exchange. Off-chain matching executes at high frequency; every batch is proven with R0VM on Boundless, covering both trade execution and solvency. Traders get sub-second fills, and the exchange’s balance sheet is cryptographically auditable in real time.
Universal DeFi
- Mendi is building a unified lending platform that treats liquidity on multiple chains as one pool. Its core logic stays in Solidity but runs through Steel on Boundless, so large state reads and rate calculations execute off-chain without gas limits. Users can supply collateral on one network and borrow on another with no custodial bridges.
Boundless Use Cases
Early adopters (rollups, DEXs, lending markets) already push their heaviest logic through Boundless, gaining stronger security guarantees and freedom from gas ceilings. Any developer can do the same: run arbitrarily complex code off-chain, then return a ZK proof that keeps everything verifiable onchain.
That capability cracks open a design space we’ve barely explored. Web2 services enjoy “infinite” compute but surrender trust to centralized stacks; blockchains keep trust but throttle expressivity. Boundless removes the trade-off: developers get internet-scale computation and cryptographic verifiability.
The real question is no longer “Can this fit on-chain?” but “What will we build when verifiable compute is effectively limitless?” The projects above are only the starting line.
Boundless is foundational to blockchains
Boundless introduces a new layer of infrastructure that brings abundant, verifiable compute to every chain. It doesn’t compete with existing networks, it enhances them, unlocking a broader design space for developers.
By decoupling execution from consensus, Boundless enables applications that are more powerful, expressive, and no longer limited by gas or siloed environments. Boundless is not a replacement for blockchains, it’s how they reach their full potential.
Getting Started
Choose the path that fits what you’re needs:
Boundless for Miners - Spin up a prover node and generate proofs
Boundless for Rollup Teams - Upgrade to a ZK Rollup in hours
Boundless for EVM Developers - Run Solidity code without gas restrictions.