Zero Knowledge Development Kit

[chancehudson]

ZKDK (Zero Knowledge Development Kit)

Summary

This proposal describes a development kit for analyzing and optimizing Noir programs. It includes editing, compilation, analysis, deployment, and instructional/learning features. It's designed to make the Noir/ACIR/Brillig/witness systems more transparent.

Motivation

Zero knowledge programs, similarly to smart contracts, are difficult to intuitively understand and build. This is because zk programs don't execute like traditional programs and must generally be used as components in a larger structure. This is not helped by the complex nature of setting up build tools, compiling circuits/witnesses, and generating/verifying resulting proofs. Further, optimizing circuits can be extremely unintuitive depending on the underlying arithmetization.

The Remix IDE does a good job of simplifying smart contract development and providing high value tools such as a debugger, gas estimator, transaction analyzer, etc.

A similar piece of software specifically for zero knowledge programs could introduce new developers to Noir, as well as act as a debugging/optimization tool for existing developers.

Prospective users

1. Circom developers

As someone who initially learned ZK development using Circom, I find languages like Noir confusing because it's unclear what is being constrained. I understand that everything is being constrained - that's the whole idea. But this abstraction can in some cases be offputting to the security/vulnerability minded Circom developer. My biggest complaint is the lack of transparency in Noir compilation, which seems to purely be an issue of tooling. I need to see the constraints to believe they are there.

2. Cryptographers

Cryptographers that are implementing new proving systems need tools for working with ACIR. Having a playground, and possibly a grammar, for the IR may help develop mental models and make integrating Noir with emerging proof systems more approachable.

Methodology

This project will be authored in Rust using the Dioxus framework. It will target web and all desktop platforms.

ZKDK aims to be a development kit, not an IDE. We want developers to learn, debug, and optimize using ZKDK, but author their code in a separate, proper, editor. ZKDK will have rudimentary editing abilities, but will NOT focus significant effort to become an IDE.

Instead this project aims to be a collection of developer tools which should include, but not be limited to:

• ACIR viewer
• Flamegraph viewer
• Documentation generator
• Witness generator/viewer
• Malicious witness generator/editor/explainer
• Puzzles/learning tools (e.g. take a program and find the best optimizations)
• Smart contract verifier generator

The project will include a file tree that can be loaded from a git url. On desktop this file tree may be bridged to the local system for direct file editing/observation.

All software will be licensed as either MIT or Apache-2.0. Independent modules will be broken out into reusable packages wherever possible.

Business Model

The web implementation will be hosted as a purely static website using Cloudflare workers. This should scale to > 10,000 daily active users without additional cost.

This project could be built into a SaaS CI integration that runs tests, generates documentation, ACIR, dependency analysis, etc. specifically for Noir. ZK packages may be complex/niche enough to justify having a CI service specifically for them. Customers would pay for the CI execution and storage/hosting of artifacts.

Timeline & Deliverables

All deliverables are assumed to be for all platforms (web and desktop) unless otherwise stated.

Month 1

• Functional UI
• Ability to load a project from Github or local file system (desktop only), view/edit files, save files (only on desktop)
• Watch for changes to files
• Functional prover
• Noir syntax highlighting

Month 2

• ACIR viewer
  • Constraint visualizer
  • Brillig function visualizer
  • Show where/how constraints are applied
  • Click to navigate to source
• Split screen editor/ACIR viewer
  • Updates in real time as edits are made

Month 3

• Witness visualizer/editor
• Visualize what fields are constrained
• Automatic malicious witness generator
  • Possibly by static analysis
  • Tests using unsafe Noir code
• Flamegraph generator

Month 4

• Inline documentation parser/visualizer
  • docs.rs type html generator for Noir circuits
• Functional/tested example snippets
• Hosting system (local)

This is designed as a prelude to a proper package manager.

Month 5

• Solidity verifier generator
• Deploy to testnet using metamask
  • Use walletconnect on desktop?
• Generate a proof and verify onchain
• General purpose contract deployment?

Month 6

• Puzzles/learning tools for ACIR/witnesses
• Overrun time for previous months/unspecified features

Team

Chance Hudson - former PSE engineer

Relevant experience: ashlang-ide, a web editor for a custom DSL (ashlang) designed to express R1CS programs. This implementation uses egui for rendering which I suspect will be inferior to Dioxus (for this particular use case).

Start Date

June 1, 2025

Questions

1. Are there any existing thoughts about inline documentation in Noir programs? e.g. for constructing something like docs.rs?

2. Is there an existing syntax/grammar for ACIR (e.g. assembly-ish)? Similar question for Brillig? It may be helpful to define a grammar that can be used to parse the IR/opcodes for external execution engines/provers.

[Savio-Sou]

Hi @chancehudson, thank you for submitting the proposal!

Re your questions:

Not for Noir programs, but we have started inline documenting Noir itself (e.g. ACIR, Brillig, compiler): https://noir-lang.github.io/noir/docs/acir/index.html.

We don't have grammar for ACIR and Brillig, but see if the docs above is helpful and feel free to open Issues for things unclear / under-explained!

[Savio-Sou]

Re the project itself:

Am I understanding it correctly that the project would be a suite of developer tooling that includes:

• ACIR viewer
• Flamegraph viewer
• Documentation generator
• Witness generator/viewer
• Malicious witness generator/editor/explainer
• Puzzles/learning tools (e.g. take a program and find the best optimizations)
• Smart contract verifier generator

which works both in a web browser and on CLI?

If yes:

1. For features already existing (e.g. flamegraph, witness gen, smart contract verifier gen), great if you could elaborate on how ZKDK differs
2. For new features (e.g. ACIR viewer, malicious witness gen), great if you could elaborate on how they will work, perhaps as user journeys if helpful

That should help sharpen up the proposal further!

[chancehudson]

Yes, it would include those things, but would run not necessarily from the CLI, but from an application.

For features already existing (e.g. flamegraph, witness gen, smart contract verifier gen), great if you could elaborate on how ZKDK differs

It doesn't really. For the flamegraph it would look nearly identical. The witness gen output might be presented slightly differently, but would work internally the same. The selling point here is integrating it into a single UI so developers can discover tools they may not have otherwise discovered.

For new features (e.g. ACIR viewer, malicious witness gen), great if you could elaborate on how they will work, perhaps as user journeys if helpful

I may have given the wrong impression listing all the features as equal line items. My intention was to focus mostly on ACIR and witness tooling, with things like the existing flamegraph/smart contract generators thrown in as quality of life improvements. I want to make the compilation pipeline much more transparent so developers can more easily understand the arithmetization of the code they are writing. I think this will yield more performant circuits with fewer vulnerabilities.

For the ACIR viewer, I was imagining a tab that auto-reloads when files are edited. A user would have their project open in an IDE in one window, and the ACIR viewer in another. As the user edits their code the ACIR is automatically rebuilt with changes being highlighted or auto-scrolled to. Part of the deliverable should include a bespoke method of visualizing ACIR in a human readable way.

The malicious witness gen must be built after the ACIR tooling. I'm imagining an implementation that uses back substitution to solve constraints. The user may set certain witness values (e.g. provide fixed inputs/outputs/intermediates) and have the program search for solutions. It would be nice to show which values are dependent on others. Another approach might involve taking a valid witness and looking for values that can be mutated while keeping others fixed. Again, this will take some experimentation to find something actually useful. Part of the deliverables could include a simple lattice based signature implementation in Noir (e.g. Dilithium). This would be a good circuit to experiment with.