2 posts tagged with "retrospective"

2025 has been a strong year for Mopro and the evolution of mobile proving. Over the past year, we showed that Mopro is not just a tool for advanced developers, but one that hackers and beginners can adopt with ease.

This progress was also showcased at DevConnect, where we presented Mopro’s approach to mobile proving and shared real-world learnings from building and deploying zk applications on mobile. You can watch the full talk.

The following milestones highlight what we accomplished.

Mobile SDK Management Solution​

We realized that for most zk protocol developers, building a full frontend is not essential—especially when the goal is to demonstrate a proof of concept or integrate the protocol into an existing product. What is essential, however, is a reliable and easy-to-use SDK.

To address this, we built reusable templates with Mopro bindings that can be integrated with minimal mobile development experience. These templates are designed to be easily extended into SDKs for multiple platforms, enabling zk protocol teams—such as zkEmail, Semaphore, and others—to focus on protocol design rather than frontend or mobile engineering.

Our approach is inspired by the Reclaim Protocol philosophy: a protocol should support as many platform SDKs as possible to unlock a broader range of applications and products.

Expanded FFI Support​

Although UniFFI provides a robust foundation for Rust FFI, it still requires manual effort to integrate with modern cross-platform frameworks such as Flutter and React Native. This added complexity can be a barrier for mobile developers.

In 2025, we streamlined this process by integrating multi-platform FFI generation into mopro-ffi. Today, Mopro can automatically generate bindings for Swift, Kotlin, Flutter (with flutter_rust_bridge), React Native (with uniffi-bindgen-react-native), and WebAssembly (with wasm-bindgen), eliminating the need to maintain platform-specific glue code. Developers define their interfaces once in Rust, and Mopro handles the rest.

Noir Support​

Alongside our existing support for Circom and Halo2, we integrated Noir into Mopro in 2025, recognizing its growing adoption as a frontend language for zero-knowledge circuits. Inspired by the zkPassport team, we enabled mobile proving and verification for Noir-based circuits.

Throughout the year, we participated in multiple NoirHack events and NoirCon, where we built Stealthnote Mobile, achieving up to 10× faster performance than the browser version and a superior user experience. We also released an example demonstrating how Noir proofs can be verified on-chain.

Hackathon Projects​

Throughout 2025, we participated in several hackathons and received over 50 project submissions built with Mopro. Below are a selection of standout projects developed this year.

Zuma​

Anonymous Event Attendance

ETHGlobal Trifecta — Zero Knowledge

• GitHub: https://github.com/chengggkk/zuma
• Submission: https://ethglobal.com/showcase/zuma-6vnoj

Zuma is a ZK-powered Luma-style application, inspired by Luma and Zupass. It combines the seamless user experience of native event apps with the strong privacy guarantees of zero-knowledge proofs.

When a user attends an event, the app generates a Semaphore proof to attest to attendance. Verifiers only need to validate the proof to confirm that the user is an attendee—without learning any personal information such as the user’s email address or name.

Stealthnote Mobile​

Glassdoor-Style Anonymous Forum

NoirHack 2025

• GitHub: https://github.com/vivianjeng/stealthnote-mobile

Stealthnote Mobile is inspired by stealthnote.xyz and demonstrates that Noir proofs can be generated and verified directly on mobile devices. Compared to the browser-based implementation, the mobile app achieves up to 10× faster performance.

While the browser version takes approximately 20 seconds to generate a Google OAuth proof, the mobile app completes the same operation in about 2 seconds, resulting in a significantly improved user experience. In the future, the app could integrate push notifications to notify users when new posts are available.

MobiScale​

Privacy-Preserving AI Biometric Verification with zkVM on Mobile

ETHGlobal Cannes 2025

• GitHub: https://github.com/ElusAegis/MobiScale
• Submission: https://ethglobal.com/showcase/mobiscale-n9vj6

Mobiscale represents a major technical milestone for Mopro, showcasing how mobile hardware can enable zkVMs on smartphones. The project combines AI-powered facial recognition with Apple’s Secure Enclave to verify identity in a privacy-preserving way.

Users upload a passport photo and take a live selfie, which are compared locally by an AI model to establish identity with high confidence. The system then generates zero-knowledge proofs using RISC Zero and Noir circuits, allowing third parties to verify identity claims without accessing biometric data, confidence scores, or image hashes.

ZeroSurf​

Seamless Browser-to-Mobile ZK Age Verification

ETHGlobal New Delhi 2025

• GitHub: https://github.com/Krane-Apps/zerosurf-anon-aadhaar
• Submission: https://ethglobal.com/showcase/zerosurf-9988k

ZeroSurf demonstrates a highly smooth user experience between browser applications and mobile native apps through deep linking. When accessing a website with age restrictions, users are redirected via a URL to a mobile app, where a zero-knowledge proof (in this case, an Anon Aadhaar proof) is generated.

The proof is then returned to the website, enabling verification without exposing sensitive information. This project expands the use cases for mobile-native provers and shows how browser-based applications can directly benefit from mobile zero-knowledge proving.

Future Direction​

In 2026, we propose the following direction for the community. While Mopro handles the FFI layer and ensures that proving systems work reliably across platforms, we also want to raise awareness that reaching users on different platforms requires more than just cross-platform compatibility.

To truly enable adoption, zk protocol developers should provide platform-specific SDKs that can be easily consumed by application developers on iOS, Android, web, and beyond. By offering well-designed SDKs tailored to each platform’s ecosystem, zk applications can achieve broader reach, better user experience, and faster integration across diverse platforms.

As for the Mopro team, we plan to collaborate with more projects to help them build and ship their protocol SDKs. We will continue exploring zkVMs on mobile and advancing client-side GPU research across different proving systems.

In addition, we aim to engage more deeply with mobile development communities and events, promoting the adoption of zero-knowledge proofs in real-world mobile applications.

Conclusion​

2025 was a milestone year for Mopro, proving that mobile zk is not only possible, but practical and accessible. As we move into 2026, we’re excited to keep pushing the boundaries of mobile proving and work closely with the community to bring zero-knowledge to more platforms and applications.

It has been a remarkable year for the Mopro project. We’ve successfully transitioned from a proof of concept to a ready-to-use solution, attracting significant interest from various projects.

Here are the milestones we’ve achieved this year, along with key reflections on our journey.

Optimizing Developer Workflow​

We streamlined the development process through significant codebase refactoring. By merging mopro-core and mopro-ffi into a single mopro-ffi folder and consolidating the iOS, Android, and web apps into a test-e2e folder, we reduced folder depth, making it easier for contributors to locate functions.

Additionally, we removed the circuits compilation and trusted setup processes, along with unused toolchain targets. These optimizations have drastically improved our CI workflow, reducing the peak runtime from around 1 hour to just 10 minutes (10 times faster)!

We also enhanced the Mopro CLI, significantly reducing the time required for setup and usage. As mentioned earlier, users no longer need to install unnecessary toolchains or download unused circuits from the Mopro repository.

Looking ahead to 2025, we plan to make the CLI even more accessible by providing precompiled binaries for download, eliminating the need for git clone during installation.

Users can now quickly clone the repository and build an iOS or Android project in just three commands—mopro init, mopro build, and mopro create—all within 3 minutes! For detailed instructions, check out the Getting Started section.

Enabling Multi-Platform Support​

In addition to Swift for iOS and Kotlin for Android, we’ve now created templates for cross-platform frameworks like React Native and Flutter. The CLI has been updated to support these platforms, and the documentation has been refreshed to reflect these enhancements.

Please refer to the following resources:

• React Native Setup
• React Native App
• Flutter Setup
• Flutter App

Additionally, Mopro now supports WASM for web browsers. We provide wasm-bindgen for the Halo2 prover, enabling developers to use the Mopro CLI to generate website templates with bindings. This significantly reduces the time spent navigating the outdated Halo2 tutorial available at Using halo2 in WASM (It was authored in 2022).

Please refer to the following resources to learn how to use Mopro for building WASM applications for web browsers:

• WASM Setup

Expanding Compatibility with General Rust Functions​

We realized that generating and verifying proofs alone isn’t sufficient for application developers. To address this, we made the Mopro template compatible with any Rust crate or function, allowing developer to extend the FFI interface directly through Rust code.

For instance, if a developer needs a Poseidon hash function but neither Swift nor Kotlin provides a Poseidon hash library, they can integrate a Rust Poseidon crate. First, they define the function API in Rust, such as:

#[uniffi::export]
pub fn poseidon(input: Vec<u8>) -> Vec<u8>{
    // Poseidon hash implementation
}

By annotating your function with #[uniffi::export], UniFFI automatically declares the appropriate FFI type and generates the necessary bindings for Swift, Kotlin.

Once processed, the generated foreign language bindings expose your custom functions seamlessly. You can then call the Poseidon function in your Swift or Kotlin code as if it were a native API, enabling straightforward cross-language integration.

For more details on how UniFFI processes your Rust code to generate these bindings, please refer to the Uniffi - Procedural Macros.

By running mopro build again, the developer can generate Swift and/or Kotlin bindings for the Poseidon hash function. They can then easily call the function in Swift or Kotlin like this:

let hash = poseidon(input: input)

or in kotlin

val hash = poseidon(input)

Additionally, this approach is compatible with WASM for browsers. You can define a function in Rust as follows:

use serde_wasm_bindgen::to_value;
use wasm_bindgen::prelude::*;

#[wasm_bindgen]
pub fn poseidon(input: JsValue) -> Result<JsValue, JsValue> {
    // Poseidon function implementation
    to_value(...)
}

Then, by running mopro build again with the web target, you can generate the necessary bindings for the web. Once built, you can call the poseidon function directly in JavaScript, making it seamlessly accessible in browser-based applications.

The Rise of New ZK Mobile Apps​

This year, we’ve seen a growing number of ZK mobile apps being developed. Some notable examples include:

1. World ID
2. Anon Aadhaar
3. Open Passport
4. Myna Wallet
5. FreedomTool

These apps benefit significantly from mobile-native proving compared to using tools like snarkjs. For instance, Anon Aadhaar achieves up to 8x faster performance with rapidsnark compared to snarkjs.

For more details on the benchmarks, please refer to the benchmark section.

While we’ve provided the Mopro stack with rust-witness and ark-works, most applications are leveraging the witnesscalc and rapidsnark stack for faster proving, particularly with RSA circuits.

Given the adoption trends and benchmark results, we've recognized the need to prioritize improving rapidsnark integration and further enhancing the developer experience. This will be a key focus in Q1 of 2025.

We’re excited to see even more ZK mobile-native apps emerge in the near future, delivering improved performance and enhanced user experiences.

Final Thoughts and Looking Ahead​

The Mopro tool has become more robust, now supporting multiple platforms. However, our vision extends further—we aim to develop a mobile-native ecosystem as comprehensive and developer-friendly as the JavaScript/TypeScript ecosystem, empowering developers to seamlessly build innovative apps.

As we look to the future, we encourage developers to explore the opportunities in building ZK mobile applications. By leveraging mobile-native proving, you can create apps that are not only faster but also more accessible to users worldwide. Let’s work together to shape the next wave of ZK technology and bring its benefits to mobile platforms!