Noir Language Documentation

Noir provides a standard library of cryptographic primitives that can be used directly in your circuits. These primitives are being progressively added to the language.

Important Note on Backends: Some cryptographic methods are implemented via the Aztec backend rather than being performed natively using Noir code. If you switch to a different backend, these specific methods may not be available. Always verify backend compatibility when relying on specific cryptographic functions.

The ACVM crate is structured into two main functional areas:

• compiler/: Handles circuit compilation and optimization.
• pwg/: Responsible for partial witness generation (PWG).

The ACVM (Abstract Circuit Virtual Machine) repository is organized into several specialized components that handle circuit representation, execution, and serialization:

• acir/: Defines and implements the Abstract Circuit Intermediate Representation (ACIR).
• acvm/: Implements the ACVM, which is responsible for executing ACIR.
• brillig/: Defines and implements unconstrained Brillig opcodes.
• brillig_vm/: Implements the Brillig VM, which is responsible for executing Brillig.
• msgpack_tagged/: Provides a tagged-map serialization format designed for evolvable bytecode (used in conjunction with the msgpack_tagged_derive proc-macro).

ACIR (Abstract Circuit Intermediate Representation) serves as the bridge between high-level frontends (like the Noir programming language) and low-level proving systems (like Aztec's Barretenberg).

It provides a generic, open-source intermediate representation that is agnostic to specific proving systems. ACIR bytecode acts as the link between the output of a compiler (e.g., Noir) and the input required by a proving system backend.

Key components include:

• Abstract Circuit: A computation model where gates (opcodes) are connected by wires (witnesses). It is represented as a Directed Acyclic Graph (DAG).
• Intermediate Representation: The bytecode that translates user-specific computations into a format suitable for proving systems.

A CtString is a compile-time, dynamically-sized string type used within comptime code. Unlike str<N> or fmtstr<N, T>, the size of a CtString does not need to be specified in its type. This makes it ideal for general string handling or formatting items at compile-time where the final length is unknown.

You can leverage the formatting capabilities of fmtstr by formatting into a fmtstr first and then converting the result into a CtString using the AsCtString trait.

A vector is a dynamically-sized view into a sequence of elements. They can be resized at runtime, but because they do not own the underlying data, they cannot be returned from a circuit.

Vectors can be treated as arrays without a constrained size. In Noir, the syntax @[..] is used to create an immutable, growable vector. To write a vector literal, use a preceding at sign, such as @[0; 2] or @[1, 2, 3].

fn main() -> pub u32 {
    let mut vector: [Field] = @[0; 2];

    let mut new_vector = vector.push_back(6);
    new_vector.len()
}