If you’ve spent any time in blockchain or cryptography circles, you’ve probably heard the buzz around zero-knowledge proofs (ZKPs). They’re a clever bit of math that lets you prove something is true without showing why it’s true, kind of like proving you know the password without actually typing it out in front of someone.
ZKPs can supercharge privacy, security, and scalability in Web3. But here’s the catch: generating these proofs has traditionally been painful — it’s slow, it’s expensive, and it often requires a PhD-level understanding of cryptography.$PROVE
@Succinct Labs, a small but well-funded startup out of Silicon Valley, wants to change that. Founded in 2022 by Uma Roy and a team of cryptography veterans, they’ve raised 55 million from Paradigm and other big-name investors to make ZKPs easy to use, fast to generate, and most importantly, available to anyone.
Their approach boils down to two main innovations:
1. A decentralized Prover Network — a global, open marketplace where anyone can request or generate ZK proofs
2. SP1, a high-performance, general-purpose zero-knowledge virtual machine (zkVM) that can prove any program’s execution
Put them together, and you get something like cloud computing for proofs, except instead of trusting Amazon or Google, you’re tapping into a decentralized network that’s incentivized to be fast, cheap, and honest.
The Big Problem: ZK Proofs Are Powerful but Painful
Zero-knowledge proofs have been around for decades, but until recently, they were mostly academic toys. In blockchain, they’re now used for:
Scaling (zkRollups on Ethereum)
Privacy (shielded transactions)
Bridges (verifying events across chains without trusting middlemen)
The catch? To use ZKPs, you either:
Hire a rare and expensive ZK engineering team to design custom circuits for your logic
Set up and maintain your own high-powered servers with GPUs or FPGAs to generate proofs
Or pay a centralized service to do it for you and hope they don’t go offline
@Succinct s bet is simple: what if proof generation was as easy to outsource as file storage or compute power? That’s where their Prover Network comes in.
The Succinct Prover Network — Proofs on Demand
Think of the Prover Network as a marketplace for math.
On one side, you have requesters — projects, apps, or blockchains that need proofs. On the other side, you have provers — people or organizations running heavy-duty hardware who can generate those proofs.
Here’s how it works:
1. A requester submits a job: I need a proof that this program ran correctly, and I’ll pay X tokens
2. Provers bid to do the job — competing on both price and speed
3. The winner generates the proof, submits it back, and gets paid
4. If they fail or cheat, they lose their stake held in the network’s PROVE token
It’s permissionless — anyone with the right hardware can join as a prover — and it’s decentralized, so no single company controls who gets to prove what. Jobs are matched by an automated auction, not a central gatekeeper.
The design has some nice side effects:
Lower costs: competition pushes prices down
Faster turnaround: provers optimize to win jobs
Reliability: if one prover disappears, another can step in
No setup pain: requesters don’t need to run any proving hardware
In short, it’s like AWS for ZK proofs, except AWS is replaced by a swarm of independent operators racing to serve you first.
SP1 — The zkVM That Proves Anything
If the Prover Network is the marketplace, SP1 is the engine. It’s Succinct’s custom-built zero-knowledge virtual machine that can run any program compiled to the RISC-V architecture and spit out a proof of its execution.$PROVE
Why does that matter? Most ZK systems are specialized — a zkEVM can prove Ethereum transactions, but not a custom AI model or a game engine. SP1 is general-purpose. If you can write it in Rust or C++, SP1 can prove it. That means:
No learning exotic ZK languages
No hand-crafting cryptographic circuits
No months-long dev cycles just to get a proof
And it’s fast. Really fast. Independent benchmarks show SP1 proving certain programs up to 28× faster than comparable zkVMs. It’s packed with optimizations for common crypto operations such as hashing, signature checks, and elliptic curves, and can even take advantage of GPUs or FPGAs for big speed boosts.
Best of all, SP1 is open source and audited, so developers can inspect it, trust it, and even improve it.
Why They Work So Well Together
Here’s the magic:
SP1 makes it easy to write programs that can be proven
The Prover Network makes it easy to get those proofs generated at scale, without running your own infrastructure
For a developer, the flow is simple:
1. Write your logic in normal code
2. Compile to SP1
3. Send proof requests to the network
4. Get back a proof you can verify on-chain or anywhere else
No cryptography PhD. No GPU farm in your garage. Just working proofs.
Real-World Proof
Succinct’s approach isn’t just theory — it’s already running in production:
Mantle Network is transitioning from an Optimistic Rollup to a zkRollup powered by Succinct
Cosmos to Ethereum bridge now uses Succinct’s proofs to connect 120+ chains
World Chain from the Worldcoin team uses Succinct to cut transaction finality from 7 days to 1 hour
Galxe uses SP1 to prove on-chain raffles are fair
Hackathon projects have even used SP1 to prove image edits in a browser
These are wildly different use cases, but they all lean on the same core infrastructure — general-purpose proving plus a decentralized marketplace to run it.
How It Stacks Up
Compared to other ZK efforts, Succinct stands out for a few reasons:
General-purpose — not locked to one blockchain or transaction type
Decentralized provers — no single point of failure or control
Market-driven efficiency — auctions keep prices low and speeds high
Developer-friendly — write in Rust or C++, no need to learn new languages
Battle-tested — already powering live systems at scale
The Bigger Picture
@Succinct Labs isn’t just building another blockchain tool, they’re building an infrastructure layer for trustless computation. If they succeed, ZK proofs could go from an exotic niche to an everyday part of software, much like SSL certificates did for web security.
By making proofs easy to write with SP1 and easy to run with the Prover Network, they’re lowering the barrier so that any developer can build verifiable systems. And they’re doing it without sacrificing decentralization, performance, or openness.
In the long run, that could mean a web where you never have to take someone’s word for it — you can just check the proof.