Noir Circuit Optimizer: Constraint Reduction Tooling for Efficient Proof Generation

[Mikerah]

Summary

We propose developing a Circuit Optimizer for Noir, directly addressing developer pain points related to excessive circuit sizes and proving inefficiencies. The optimizer will apply foundational optimizations (constant folding, dead code elimination, sub-expression elimination) and advanced global optimizations (constraint pruning, custom gate synthesis, backend-specific transformations) to substantially reduce constraint counts. Initially, we will release these foundational optimizations open-source, with more advanced optimizations provided via a sustainable usage-based API. The tool will integrate seamlessly into Noir’s existing compilation pipeline, initially as a CLI tool, subsequently supporting APIs in Rust, JS, TS, and Python, significantly enhancing Noir's usability and accessibility for developers.

Motivation

Noir dramatically simplifies ZK circuit development but the resulting circuits can end up larger than custom designed circuits. This can lead to longer proving times and more time spent optimizing and debugging Noir circuits.
From our past experience with Noir and by speaking with prospective users of Noir, we found this to be a bottleneck in terms of developers wanting to adopt Noir for their own use cases. Previous tools like Circom and Clap have demonstrated the efficacy of systematic optimization methods in significantly reducing constraints. A dedicated optimizer tailored specifically to Noir's PLONKish arithmetic circuits is necessary to address these critical bottlenecks systematically.

Methodology

We will implement a multi-stage optimization pipeline:

• Initial optimizations: constant folding, dead code elimination, linear constraint merging, sub-expression reuse.
• Advanced optimizations: global constraint analysis, custom gate flattening, backend-specific optimizations (UltraPlonk/UltraHonk), lookup table utilization.

The implementation will leverage Rust for core integration and performance, initially providing a CLI tool, followed by exposing APIs via JS, TS, and Python. Rigorous testing and continuous integration will ensure correctness and performance.

Business Model

Our sustainable funding model includes:

• Initial open-source foundational optimizations freely available to the community.
• Advanced optimizations provided via a monetized, usage-based API, ensuring ongoing maintenance, support, and development.
• HashCloak operates as a consulting company; a portion of the revenue from advanced optimizations will directly fund ongoing development and maintenance of the open-source foundational optimizer tool.

Timeline and Deliverables

• Month 1 (June 2025): Planning the architecture and UX of the standalone CLI tool, defining input/output formats and interactions with ACIR files and Noir compiler outputs. Establishing the overall integration model.
• Month 2 (July 2025): Implementation of core optimizations (constant folding, dead code elimination, linear constraint merging).
• Month 3 (August 2025): Implementation of sub-expression reuse and boolean simplification. Early testing and internal benchmarks.
• Month 4 (September 2025): Begin advanced optimization methods (global constraint pruning, gate flattening).
• Month 5 (October 2025): Backend-specific optimizations, lookup table integration, and language API bindings.
• Month 6 (November 2025): Final integration, testing, documentation, public release, and API launch.

Deliverables:

• Integrated open-source Rust Circuit Optimizer.
• Multi-language APIs (JS, TS, Python, Rust).
• Comprehensive documentation and user guides.
• Hosted advanced optimization API.

Team

HashCloak Inc.

• Lead Developer: Alex (Contact: [email protected]). Expertise includes Rust development, cryptographic tooling, and circuit optimizations. Has worked on HashCloak #7523.
• Core Developer: Manish (Contact: [email protected]). Extensive cryptographic tooling and circuit optimization experience.
• Project Manager: Teresa (Contact: [email protected]). Experience managing cryptography and zero-knowledge projects, ensuring timely delivery and project coordination.

Start Date

1 June 2025

Questions

No outstanding questions at this time.

[Savio-Sou]

Hi @Mikerah, thanks for submitting the proposal!

The project sounds very interesting. Intuitively feels like some of the features might exist in the Noir compiler, while some could be immensely powerful, but don't think I understand them enough to tell and share thoughts upon.

Great if the proposal could elaborate on the designs and expected behaviors of the features involved!

[Mikerah]

Hey @Savio-Sou, thank you for the feedback.

Indeed, as any compiler would have, the Noir compiler does do some optimization for a given Noir circuit. However, sometimes, we end up having to optimize the circuit beyond what the compiler itself can provide. It's actually one of the parts that takes us the longest when using Noir.

We plan to essentially adapt current R&D for optimizing Plonkish circuits (e.g. Clap) and do our own research for circuit optimization techniques to integrate into this tool. Our current direction involves looking at logic optimization techniques to see which ones can be applied directly to Plonkish circuits like that of Noir. From this, we aim to provide a basic set of optimization techniques for free. Then for the more complicated techniques, we aim to provide this at an extra cost as these tend to actually take more time to run and incur more of a cost, both in terms of R&D and hardware resources.

Over time, we expect to not only build a circuit optimization tool for Noir but also a benchmarking platform as well.

Please let me know if you have any more questions!

[TomAFrench]

Hey @Mikerah, can you provide some examples of programs which the Noir compiler is currently producing sub-optimal output which you would want to improve as part of this proposal?

[Mikerah]

For example, here: https://github.com/hashcloak/semaphore-noir/pull/2/files, this had to be hand optimized by Maxim.
Another one which you gave Tom is here: https://github.com/hashcloak/noir-mpc-ml/blob/master/src/quantized.nr#L108-L115 where we initially did with conversion to byte array and removing 2 bytes. In both cases, we relied on the expertise of Aztec engineers but ideally these are things that can be given in a more automated fashion.