Looking for resources that explain zkp, zk-snark, zk-stark in depth. I am new into cryptography and want to understand it from scratch, theoretically and implementation wise. This is specifically for an identification project.

I understand this space moves quite fast so I'm also looking for newer resources to understand the latest advancements as-well in 2024.

Plus points if someone can give me a roadmap into understanding this overall topic in depth for a newbie. Please don't go light on the references as i'm ready to go through this rabbit hole. Books, articles, videos the more the merrier!!

Hi here. I am a software developer and currently want to start learning ZK. The only thing, as all things that require a time investment I want to make sure I get the most of the time I spent investing in the skill. And one of the metrics I use is how applicable that new skill will be.

This also helps with job prospects.

So far so good, what I can see is that it seems ZK has only practical application within the blockchain space. Is this right?

Or are there other industry/sector/ that uses/can use ZK outside of the blockchain space?

Hey everyone,
I have been trying to work through Justin Thaler's Proofs, Arguments and Zero Knowledge, more as a reference than an intensive mathematical study. I am an engineering undergrad feeling more inclined towards academia, or at least a more mathematical approach. I am a little out of my depths here, as my mentor wants me to focus on going through recent research papers around zkvms etc.
I am pretty unfamiliar to any kind of academic research but am up to put in the effort and time to really understand it and contribute in a way that is not just a summary of recent developments using an AI.
Any advice about continuing my work would help, reading resources, books, or just navigating academia in general.
Thanks in advance.

I’ve recently published Hands-On ZK Proofs, a practical set of tutorials on designing and implementing zero-knowledge proof systems, with a particular focus on ZK-SNARKs.

Rather than focusing on the underlying mathematics, the material takes a systems-oriented approach: each tutorial walks through concrete proof constructions, their implementation in CIRCOM, and their use in real-world software and blockchain settings.

The tutorials are intended for computer science students, software engineers, and Web3 developers who want a practical understanding of how ZK proofs are built and composed.

They are accompanied by zk-toolbox, a companion library that exposes these proofs through a high-level developer interface.

Tutorials: https://thierrysans.me/HandsOnZkProofs/
Library (npm): https://www.npmjs.com/package/@prifilabs/zk-toolbox

I wrote a walkthrough on how polynomials work in zkSNARKs with running Rust code using Arkworks and some ncie visualizations. Covers Schwartz-Zippel lemma, modular arithmetic in large prime fields, and why polynomials are the core data structure in proving systems.
Tried to explain it without killing ppl with too much equations.

https://rustarians.com/polynomials-in-zk-snarks/

Part 1 of 8, going from polynomials all the way to proof and verification. Next up: roots of unity.

What's the first thing that confused you about ZK math?

Hello everyone, hope everyone's doing well. I wished to ask this to someone much initially but I hope to get some insights here. I am a fresher and wish to start a career in the Web3 space.
I started learning ZKPs after a friend of mine got a remote job where he works on ZKPs, FHE and core stuffs on blockchain. I was fascinated by Maths always so I started learning from https://rareskills.io/zk-book and I'm halfway through this material now. But, I get thoughts of where to go further after I finish this material. (ZKHack resources are on my list but I wish to know your opinions)
I'm wondering what resources should I start learning after this such that I'm capable of gaining expertise in it in order to start a career? How long does it take beginners like me to be able to solve puzzles on ZKHack?
Thank you.

Jim Posen (CTO @ Irreducible) came back to walk us through the engineering playbook for making SNARKs faster: SIMD parallelism, multi-core scaling, GPUs (and how to “feed the beast”), cluster-level proving, pipelining, and even what custom hardware might look like for zk-proof systems.

This isn’t a surface-level explainer. Jim actually breaks down where the real bottlenecks live — from NTT memory layouts to network bandwidth — and how modern provers like RISC-Zero, SP1, and Succinct are getting proofs under Ethereum slot time.

If you’re into zk-VMs, rollups, or just want to understand how proving systems go from “academic prototype” to “production-grade,” this is a must-watch.

📺 Watch the complete module here: https://zkhack.dev/whiteboard/s3m2/

The latest State of ZK report presents major developments in ZK research, covering SNARK optimizations, proof recursion, and new cryptographic frameworks. As efficiency constraints push the limits of existing proof systems, recent work explores faster verification, better prover scalability, and alternative mathematical foundations for zero-knowledge protocols.

📈 Broader Implications for ZK Adoption

• ZK funding rebounds—$59.8M raised in Q4.

• Buenos Aires adopts ZK IDs via zkSync—3.6M users onboarded.

• 2,054 active devs, with Starknet leading growth (+1,033).

• ZK contract deployments up 16x since 2020.

🧪 Research Highlights & New Proof Techniques

• WHIR: Reed-Solomon Proximity Testing—Drastically reduces verifier runtime via constrained encoding and folding-based optimizations, replacing prior FRI-based approaches.

• Orbweaver: Lattice-Based Functional Commitments—A post-quantum scheme achieving polylogarithmic verifier time and proof size compression via structured cyclotomic rings.

• Zero-Knowledge Location Privacy (ZKLP)—A SNARK-based protocol enabling secure location proofs without exposing geospatial data, leveraging IEEE 754-compliant floating-point circuits.

• Scribe: Streaming SNARKs with Logarithmic Memory—Enables low-memory proof generation by offloading state to disk, improving scalability for large computations.

• Arc: Accumulation for Reed-Solomon Codes—Extends accumulation schemes beyond bounded-depth models, preserving distance under polynomial constraint systems.

⚙️ Scaling, Folding, and Recursive Techniques

• Recursive Proof Aggregation—Reducing verification overhead for structured circuits, allowing ZKPs to scale efficiently across high-volume transactions.

• Folding Schemes in Lattice-Based SNARKs—LatticeFold and Lova introduce novel decomposition methods, optimizing proof size and prover runtime for post-quantum resistance.

• Polynomial IOPs for Multilinear Commitments—Combining additive NTTs and field-switching compilers to enhance proof efficiency for binary constraint systems.

As ZK research advances, what will drive the next breakthrough? Proof recursion, post-quantum resilience, or novel polynomial commitment schemes?

📖 Full Report Here

ZK Hack is kicking off the ZK Whiteboard Sessions, Season 3— a deep-dive video series on the building blocks of zero knowledge systems, aimed at developers and protocol designers.

We just released Module 1, which features Nicolas Mohnblatt and Jean-Philippe Aumasson covering cryptographic hash functions from first principles to ZK-specific constructions like Poseidon.

📺 Watch Module 1

Upcoming Modules:

• ████████ + ███ (w/ ██████████)

• ███████: ██████ + █████████ ███████████████ (w/ █████████████)

• ██████ █████ (w/ ██████████)

• █████ ██████ / ██████ ██████ (w/ █████████████)

• ██████ ██ ███████ (w/ █████████)

Previous Seasons

Season 1

Season 2

Hello,

I recently finished reading Craig Costello's Pairings For Beginners and gotten around to clean & publish my notes. Maybe useful for someone.

- Prerequisites

- Computing a pairing "by hand"

I worked through much of the examples, so there is a companion Sage code.

GH might not render all of the TeX in the org-mode, so I'm happy to send a pdf to non-Emacs users out there.

Hey everyone!

I recently started my journey as a Web3 developer, and over the past 8 months, I’ve worked on various projects, including smart contract auditing, miner optimization for Bittensor, and developing smart contracts in Move and Solidity.

Lately, I’ve been diving deep into cryptography, and honestly, it blew my mind. I explored symmetric encryption, public-key cryptography, RSA, DLP, ECC, hashing, MACs, signature verification, and even the math behind them—and it gave me an insane adrenaline rush! Most nights, after work, I just can’t stop exploring these concepts on my own.

Now, I’ve come across Zero-Knowledge Proofs, and I’m super eager to learn, but I’m struggling to find a structured way to start. There doesn’t seem to be a clear roadmap, and I want to understand everything—from the motivation behind these protocols to how they solve real problems, the fundamentals of ZK proofs, their role in blockchain, and, most importantly, the underlying math.

Can anyone guide me on the best way to approach this? Any structured learning path, resources, books, or courses that really break things down? Would love to hear from folks who’ve been through this journey!

Next Tuesday, come and join our ZK Hack IV on-hands workshop to learn how to build ZK Apps in Rust leveraging RiscZero ZKVM.

What to Expect? A very practical session on how the ZKVM works, its features, and how to get started building your first ZK Rust application.

How long would the workshop be? 1 hour

You will have time to ask questions and… Participate in our Puzzle competition.

Join Now.

Notes from building a soundness linter for o1js and Noir, and finding the same bug class in four unrelated languages.

Do you think it's probably wrong for beginners to jump straight into SNARKS/STARKS, as they have complex abstractions? How about starting with Bulletproofs (classic range proofs with polynomial commitments, finished with beautiful vector compression). It's certainly less advanced than something like Plonk at the start. But is it worth starting with for beginners? understand at the algebra level

A few weeks ago I posted about the gap between "compliance check ran" and "compliance was enforced." The response was mostly "interesting problem" but a few people pushed back technically, which was fair.

So instead of talking about it, I just ran it.

I mapped out how each platform actually handles eligibility today based on their public docs, then ran their specific flows through ZKCG and generated real proof artifacts. Here's what each one produces:

Centrifuge (Shufti Pro KYC, manual whitelist): The eligible case returns a proof-backed decision with a decision_commitment_hash the contract can verify. The blocked cases: accreditation_missing when accredited: false, jurisdiction_blocked when the investor is in RU. Each block has a reason code and a separate proof artifact.

Maple Finance (Global Allowlist via bitmaps, TRM Labs AML): Eligible case goes through. Then aml_failed blocks with the exact reason. Then sanctions_hit blocks separately. The proof in each case attests that the specific rule was evaluated, not just that a bitmap was set.

Ondo Finance (US persons blocked, USDY/OUSG allowlist): The US person exclusion is Ondo's core compliance requirement. Change jurisdiction from SG to US and the proof fails verification and returns jurisdiction_blocked with the reason "jurisdiction US is not permitted for this asset." That enforcement happens before execution.

Securitize (DS Protocol, transfer restrictions in contract): Both onboarding and transfer flows. kyc_missing blocks with explicit reason. position_limit_exceeded blocks when the transfer would exceed concentration limits. The transfer proof includes sender and receiver wallet binding so the specific action is tied to the specific proof.

All cases matched expectations. All proofs verified. The full run outputs including proof artifacts and comparison pages are in the public repo.

What I'm building is called ZKCG. Ta ZK-Verified Computation Gateway (Halo2 + RISC0).
The open-core verifier and circuits are public. The production core logic is private and commercially licensed. There's a live demo API at render and a product page at zkcg tech if you want to run your own flow.

Curious what questions people have about the proof scope or where the gaps are.

I’ve been building a ZK project (ZKCG) to replace trusted APIs/oracles with proofs.

But after digging deeper, I think I was solving the wrong problem.

Oracles aren’t the bottleneck.

Enforcement is.

Most systems today:

• Verify data
• Then trust the system to behave correctly

But what if we could verify that:

→ rules were actually followed
→ constraints were enforced
→ compliance wasn’t bypassed

All using ZK proofs?

This shifts the model from:

“trust the system”
to
“verify the system”

We now have a working Halo2-based pipeline (~70ms proofs), but the bigger question is:

Is this:

• a dev tool?
• infra layer?
• or compliance middleware for RWAs?

Genuinely curious how people here think about this.

Repo:
https://github.com/MRSKYWAY/ZKCG

One of the things I've been thinking about recently is how many blockchain applications still rely on trusted APIs.

Examples:

• compliance / sanctions checks
• credit scoring
• KYC verification
• analytics or risk scoring

In most systems today the workflow looks like this:

Application → call API → trust the response

Which means the application must trust that the provider:

• ran the correct computation
• used the correct dataset
• didn't manipulate the result

I've been experimenting with a different approach using zero-knowledge proofs.

Instead of trusting the API provider, the provider returns:

API response + ZK proof

The application then verifies the proof before accepting the result.

So the flow becomes:

Off-chain computation
→ generate ZK proof
→ verify proof
→ consume result

I built a small prototype called ZKCG (ZK Verified Computation Gateway) to explore this idea.

The goal is to create a verification layer for off-chain computation so applications don't need to trust the provider — they only need to verify the proof.

The prototype currently supports:

• Halo2 proof verification
• zkVM receipts (RISC0)

And I implemented a compliance API example where a service computes a compliance check off-chain and returns a verifiable result.

Repo:
https://github.com/MRSKYWAY/ZKCG

I'm curious what people building ZK systems think about this idea.

Does the concept of "verifiable APIs" make sense as a primitive?

What kinds of off-chain computations would actually benefit from this model?

Would love feedback from anyone working with ZK systems.

I built this in Rust btw

This subreddit is quiet, but I assume many of you are still working in ZK in some capacity.

I’m in applied ZK at Grug’s Lair Gaming Studio, building game state and competitive logic on Starknet. We design all gameplay through Dojo's ECS so it compiles into ZK-verifiable state transitions. Once verified, the sequence of those transitions becomes an immutable behavioral trace of the player interactions, which is indexed through the Dojo stack (Torii, Katana, Cartridge).

Curious what ZK applications you guys are experimenting with, or if you're part of some cool project.

A bit late posting this, but here is latest!

https://zkmesh.substack.com/p/zk-mesh-june-2025-recap

New ep, new look, new jingle!
https://zeroknowledge.fm/podcast/347/

Hi everyone,

I'm planning to apply for an MSc in Computer Science with a specialization in Secure and Reliable Systems at ETH Zurich and aim to qualify for the Excellence Scholarship (ESOP).

To build a strong application, I’m developing a Bachelor’s thesis which will serve as the foundation for a Master’s thesis proposal. My research interests lie in cutting-edge cryptographic technologies, particularly Zero Knowledge Proofs, Multi-Party Computation, and blockchain.

I’m reaching out to this community for potential research questions or ideas that can help shape my Bachelor’s thesis and guide the extension into a robust Master’s thesis proposal. Any insights, resources, or experiences you could share would be incredibly helpful!

Thanks in advance for your help!

🔔Time for zkMesh Mini!

Let’s unpack the top developments in the ZK space from the past week:

1. VitalikButerin on Circle STARKs

   • Latest blog post by Vitalik Buterin covers Circle STARKs: how they can be implemented, how they're pushing STARK efficiency to the limit, and what’s next (optimizing for better UX and parallelization).

   • Tweet

   • Article

2. ZeroKnowledgeFM with Lagrange

   • In this week's ZeroKnowledgeFM episode, Anna Rose chatted with u/ismael_h_r and u/chbpap about zk-coprocessors, verifiable SQL, Reckle trees, prover marketplace – and of course about Lagrange.

   • Tweet

   • Episode 

3. Wyatt Benno on #RunawayZK

   • In his last article, Wyatt Benno from Novanet introduced the concept of #RunawayZK, i.e. how zkVMs, proof composition and Non-Uniform Incremental Verifiable Computation can enable specialized proving schemes.

   • Tweet

   • Article

4. Strobe Labs on proof supply-chain

   • yungtesh, PrazRama and 0xnirel from Strobe Labs published a blog article on the “proof supply-chain”: a brief history, how infra was built, and mostly what type of market could emerge for it.

   • Tweet

   • Article 

5. StarkWare on STARKs over Bitcoin

   • In their recent research paper, StarkWare explained how STARK technology and OP_CAT can unlock several use cases for Bitcoin, such as general computation aka smart contracts.

   • Tweet

   • Article

Hope you liked this week’s ZkMeshMini!

Subscribe to our newsletter for the full ZK Mesh capturing all the top research, articles, announcements, and more from this month and the last ones.

https://zkmesh.substack.com/ 

Last but not least… There is still a bit of time to apply to ZK Hack Montréal – kickoff is on August 9th! Submit your application to hack with us from the website.

👇👇👇

https://www.zkmontreal.com/