Inspiration
QuantumMesh was born from the worry that classical public-key crypto will become vulnerable as quantum computers advance. I wanted a communication stack that combines Web3 primitives (Polkadot/Substrate, XCM) with post-quantum primitives (Kyber, Dilithium, SPHINCS+) so people can keep messaging, file sharing, and video calls private even after large-scale quantum hardware arrives. The project README and architecture describe this goal and the building blocks chosen.
What it does
QuantumMesh is a decentralized communication network that provides:
Quantum-resistant end-to-end encryption (Kyber768, Dilithium3, SPHINCS+).
Cross-chain messaging integrated with Polkadot/XCM for an immutable message trail.
Decentralized storage (IPFS) with client-side encryption for attachments.
P2P video calls using WebRTC with quantum-safe DTLS.
Token incentives for node operators (stake to run nodes, earn rewards).
All of the above are laid out in the repo README and architecture diagrams.
How we built it
High-level implementation choices:
Client layer: Next.js web app + React Native mobile app that talk to a GraphQL gateway.
Crypto & networking: Rust services provide the crypto primitives (liboqs integration) and libp2p nodes; a mediasoup/WebRTC service handles P2P media.
Blockchain layer: A Substrate node with a quantum-mesh pallet and ink! contracts to record immutable message hashes, staking, and governance.
Storage & infra: IPFS for encrypted content, PostgreSQL + Redis for metadata and caching, deployed via Docker / Kubernetes, with Netlify / Fly.io used in the README examples.
Quick start and install steps, plus the file structure, are in the repository README.
Challenges we ran into
Integrating post-quantum libraries (liboqs) into a cross-language stack (Rust + TypeScript). Packaging liboqs for both native Rust services and WASM (for any browser-side components) is particularly tricky.
Latency vs. post-quantum cost: PQ algorithms are heavier—balancing real-time video/voice latency with PQ key-exchange cost required engineering tradeoffs (hybrid crypto where appropriate).
Cross-chain semantics: Mapping messaging semantics to Polkadot XCM (finality, fees, storage of proofs) added protocol design complexity.
Testing and audits: Ensuring constant-time operations and correctness across many implementations required additional CI and security review processes (the README references audits and a bug bounty program).
Accomplishments that we're proud of
Built an end-to-end architecture that pairs Substrate/ink! smart contracts with liboqs-based PQ crypto and libp2p networking (all documented in the repo).
Achieved prototype performance targets in the README (example metrics: ~87ms message latency, encryption time ~42ms) while maintaining quantum-resistant primitives.
Laid out a full roadmap (core protocol → crypto integration → mainnet → mobile → cross-chain bridge → DAO governance) to take the project from hackathon prototype toward production.
What we learned
Practically deploying PQ crypto requires hybrid strategies: use classical primitives where safe today and PQ for long-lived secrets.
The throughput of the network can be expressed simply: if a single node processes r messages/sec, N nodes give approximate system throughput ≈ 𝑟×𝑁 (ignoring network bottlenecks and coordination overhead). This helps reason about horizontal scaling and stake-based node sizing.
Developer ergonomics matters: providing a TypeScript SDK and clear Next.js/React examples speeds adoption.
What's next for QuantumMesh
Finalize mainnet Substrate pallet and security audits (move from prototype to a canary network).
Optimize PQ operations for browser/WASM and mobile (reduce encryption time and memory footprint).
Launch incentivized testnet with staking + node-operator rewards and release the TypeScript SDK for builders.
Implement cross-chain bridge and DAO governance as laid out in the roadmap.
Log in or sign up for Devpost to join the conversation.