The Succinct’s platform goal is to accelerate ZK adoption, so that developers from different backgrounds can quickly incorporate ZK into their own solutions.

The platform enables off-chain execution of intensive computations by implementing zk-SNARKs (Zero-Knowledge Succinct Non-Interactive Arguments of Knowledge) and recursive proofs to generate highly compact proofs of computational integrity. This results in faster processing times and lower costs for on-chain transactions, making decentralised applications more efficient and scalable.

In order to fulfil this vision, Succinct has released several products that work in unison to bring state of the art zero-knowledge features to development teams:

• Succinct Protocol: an open infrastructure layer with several standards and proving system agnostic components.

• Decentralised Prover Network: an application-specific blockchain optimised for fast-finality, short-term censorship resistance, and sovereignty.

• Succinct Platform: a UI that integrates the development flow of ZK based applications with a prover network and SP1 zkVM.

• SP1: a state of the art zero-knowledge virtual machine, capable of compiling Rust and generating proofs of arbitrary logic.

• SP1-Reth: a POC performant type-1 zkEVM

The following sections further dive into the products, what role they fulfil in the wider stack and their intricacies.

The Succinct Protocol

An open infrastructure layer with several standards and proving system agnostic components. The platform leverages the standardisation of the protocol to provide unified workflows for any proving stack, making ZK development more modular and coordinated.

These are the main components of the protocol:

• Proof standard: open-source, ERC-like standard enables developers to seamlessly link their on-chain logic and inputs/outputs with off-chain verifiable computation. This standard allows developers to use any proving system to create their ZK application, provided they standardise their public inputs and outputs to adhere to a simple specification. This will be explained later in the “Into the code” section of this article.

• Succinct Gateway: to link a smart contract with off-chain computation, developers can request proofs via the Gateway contract and receive verified outputs post proof verification. This provides a standardised interface to integrate with any proof system through a single address on any chain.

• Proof Marketplace: proofs on the platform can be generated by Succinct’s proving infrastructure. In the long-term, this infrastructure will evolve into an open proof market where provers will earn fees for providing their compute power. The market will provide competitively priced, highly available, and decentralised proving to ZK applications.

• Proof Aggregator: Today, the minimum cost for verifying a proof on-chain is ~200k gas. A universal aggregation protocol is in development. It will aggregate proofs from a variety of proof systems and send the marginal cost of verifying a proof on-chain to zero.

Decentralised Prover Network

Today’s ZKP landscape requires applications to build and manage their own infrastructure, a challenging task as cost-effective proving increasingly requires custom hardware and efficient hardware utilisation. With Succinct, applications simply submit proof requests to the network and an auction mechanism matches these requests with a diverse set of Provers who run latest generation hardware.

Users of Succinct’s network don’t have to run their own infrastructure and can be assured by the high liveness guarantees of the network itself. Coordinating zero-knowledge proof generation on a decentralised marketplace benefits end-users through the economies of scale of proving and aggregation.

Aggregation at scale decreases on-chain verification costs. With a carefully planned architecture developers can benefit from this setup since proofs that are not latency sensitive can be aggregated into a single proof before being delivered on chain, reducing the verification cost of a zero-knowledge proof (~200K gas) by an order of magnitude.

SP1: Zero-Knowledge Virtual Machine

SP1 is a zero-knowledge virtual machine (zkVM) that verifies the execution of arbitrary Rust code. It could eventually also target any other LLVM-compiled language (like C++, Swift, Julia and Kotlin).

With the launch of TestNet, SP1 is currently the fastest and more feature-rich zkVM available (compared to Risc0 & Jolt).

Allowing developers to write programs in Rust with full support for the standard library is no small feat since it enables them to leverage their existing skills and tools. This compatibility extends to numerous Rust crates, including revm, alloy, tendermint-rs, serde, and json, making it easier to write verifiable programs without needing to learn new languages or frameworks.

One of SP1’s standout features is its use of performant STARK recursion and a Groth16 STARK-to-SNARK wrapper. This combination significantly reduces the size of SP1 proofs, making them verifiable on any EVM chain for approximately 300k gas. This capability is crucial for applications requiring efficient on-chain verification, such as zkEVMs and ZK light clients.

The novel “precompile-centric” architecture of SP1 facilitates extremely fast and cost-effective proof generation. This architecture allows for an order-of-magnitude improvement in proof generation speed for common blockchain applications, including ZK rollups.

SP1 is committed to open-source principles, with its entire constraint logic available for public scrutiny and contribution. The codebase is licensed under MIT, ensuring that developers can freely use, modify, and distribute the software. This open approach encourages collaboration and continuous improvement from the community, also facilitating third-party audits, improving the overall transparency and security of the system.

For use cases that require chaining together multiple proofs, such as proof aggregation or rollups, SP1 supports efficient recursion within itself. This capability allows for the verification of SP1 proofs within SP1, streamlining the process of creating complex, nested proof systems. This example repository demonstrates this functionality, providing developers with practical insights into implementing SP1 recursion in their projects.

Into the code

Setting up a project with SP1 follows a familiar process for Rust developers, akin to initialising a regular Rust project. You start by using the command cargo prove new <name>, which sets up the project structure needed for developing with SP1.

Once the project is set up, you can write your business logic in plain Rust. SP1 allows for arbitrary logic, enabling you to leverage the full power of the Rust programming language without requiring any special syntax or constructs specific to SP1. This flexibility makes it easy to integrate SP1 into existing Rust projects or develop new applications from scratch.

Handling inputs and outputs in SP1 requires pre-processing and committing these values using the SP1 SDK. This step ensures that the prover can utilise these values effectively during the proof generation process. By committing inputs and outputs, you establish a secure and verifiable connection between the data and the computation.

To enhance performance, SP1 provides several utility functions as pre-compiles. These utilities include hashing functions such as SHA256 and Keccak256, which are commonly used in cryptographic operations. Additionally, SP1 supports elliptic curve operations with algorithms like Ed25519, Secp256k1, and Bls12–381. These pre-compiles are optimised for performance, making it easier to implement secure and efficient cryptographic functionalities in your applications.

SP1 offers a Rust SDK and some CLI tools sp1up&cargo prove that allows you to:

1. Create “provable” Rust projects

2. Compile a Rust program as a RISCV executable (ELF)

3. Run Rust programs & generate proof of execution (with given inputs and resulting outputs)

4. Verify the proof on-chain (by generating a Solidity contract that can be deployed and used for verification)

Anatomy of SP1 Programs

• program: the source code that will be proven inside the zkVM.

• elf: contains compiled RISCV executables.

• script: contains proof generation and verification code.

Generating Proofs with SP1

Normally SP1 generates Groth16 proofs that grow in size depending on the amount of cycles that the program takes to run. SP1 can also be set to use STARK recursion to generate constant size proofs. This will take longer time for proof generation, but ensure that the proof size remains constant.

To build performant recursion, Succinct has built an open-source zkVM recursion stack that allows for programmable verification of SP1 proofs on-chain. These are the main components of the recursion stack:

• Recursion zkVM: implements recursion-specific ISA (Instruction Set Architecture) and is heavily optimised for succinct verification.

• Recursion DSL: a custom Rust-based domain-specific-language that natively supports fields, extension fields, accelerated recursion primitives, and ZK-friendly memory.

• Recursion Compiler: compiles programs written in the recursion DSL into multiple target backends, including the recursion zkVM ISA and a Gnark circuit (used for PLONK-KZG verification of STARK proofs).

The SP1 Rust SDK offers a ProverClient that can be used to execute compiled code and generate proofs programmatically.

SP1 Benchmarks

Proof generation time remains a challenge to be tackled, in order to accelerate the proof generation speed time, Succinct Labs recently announced the introduction of SP1 GPU. This will enhance the performance of their prover, achieving up to a 20x improvement. This results in a 10x reduction in both cost and latency.

You can reproduce some of the following benchmarks using Succinct’s benchmarking library for zkVMs.

Verifying Proofs with SP1

By default, the proofs generated by SP1 are not verifiable on-chain, as they are non-constant size and STARK verification on Ethereum is very expensive (for now).

To generate a proof that can be verified on-chain, the zkVM can:

1. Generate a normal SP1 proofs

2. Recursively combine all proofs into a single proof using the STARK recursion protocol.

3. Wrap the recursive proof in a SNARK proof using Groth16.

You can follow these guidelines to verify your proof with Solidity in Ethereum.

Succinct’s future perspective

Envision a ZKP ecosystem where a variety of applications and infrastructure seamlessly integrate the latest research in proof systems and custom hardware, while benefiting from the economies of scale and liveness guarantees of a decentralised network of provers.

The future of ZK development is sovereign, modular and coordinated.

The Succinct protocol addresses several structural weaknesses inherent in monolithic approaches to zero-knowledge (ZK) applications, providing a more flexible and sustainable framework for developers.

The lack of standards in current ZK applications forces developers to learn custom tooling and integrate bespoke solutions, which creates friction in adoption and imposes vendor lock-in. Succinct alleviates this by offering unified tooling and workflows that allow developers to retain sovereignty over their use of ZK technology. This means they can easily switch between different ZK providers without being tied to a specific vendor’s tools or methods.

The ZK field of study is rapidly evolving, with continuous algorithmic breakthroughs and engineering improvements significantly enhancing prover efficiency. Keeping production environments up to date with the latest advancements can be cumbersome and expensive. Succinct’s support for any proof system allows developers to use the most suitable proof system for their needs and modularly upgrade to the latest technology as it becomes available. This ensures that applications can remain at the cutting edge of performance and efficiency without incurring excessive overhead.

Teams like Celestia, Avail, Polygon and Eigenlayer are already integrating the Succinct Protocol into their own platforms. Recognizing that there won’t be a single proof system to dominate the future, Succinct’s proof-system agnostic utilities and tooling are designed to benefit all ZK teams through a shared infrastructure. This coordinated approach fosters diversity and innovation within the ZK ecosystem, ensuring that various proof systems can coexist and evolve together, leveraging the shared resources and advancements made possible by Succinct.

Conclusions

Succinct Labs offers a strong lineup of solutions for developers to integrate zero-knowledge to their applications without the need to learn a new collection of mathematical paradigms and domain specific languages. Writing plain Rust and getting a proof “out of the box” can certainly feel like magic.

A lot of benchmarking remains to be done, in order to further understand the UX limitations of generating proofs on the client side and with a prover network, as well as the economic limitations of storing and verifying proofs of chain for real world solutions in production environments. But the growing ecosystem of on-chain verification services could also dramatically reduce the cost and complexity of the full flow of executing, proving & verifying logic using zkVMs.