SP1: A performant, 100% open-source, contributor-friendly zkVM

Can someone explain this in lay-person’s terms?

I feel like I read and ‘understood’ the text of the blog post, but I’m still none the wiser about what sort of things this can prove and what the values of those proofs is.

For those looking for applications outside crypto, this might also be interesting: https://docs.ezkl.xyz/

It's similar to Succinct but for proofs of ML models instead of RISCV. So you could generate a proof on some private data, on your computer or in a trusted environment, and submit the proof to show that you pass a fraud check without revealing any of your data.

If its not obvious what a zKVM is, it shouldn't be unexplained in a headline with no commmentary.

edit: The fact that its actually zkVM instead is even more confusing.

"verifies the execution of [..] any LLVM-compiled language"

Why is it limited to LLVM-compiled languages? Wouldn't anything that compiles to RISC-V work?

And since the LLVM bitcode format completely changes every time there's a new LLVM release, how does that work?

I cofounded a company doing also this [1] you can check the repositories [2].

[1] https://bitvmx.org

[2] https://github.com/FairgateLabs

Not as inscrutable as these things usually are, but I still don't really know what one would use this for. This world feels like a parallel ecosystem to traditional software, and the paths rarely meet.

So i could write some complex logic with nested for loops and ofload it to the coprocessor

Allow me to add some context. The idea behind "proving" computation relies on the assumption that someone wants to verify it. Some systems require verification. Most notably: distributed systems that don't rely on a centralized authority to enforce rules.

Historically, you either don't verify compute: you don't verify that AWS runs correctly code on the cloud, nor do you verify the algorithm used to compute your taxes. Or you verify compute via re-execution (to make sure a program ran correctly, just run it locally on given inputs): e.g. every participant in the Bitcoin protocol re-executes all transactions on the network. This means that all payments on this platform are verified by peer-to-peer nodes. Moreover, anyone who desires to convince themselves that the system runs with integrity can simply boot a node and join the network. This adds robust security characteristics! Nonetheless, this creates great friction as every time a transaction is verified on these distributed systems, it is re-executed. This does not scale.

Enters "ZK" (zero-knowledge), a technology able to grant verifiability to computation that does not rely on re-execution but rather checking a succinct certificate of correct computation. Anything that refers to succinct proofs of computation is currently referred to as ZK. Nonetheless, ZK can grant either Scalability or Privacy. It is usually known to refer to privacy. ZK-VMs are mostly used to achieve scalability.

The disruptive advantage of ZK is the separation of two actors: Prover and Verifier. The prover runs a computation once and generates a proof that it did so with integrity (following some pre-defined rules such as "i can't create new money"). Verifiers are then able to check the integrity of the network with overwhelmingly low hardware requirements.

TL;DR: ZK compresses compute. The first use case for ZK (in terms of scalability) is to prove Blockchain transactions to greatly increase scalability of blockchains. Many use cases will follow.

Is this useful outside the cryptocurrency crap?

L. Ron Hubbard has entered the chat.