Vibeleaderboard
← Back to Tools
Index / tool

QuDAG

https://github.com/ruvnet/qudag
Visit github.com
Category
Cybersecurity
Rank
No. 1092Tools index
Pricing
Open Source
Type
TOOL
Builder
ruvnet
GitHub
196 stars
Date

About

Quantum-resistant DAG-based anonymous communication protocol, built end-to-end with Claude Code via a TDD implementation plan.

What it does

QuDAG combines peer-to-peer messaging, graph-based consensus, private routing, post-quantum cryptographic primitives, human-readable dark addresses, credential storage, and agent coordination. Users can run nodes from a command line, embed individual Rust components, connect agents through MCP, or target browser and Node.js environments through WebAssembly.

Why it's ranked here

The project has unusually broad, inspectable building blocks: separate cryptography, networking, consensus, protocol, vault, MCP, exchange, and WebAssembly packages. That ambition comes with a serious qualification. The supplied consensus facade contains simplified behavior, including a signature check that always succeeds, so security-sensitive adoption requires direct code validation rather than trust in the README.

What's good

The modular Rust workspace lets teams adopt cryptography, networking, consensus, vault, or MCP support separately. Core crates reject unsafe Rust, while the consensus crate includes invariant and compilation tests. Network code covers peer discovery, NAT traversal, reputation, onion routing, traffic obfuscation, and temporary addresses. Installation surfaces span Cargo, npm, a command line, and embeddable libraries.

Tradeoffs

The README makes categorical claims about anonymity, quantum resistance, Byzantine fault tolerance, scalability, and autonomous business operation. The provided source does not establish those properties through audits or measured results. Some consensus-facing code is explicitly simplified or present for test compatibility, creates runtimes inside synchronous operations, unwraps runtime creation, orders vertices only by timestamps, and accepts every signature.

How to use it well

QuDAG best suits Rust teams prototyping private peer-to-peer systems, post-quantum experiments, agent coordination, or MCP-connected network services. Start with one component, run workspace tests and benchmarks, and threat-model every security boundary before deployment. Treat the full node as research-grade infrastructure until its guarantees are independently validated. It does not supply the customer service, logistics, governance, or business logic described in the broader vision.

Technical notes+

Cargo.toml defines a Rust 2021 workspace containing qudag, five core crates, tools/cli, qudag-mcp, qudag-wasm, and qudag-exchange. core/dag/src/lib.rs denies unsafe code and exposes DAGConsensus, but verify_message() is a placeholder returning true, get_total_order() sorts only by timestamps, and several synchronous methods create Tokio runtimes with unwrap(). core/crypto/src/lib.rs exports ML-KEM, ML-DSA, HQC, BLAKE3-related hashing, signatures, and fingerprints. core/network/src/lib.rs exposes LibP2P-oriented discovery, Kademlia, NAT traversal, onion routing, shadow addresses, reputation, and traffic obfuscation. core/vault/src/lib.rs exposes DAG-backed secret storage and vault cryptography. Makefile provides workspace build, test, benchmark, formatting, linting, installation, and uninstall targets.

Observed

License
Dual licensed under MIT or Apache-2.0.
Primary language
Rust, using the 2021 edition and a Cargo workspace.
Packaging
Published surfaces described for Cargo crates and an npm package, plus local installation scripts.
Interfaces
Command-line tool, Rust libraries, MCP server, and WebAssembly package.
MCP transports
The README lists stdio, HTTP, and WebSocket transports.
Platform support
The README describes WebAssembly use in browsers and Node.js applications.
Workspace structure
The workspace separates main library, crypto, DAG, network, protocol, vault, CLI, MCP, WebAssembly, and exchange packages.
Safety policy
Provided DAG, crypto, protocol, swarm, and vault crate roots deny unsafe Rust.

Read from README.md, Makefile, Cargo.toml, core/dag/lib.rs, core/crypto/lib.rs, core/network/lib.rs, core/protocol/lib.rs, core/monitoring/mod.rs, core/dag/src/lib.rs, core/swarm/src/lib.rs, core/vault/src/lib.rs, core/crypto/src/lib.rs, core/network/src/lib.rs, core/protocol/src/lib.rs, core/optimized/advanced/mod.rs.

What it can do

  • Send anonymous messages through quantum-resistant encryption

    Message content and recipient identifier → Encrypted anonymous message transmitted through DAG network

  • Establish secure communication channels

    Communication parameters and recipient details → Encrypted communication channel resistant to quantum attacks

  • Route messages through DAG network topology

    Encrypted message packets → Message delivered via optimized DAG routing path

  • Generate quantum-resistant cryptographic keys

    Key generation parameters → Post-quantum cryptographic key pairs

  • Verify message integrity and authenticity

    Received encrypted messages → Validation status and decrypted message content

  • Maintain anonymous identity within network

    User identity and network participation data → Anonymized network presence and routing capabilities

Tags

quantum-resistantdaganonymousclaude-codetdd

Tech Stack

RustDocker

Comments (0)

No comments yet

Editorially curated, with community endorsements as a secondary signal. Corrections welcome.