Noir

Noir adopts a syntax heavily inspired by Rust, lowering the barrier to entry for developers already familiar with systems programming. This design choice abstracts away the underlying arithmetic circuit compilation, allowing developers to focus on application logic rather than cryptographic primitives.

• Familiar constructs: Uses let bindings, fn declarations, and generics
• Type safety: Enforces strict typing with u32, u64, Field, and custom structs
• Control flow: Supports loops, conditionals, and mutable variables within circuit constraints

Noir compiles programs into zero-knowledge circuits that generate proofs of correct execution without revealing private inputs. The prover demonstrates knowledge of satisfying inputs while keeping sensitive data—such as identity credentials or financial records—completely hidden from verifiers.

• Private inputs: Marked with the pub keyword distinction; non-public values remain secret
• Proof generation: Integrates with backend proving systems like Barretenberg
• Verification: Produces succinct proofs verifiable on-chain or off-chain in constant time

Noir separates its frontend language from the cryptographic backend, enabling developers to write a circuit once and prove it using different proving systems. This decoupling future-proofs applications against advances in proof technology.

• Current backends: Barretenberg (Aztec's native proving system)
• Pluggable design: Supports integration with different Polynomial Commitment Schemes
• Proof system flexibility: Can target both ZK-SNARKs and ZK-STARKs without rewriting circuit logic

Noir ships with a comprehensive standard library providing cryptographic primitives, hash functions, and data structures commonly needed in zero-knowledge applications. The toolchain includes a package manager, testing framework, and debugger.

• Cryptographic primitives: Built-in Pedersen hashes, Merkle tree implementations, and signature verification
• nargo: The Noir package manager and build tool, analogous to Cargo in Rust
• Testing: Supports unit tests and integration tests with witness generation
• Debugger: Interactive debugging with breakpoints and variable inspection

Noir is designed for seamless integration with Ethereum Virtual Machine ecosystems and other blockchain networks. Generated proofs can be verified by smart contracts, enabling private transactions, confidential DeFi, and identity solutions.

• Solidity verifier generation: Automatically produces EVM-compatible verifier contracts
• Aztec Network integration: Native support for private smart contracts on Aztec's Layer 2
• Cross-chain proof verification: Succinct proofs can be verified across multiple settlement layers

Noir supports recursive proof composition, where one proof attests to the validity of multiple previous proofs. This enables proof aggregation and compression, dramatically reducing on-chain verification costs for complex multi-step computations.

• Proof aggregation: Combine multiple independent proofs into a single constant-size proof
• Incremental computation: Build Proof-Carrying Data structures for long-running computations
• Scalability: Reduces amortized verification cost to near-constant time regardless of computation depth

Prove attributes about yourself without revealing the underlying data. Noir circuits enable anonymous credentials where a user can prove they are over 18, a citizen of a specific country, or a member of a DAO without exposing their exact birthdate, passport number, or wallet address.

• Selective disclosure: Reveal only the minimum necessary information
• Sybil resistance: Prove unique personhood without linking to a real-world identity
• Composability: Noir proofs can be verified on-chain via Aztec or any compatible verifier

Execute complex business logic off-chain and generate a succinct proof of correct execution that anyone can verify. Noir acts as the proving layer for zk-oracles, verifiable AI inference, and provable database queries.

• zkML integration: Prove a model inference ran correctly without revealing weights
• Provable API responses: Verify that an oracle correctly transformed raw data
• Recursive proof aggregation: Combine thousands of proofs into one constant-size proof

Enable censorship-resistant voting where ballot choices remain secret but tallies are publicly verifiable. Noir circuits ensure one-person-one-vote integrity, correct tally computation, and eligibility proofs without linking voters to their selections.

• Ballot secrecy: Individual votes are cryptographically hidden
• Public verifiability: Anyone can confirm the final tally is correct
• Eligibility proofs: Prove membership in a voting group without deanonymization

Build provably fair games where hidden state and randomness are cryptographically guaranteed. Noir enables fog-of-war mechanics, sealed-bid auctions, and card games where hands remain private until revealed.

• Commit-reveal schemes: Players commit to actions without exposing them
• Verifiable shuffle: Prove a deck was shuffled fairly without revealing card order
• Anti-collusion: Game state integrity enforced by validity proofs, not trusted servers

Enable organizations to prove compliance with regulations without exposing sensitive internal data. A supply chain partner can prove an audit passed, a bank can prove capital adequacy, or a healthcare provider can prove HIPAA compliance—all without revealing the underlying records.

• Zero-knowledge audits: Prove regulatory thresholds are met without data export
• Cross-entity computation: Joint analytics across competitors without data pooling
• Tamper-proof attestations: Cryptographic proof that a report was generated correctly