OpenViSTAI · Agents · Blockchain · Crypto
Submit a project
Menu
ZK & Privacy

Stark Snark Recursive Proofs

Stark Snark Recursive Proofs is a Rust library and set of proof-of-concept examples for combining Winterfell-generated STARKs with Circom and Groth16 SNARKs in recursive proof workflows.

Explore the practical guide ↓

Independent OpenViST project profile, based on linked sources.

Stark Snark Recursive Proofs — OpenViST project profile in ZK & Privacy.
OpenViST project illustration. See the linked sources for product details.
Understand the project

Practical overview

When it fits

Use it when prototyping or studying a combined STARK/SNARK workflow and when you need a small example that covers circuit compilation, proof generation and verification.

Who it is for

  • Rust developers exploring recursive zero-knowledge proof compositions.
  • Developers who want to study a worked proof-generation and verification workflow using Winterfell, Circom and Groth16.

Documented uses

  • Build and compile a Circom circuit and generate circuit-specific keys for the example.
  • Generate a recursive STARK-SNARK proof for the sum-of-integers example.
  • Verify a previously generated example proof.
  • Adapt an algorithm by implementing proof options, public inputs, a Winterfell AIR, and a Prover.
Before you choose

Requirements & limits

The repository is public and lists an MIT license.

  • The implementation is in Rust and uses Winterfell, Circom and Groth16.
  • A phase-one Powers of Tau transcript named final.ptau must be placed in the workspace root before proceeding.
  • Circuit compilation generates circuit-specific keys and is required before proving or verifying; repeat it if proof options change.
  • The included sum example is presented as a proof of concept, not as a general-purpose application.

Check current requirements in the official documentation. Source-based guidance does not mean OpenViST has run or independently tested this project.

Source-based practical guide

Build and verify the sum proof example

Run the documented example stages for compiling the sum circuit, generating a recursive proof, and verifying it.

Before you start

  • A Rust/Cargo environment for the repository’s example crate.
  • A phase-one Powers of Tau transcript named final.ptau in the workspace root.

Steps

  1. Build the example with the command below.

    Documented command
    cargo build --release -p example-sum

  2. Compile the circuit and generate its circuit-specific keys with the command below.

    Documented command
    cargo run --release -p example-sum --bin compile

  3. Generate the recursive proof with the command below.

    Documented command
    cargo run --release -p example-sum --bin prove

  4. Verify the previously generated proof with the command below.

    Documented command
    cargo run --release -p example-sum --bin verify

Expected outcome

A generated proof for the sum example that can be checked by the example’s verify executable.

Guide limitations

  • The compile stage must precede prove and verify.
  • Compile again whenever proof options change.
  • The repository documents the required transcript but does not guarantee the availability of its linked download.
Documentation 1 ↗
Evidence and transparency

Sources & review

Official repository ↗
Source record details
Source availability
Active
Sources checked
17 October 2026
Original website title
VictorColomb/stark-snark-recursive-proofs · Official homepage title · retained in its source language
How we review sourcesSuggest a correction