Forged in Rust. Open Source. Unbreakable.
Self-custody crypto wallet built from the ground up in Rust. Your keys never leave your device.
Every other mobile wallet uses JavaScript, Swift, or Kotlin for crypto operations. We use Rust.
Rust guarantees memory safety without a garbage collector. No buffer overflows, no use-after-free, no dangling pointers -- all verified before your code ever runs.
Private keys are automatically wiped from memory when no longer needed. No garbage collector leaving secrets scattered in RAM.
Zero C dependencies. All cryptographic operations use audited, pure-Rust crates. The same code compiles for iOS, Android, and desktop.
Write once, compile everywhere. The Rust core runs identically on every platform via UniFFI bindings -- no platform-specific crypto bugs.
"In most wallets, a single memory bug can leak your private key. In Rust, that class of bug simply cannot exist."
use zeroize::{Zeroize, ZeroizeOnDrop}; /// Private key that automatically wipes /// itself from memory when dropped. #[derive(Zeroize, ZeroizeOnDrop)] pub struct SecretKey { // 32 bytes, zeroized on drop bytes: [u8; 32], } impl SecretKey { /// Derive a child key using BIP-32. /// The parent key is consumed and /// zeroized after derivation. pub fn derive_child( mut self, path: &DerivationPath, ) -> Result<SecretKey, KeyError> { let child = self.derive_internal(path)?; // `self` is dropped here, // memory is automatically zeroized Ok(child) } } // When `SecretKey` goes out of scope: // 1. Rust's ownership system ensures // exactly one owner exists // 2. ZeroizeOnDrop overwrites bytes // with zeros // 3. Memory is deallocated // No GC, no timing gaps, no leaks.
Native support for major blockchains and their tokens. All key derivation and signing happens in the Rust core.
Security is not a feature -- it is the architecture. Every layer is independently verifiable in the source code.
Your seed phrase is encrypted by Rust (Argon2id + AES-256-GCM) AND by the Secure Enclave (P-256). An attacker would need to break both layers -- a mathematical impossibility with current technology.
"We believe security comes from transparency, not obscurity."
The UI layer never touches cryptography. All sensitive operations are isolated in the Rust core, exposed via type-safe UniFFI bindings.