Dev tools · alternatives · 2026
24 alternatives to I Built a Groth16 ZK-Proof Verifier from Scratch Using Rust
I've always been fascinated by cryptographic principles, so I decided to dive deep into zero-knowledge proofs and implement a Groth16 proof verifier entirely in Rust. This project validates cryptographic proofs and demonstrates how succinct, verifiable computations can be achieved. Using Rust's powerful libraries like arkworks, I implemented pairing checks, public input commitments, and proof validation logic while ensuring the code remains modular and efficient. I handled the complexities of affine group operations, scalar multiplications, and optimized public input verification to make…
Below are 24 products that do a similar job, ranked by how close each is in meaning and then by launch-day votes. I Built a Groth16 ZK-Proof Verifier from Scratch Using Rust launched in 2024; newer entries below may have overtaken it.
- 1

Hi HN, We (myself, Adhyyan1252 and yush_g) are undergrad students that hacked out this side project last month during Hack Lodge[1] (the ideas and many of the underlying circuits for which came from the 0xPARC community[2])! We’re extremely excited to share this new primitive. Besides the technical challenges building this project that folks here would find interesting (fixing the ZK proof compiler, modifying nodeJS V8 params etc.), we think this is a very novel use case for ZK tech, and ECDSA inside ZK-SNARKs is a starting point that unlocks many other ideas! :D A summarized version of our…
2022 · github.com · its alternatives →
- 2

VEKOS(Verified Experimental Kernel OS) is a Rust-based experimental kernel that focuses on runtime verification and security. Every filesystem operation and memory allocation generates cryptographic proofs that can be verified in real-time, ensuring system integrity. Think of it like a blockchain for OS operations rather than just storage verification. Key features: - Merkle tree-backed filesystem with operation verification - Memory manager with CoW and proof generation - Buddy allocator with zone-based memory management - Shell with VT100 support - Verified boot sequence with stage…
2024 · github.com · its alternatives →
- 3

Zero-Knowledge Proofs (ZKPs) let an untrusted proved show that computation was executed correctly without revealing the inputs to the verifier. However to prove anything, the computation first has to be expressed as a circuit: a system of polynomial equations (constraints) over a finite field. Circuits are the assembly language of zk and every constraint costs prover (and sometimes verifier) time, so production circuits are aggressively hand-optimized. Over the last months, we have been experimenting with writing formal specifications instead and letting LLMs produce the circuits: as long as…
Jul 2026 · zk.golf · its alternatives →
- 4

A pipeline that translates Rust GPU code into formal Coq models, as a foundation for memory model proofs - neelsomani/vericuda
Oct 2025 · github.com · its alternatives →
- 5

"Game" is a stretch, but I put together this repo containing a pure Rust app which uses SDL2 and compiles to WASM (and can be run in a browser). Older resources were a bit out of date and a bit too verbose for my purposes, so here's a minimal working example.
2024 · github.com · its alternatives →
- 6

This is a project I made to learn more about crypto. I've also written a [post](https://vaktibabat.github.io/posts/ecurvechat/) that explains all the crypto concepts and algorithms used in the project, and how I implemented them. I'd be very glad for any feedback about both the code and the post :)
2024 · github.com · its alternatives →
- 7

I was learning ZK proofs and found that visualizing things really helped me understand them. Noticed there aren't many interactive visualizations out there, so I built one. Here's the first version: zkvisualizer.com It walks through the full pipeline step by step (Problem → Circuit → R1CS → Polynomials → Witness → Proof → Verification) with real Groth16 proofs generated in your browser using snarkjs. You can toggle between what the prover knows vs what the verifier sees, and there's a tamper detection demo where you can watch verification fail. This is still very early on, but I would be…
Jan 2026 · zkvisualizer.com · its alternatives →
- 8

2018 · sterlingdemille.com · its alternatives →
- 9

Please tell me your opinion
2024 · crates.io · its alternatives →
- 10
Rust 1.0▲6A high-level, safe and concurrent alternative to C++
2015 · rust-lang.org · its alternatives →
- 11

2017 · github.com · its alternatives →
- 12

Here is the protocol worklow. Let us define g as the generator of the multiplicative cyclic group G of order q. Let us define p = 2q + 1 (a safe prime). The values p, g, a1, b1, c1 are publicly available to the prover and the verifier. a1 = g^a mod q b1 = g^b mod q c1 = g^ab mod q where a and b are cryptographically secure randomly generated numbers. prover wants to prove he knows a secret x. the prover computes y1 = g^x mod q and y2 = b1^x mod q. the prover sends y1 and y2 to the verifier. The verifier then computes a challenge value s and sends it to the prover. the prover then computes z…
2025 · github.com · its alternatives →
- 13

Hello. I made this project as an experiment in using key cryptography for user identity in a client server model, and for some future peer to peer projects that I am working on. I am looking for feedback, please let me know what you think. Also, Merry Christmas to HN! :-)
2022 · github.com · its alternatives →
- 14HA
Most ZK proving systems are optimized for server-grade hardware with massive RAM. When scaling to industrial-sized traces (2^20+ rows), they often hit a "Memory Wall" where allocation and data movement become a larger bottleneck than the actual computation. I have been developing Hekate, a ZK engine written in Rust that utilizes a Zero-Copy streaming model and a hybrid tiled evaluator. To test its limits, I ran a head-to-head benchmark against Binius64 on an Apple M3 Max laptop using Keccak-256. The results highlight a significant architectural divergence: At 2^15 rows: Binius64 is faster…
Jan 2026 · its alternatives →
- 15

Hi everyone, wanted to share about gline-rs, an inference engine for GLiNER models written in Rust. This family of lightweight language models proved to be efficient at zero-shot Named Entity Recognition (NER) and other tasks such as Relation Extraction, while consuming less resources than large generative models (LLMs). This implementation has been written from the ground up in Rust, and supports both span- and token-oriented variants (for inference only). The goal is to provide a production-grade and user-friendly API in a modern and safe programming language, including a clean and…
2025 · github.com · its alternatives →
- 16

A unified, high-performance data validation and serialization framework for Rust, inspired by Pydantic's ergonomics and powered by Serde.
Mar 2026 · github.com · its alternatives →
- 17

2024 · maelstrom-software.com · its alternatives →
- 18

My cofounder and I run a startup in oncology, where we handle cancer genomics data. It occurred to me that, thanks to a recent complexity theory result, there's a clever way to run bioinformatics algorithms using far less RAM. I built this Rust engine for running whole-genome workloads in under 100MB of RAM. Runtime is a little longer as a result - O(TlogT) instead of O(T). But it should enable whole-genome analytics on consumer-grade hardware.
Nov 2025 · github.com · its alternatives →
- 19

High-level RealSense library in Rust
2021 · gitlab.com · its alternatives →
- 20

My friend and I have been collaborating on this lighthearted introduction to doing geospatial computation in rust. Don't know Rust? Don't know geospatial? I'd be interested to know what you think.
2022 · book.georust.org · its alternatives →
- 21

NuCypher fully homomorphic encryption (NuFHE) library implemented in Python - nucypher/nufhe
2018 · github.com · its alternatives →
- 22

A native Rust library for Delta Lake, with bindings into Python - delta-io/delta-rs
2022 · github.com · its alternatives →
- 23

A zero dependency implementation of Shamir Secret Sharing in pure Go - GitHub - openfort-xyz/shamir-secret-sharing-go: A zero dependency implementation of Shamir Secret Sharing in pure Go
2024 · github.com · its alternatives →
- 24

Hi HN! I've been building a project that handles high-value credentials in-process, and I wanted something more robust than just zeroing memory on drop. A comment on a recent Show HN[0] made me realize that awareness of lower-level memory protection techniques might not be as widespread as I thought. The idea here is to pull out all the tools in one crate, with a relatively simple API. * mlock/VirtualLock to prevent sensitive memory from being swapped (eg the KeePass dump) * Core dump exclusion using MADV_DONTDUMP on Linux & Android * mprotect to minimize exposure over time * Guard…
Mar 2026 · github.com · its alternatives →
Also compare
- StealthDrop – Anonymous crypto airdrops using zero-knowledge proofs alternatives
- Vekos – a Rust OS with Built-In Cryptographic Verification alternatives
- zkGolf – Competitive optimization of formally verified circuits alternatives
- Cuq – Formal Verification of Rust GPU Kernels alternatives
- A minimal working Rust / SDL2 / WASM browser game alternatives
- An Elliptic Curve-Based Secure Chat, Written Using Rust and Protobuf alternatives
Ranked by how close each launch is in meaning, then by votes. Prices were read from each product’s own site when checked and can change. Refine with your own description →