Noir circuits are now verifiable on Arbitrum Stylus – WakeUp Labs

[wakeuplabs]

Summary

To close out the project we kicked off in this discussion, we wanted to share what we built, some of the key takeaways, and the most relevant links.

We adapted the UltraHonk verifier to run in Stylus’ WASM environment, built a dedicated CLI, and published open-source examples. Now developers can go from writing a Noir circuit to deploying it on Stylus in just a few steps. This expands Noir’s possibilities: proofs no longer need to depend only on Solidity-based verifiers — they can be verified directly inside Stylus smart contracts using WASM and Ethereum precompiles.

👉 You can check out the final open-source repo here.
Or explore the user-facing project page here: nsv.wakeuplabs.link

What we build

Our first task: creating an Adapter Pattern

The goal was to make UltraHonk usable in Stylus by refactoring its Rust implementation into a modular, backend-agnostic structure. This way we could validate logic locally before moving into the Stylus WASM environment.

To get there, we:

• Refactored Taceo Labs’ Rust implementation of UltraHonk
• Introduced traits to abstract elliptic curve operations (add, mul, pairing)
• Implemented the first backend with Arkworks for local validation
• Ensured deterministic tests and better portability across environments
• Created a backend-agnostic structure, so UltraHonk logic could be tested locally before targeting Stylus

🔗 References:
Taceo Labs UltraHonk
Arkworks library

One of the main challenges was that the original design was tightly coupled to specific EC implementations, which made modularity tricky. We solved this by introducing trait abstractions to decouple the operations, and verified the changes with deterministic test cases. Using Arkworks as the first backend gave us a solid validation layer before integration.

Making UltraHonk Work in Stylus

The goal was to make UltraHonk verifier fully compatible with the Arbitrum Stylus WASM environment. Stylus imposes strict requirements: no std library, tight binary size limits, and reliance on Ethereum’s native precompiles for cryptographic operations.

What we did

• Removed all std dependencies → replaced with core + alloc.
• Integrated Stylus-native EC precompiles (ecAdd, ecMul, ecPairing).
• Split the verifier into modular contracts to stay under WASM size limits.
• Added Stylus-specific CI pipelines and devnode tests.

The original UltraHonk implementation relied heavily on std for memory management, error handling, and elliptic curve operations, making direct compilation impossible. We rebuilt those components using no_std primitives and integrated Ethereum precompiles to handle EC arithmetic efficiently. Modularizing the verifier kept the binary small enough for Stylus, while continuous testing on Nitro devnodes ensured correctness at every step.

Building Trust Through Internal Review

Since UltraHonk itself hasn’t yet been externally audited, we focused on conducting a thorough internal review.

In this stage we:

• Strengthened error handling → added clearer checks and fail-safes to improve reliability.
• Improved documentation → expanded explanations and clarified developer-facing notes.
• Fixed edge cases → addressed specific scenarios that could cause unexpected behavior.

📄 Deliverable: Review Report

Streamlining Workflows with a CLI

Once the verifier was functional, the next step was to simplify the developer workflow. Manually wiring Noir, Barretenberg, and Stylus was complex and error-prone, so we set out to build a CLI tool that automated the entire pipeline.

To make this happen we:

• Implemented a CLI that takes a Noir circuit all the way to a deployable Stylus verifier.
• Added commands to cover the full lifecycle:
  - new → bootstrap a Noir project
  - generate → compile a circuit, export VK, and generate Stylus contracts
  - check → run stylus check
  - deploy → deploy verifier contracts to Stylus
  - prove → generate proofs (wrapping bb)
  - verify → validate proofs locally or via deployed contracts
• Released binaries via GitHub Actions for easy installation.

🔗 CLI Release v0.1.0-alpha

Educating Through Docs & Examples

Having a working verifier and a CLI wasn’t enough, adoption depends on giving developers clear resources and real-world examples to learn from. Our goal in this milestone was to make zk on Stylus practical and approachable.

What we did:

• Built two end-to-end example dApps:
  - zk-Voting 🗳️ → demonstrates private governance flows on Stylus.
  - zk-Battleship 🚢⚔️ → an interactive zk-gaming demo where moves are proven without revealing positions

• Published supporting materials for zk-Battleship:
  🎥 Demo video
  📖 Step-by-step guide: Build zk-Battleship

• Published supporting materials for zk-Battleship:
  🎥 Demo video
  📖 Step-by-step guide: Build a Voting App

• Launched a dedicated documentation hub with guides, tutorials, and practical workflows. 🌐 nsv.wakeuplabs.link

Zero-knowledge workflows can be intimidating, especially for developers new to Noir. To lower the barrier, we paired code with visual demos and beginner-friendly guides, ensuring anyone can reproduce the examples and extend them for their own dApps.

Wrapping Up: Why This Matters for Noir

With this project, Noir developers now have a clear path to deploy and verify circuits directly inside Stylus smart contracts. Proofs no longer need to depend only on Solidity-based verifiers, they can now run natively in WASM, making verification more efficient and production-ready.

The combination of a Stylus-compatible UltraHonk verifier, CLI tooling, documentation, and open-source examples lowers the barrier for zk development and makes iteration much faster. From private governance (zk-Voting) to interactive zk-gaming (zk-Battleship), we showed that complex zk workflows can be accessible, reproducible, and practical.

This broadens the environments where Noir can thrive: not only in Solidity-based EVM flows, but also in WASM contracts on Stylus.

Looking Ahead

While the current scope is complete, there’s still plenty of room to keep pushing forward. Some next steps we see:

• Expanding the library of Noir example applications.
• Enhancing the CLI with more developer-focused commands.

👉 Explore the repo: github.com/wakeuplabs-io/noir-stylus-verifier

We’d love feedback from the Noir community on the repo, the examples, and ideas for future directions.

🧪 Built with ❤️ by WakeUp Labs