Umbra

Umbra is a privacy-preserving geolocation proof system that lets users prove they’re within a specific area — without revealing their exact location.

Comment

Inspiration

I wanted to challenge myself to use zero-knowledge proofs in a way that’s practical and privacy-preserving. I’ve always believed that apps rarely need to know where you are — they just need to know if you’re in the right place. So I built a system that proves location presence without exposing exact coordinates, using Leo and zero-knowledge cryptography.

What it does

Umbra lets users create private groups with custom geofences (defined by a center point and radius). Other users in the group can then generate a zero-knowledge proof that they are within the designated area — without ever revealing their precise location. These proofs can be used for private access control, attendance, event check-ins, and more.

How we built it

Frontend: React Native mobile app for users to join groups and prove location.

Backend: Golang server using a custom CLI wrapper called GoLeo.

ZK Circuit: Leo circuit that calculates squared distance between user location and geofence center, returning only a boolean result.

Proof Flow: The app sends location inputs to the backend, which runs the Leo circuit, generates the ZK proof, and returns the result to the app.

Challenges we ran into

Aleo’s testnet had ongoing faucet and deployment issues, so I opted to simulate the full ZK proving and verification flow locally.

React Native doesn't natively support WASM, making client-side proving difficult from the app.

Wrapping the Leo CLI in Go required careful orchestration of temp files, build commands, and I/O.

Accomplishments that we're proud of

Built a real-world ZK location system from scratch, with both frontend and backend working together.

Created GoLeo, a Golang wrapper for the Leo CLI — useful for Aleo backend integrations beyond this project.

Developed and deployed a working Leo circuit that showcases privacy-preserving computation in a novel domain.

What we learned

How to build and execute Leo circuits dynamically through a CLI interface.

Practical limitations of client-side proving and how to adapt to them.

How to design around privacy: thinking about what needs to be public, and what doesn’t.

What's next for Umbra

Add support for proof verification on-chain.

Integrate a frontend-friendly ZK stack (when WASM + mobile support matures).

Explore encrypted record use so group owners can verify presence without ever seeing the user’s raw data.

Potentially evolve Umbra into a privacy-first protocol for geo-based access control.

Built With

Share this project:

Updates