<aside>
This guide helps you go from setup to launch using Noir and (optionally) Aztec. Use the track-based tips and patterns below to help you through NoirHack.
</aside>
Install Noir's toolkit and (optionally) the Aztec sandbox. Follow the Noir Quick Start guide to install Nargo (Noir's CLI) and a proving backend. If you’re interested in exploring building with Aztec, use the Aztec Sandbox to run a local developer environment for Noir smart contracts (includes aztec-cli, a Noir-compatible aztec-nargo compiler, and wallet tools).
Leverage open-source Noir libraries to add common privacy features to your app.
<aside> All of these libraries can be found in Awesome Noir (which also contains many other great Noir resources). Some examples:
<aside>
For getting the absolute basics down, the interactive NoirGuardians quests are a fun way to learn Noir step-by-step. You can also try Noirlings, which offers hands-on exercises for Noir programming. From there, start with Noir basics and a simple proof. Checkout the NoirJS tutorial in the Noir docs to build a simple web app.
Next, try replicating a basic demo (e.g. StealthNote for privacy preserving messages with or a simple zkEmail verification) to better understand the Noir workflow. Continue to use the Noir documentation and examples in AwesomeNoir to guide you, and focus on one core library to implement (JWT or email proof is a good first project).
</aside>
<aside>
You've tried basic Noir circuits—now start building full apps. Begin by combining two primitives (e.g., zkEmail + token gating). Use Nargo to compile and verify locally, and deploy on a public testnet using a relevant verifier contract.
Aim to prototype a working UI + circuit flow. You can optionally start exploring Aztec by using the Sandbox locally, but focus on feasibility and UX first. Try building something fun, cool, and maybe even viral.
</aside>
<aside>
Push the boundaries with multi-primitive and composable designs. Explore the AnonRadar registry for inspiration from existing Noir projects, and review past hackathon winners to see what's been achieved.
Try integrating Ethereum state proofs or other external data into your app (proving things about L1 activity, off-chain or in your L2 contract). Experiment with coNoir for collaborative proofs or build cross-chain privacy workflows (e.g. a Noir proof on Ethereum that triggers a private action on Aztec or another L2).
At this level, feasibility and composability are paramount – ensure each component you add is supported by current libraries or protocols, and design your system with modularity so others can reuse parts of your approach.
</aside>
<aside> NoirHack is supported by leading ecosystems who are exploring or already supporting Noir in production.
You can optionally build apps that use Noir + these networks:
Check the Partner Contribution Guide (coming soon!) for updates on specific prize tracks, SDKs, or bounties.
</aside>
<aside>
Build your app's privacy logic purely in Noir. Write circuits to prove statements about user data or actions, then verify those proofs on any chain (e.g. via a verifier smart contract or off-chain service). This track uses Noir's core libraries directly – focusing on one or combining a few. For example, you can combine Social proofs (e.g. JWT-based privacy preserving verification) with Identity proofs (email verification through ZK Email) or On-chain proofs (Merkle membership or state proofs) to create a basic private application. All Level 1 apps are feasible with current tools (Nargo, Noir libraries) and can deploy on any chain that supports Noir's verifier contracts.
</aside>
<aside>
Combine multiple privacy primitives or even multiple ecosystems for advanced use cases. These apps might integrate Noir proofs with other systems – for example, verifying an Ethereum state proof inside an Aztec contract, or using off-chain credentials (JWT, email) together with on-chain private logic. The goal is to explore composability across the ecosystem. Level 2 encourages experimentation: you can incorporate novel ZK techniques (like coNoir for multi-party proving) or mash up several Noir libraries to build something truly unique. Ensure the components work in unison (e.g. consistent circuits and inputs) and demonstrate how different ZK building blocks can complement each other in one application. This is the frontier of Noir development, so creativity is welcome – just keep feasibility in mind (all pieces should run with today's tech).
</aside>
<aside>
If you want true network-level privacy with blockchain features, consider building directly on Aztec—a private L2 rollup where all state is encrypted by default. Noir is its native smart contract language, and integrating here unlocks on-chain private state, hidden balances, and private contract logic.
Set up the Aztec Sandbox and explore the Aztec Starter template (a minimal Noir contract + tests). Dive into Aztec’s contract system, wallet tooling, and interaction flows using aztec.js or the CLI wallet. At this stage, aim to combine multiple primitives—for example, proving a credential (JWT/email) and gating access or features on-chain. Use Aztec’s docs to learn how to deploy private contracts, manage state, and coordinate interactions across accounts and apps. Bonus: explore private token logic, treasury flows, or DAO governance tools.
In this pattern, your Noir circuits become Aztec contracts running on a privacy-first Layer 2. You get features like on-chain private state, hidden balances, and private token transfers by deploying to Aztec's rollup. Focus on integrating Aztec wallet flows and tools: users will interact via Aztec's account model and you'll use Aztec's custom Nargo and CLI for deployment. This level emphasizes building on Aztec's composable privacy infrastructure, so your app can interoperate with other Aztec contracts while keeping data encrypted. (Examples: private voting with on-chain tally, confidential token airdrops or payments, etc). Here are a bunch of example contracts written by Aztec Labs.
</aside>
Each idea below builds on one or more core privacy primitives: Social, Identity, and Incentives unlocked by the libraries mentioned above, with references to the relevant library. Start simple or combine them to unlock powerful new privacy use cases.