The quantum threat
is not coming.
I already solved it.
Shor's algorithm breaks ECDSA on a sufficiently large quantum computer. Every Bitcoin address, every Ethereum wallet — all of it becomes readable. I built Axiom on ML-DSA-44 (NIST FIPS 204), a lattice-based signature scheme with no known quantum attack. This is not a roadmap item — it runs on mainnet today.
My vision
I want to build the blockchain that exists in 50 years — not the one that was convenient to build in 2009. Quantum computing will break every ECDSA-based chain. That is a mathematical certainty. I'm building the system that survives it.
Axiom is a fully functional proof-of-work blockchain: real consensus, real UTXO set, real peer-to-peer network, real wallet encryption. The only difference from Bitcoin is that I replaced the signature algorithm with one that no quantum computer can break. Everything else is deliberate engineering — no smart contracts, no token inflation, no governance theater. Just a sound monetary system with correct cryptography.
I built this alone. One developer. 14 Rust crates. No investors, no team, no VC funding, no presale. The genesis block went live on March 21, 2026.
Why I built this
Every major chain has the same flaw
ECDSA security reduces to the discrete logarithm problem. Shor's algorithm solves it efficiently on quantum hardware. The security of trillions in stored value depends on quantum computers not being large enough — yet. I designed Axiom to not make that assumption.
ML-DSA-44 signatures
Security rests on Module Learning With Errors (MLWE) — a lattice problem with no efficient quantum algorithm. Standardized by NIST as FIPS 204 in August 2024. I use it as the only signature scheme on the chain.
FIPS 204 / ML-DSA-44Per-block difficulty — LWMA-3
Bitcoin's 2,016-block window means a sudden hashrate drop can cause multi-hour gaps. I use LWMA-3 — it recalculates every block with a 60-block weighted average. Block time stays near 30s regardless of hashrate swings.
LWMA-3 · 60-block windowRust — no memory unsafety
Bitcoin Core is ~600K lines of C++. Its CVE history includes buffer overflows, use-after-free, integer truncation. I wrote Axiom in Rust — its ownership model makes these entire classes of bug unrepresentable at compile time.
Memory-safe · No UBUTXO transaction model
Ethereum's account model means every transaction modifies shared global state — re-entrancy is an architectural consequence. I chose UTXO: stateless per-transaction, parallelizable, and structurally immune to re-entrancy.
UTXO · DeterministicStrong wallet encryption
I use PBKDF2-HMAC-SHA512 at 600,000 iterations — NIST 2023 minimum — to derive the encryption key. Decrypted key material exists only in RAM and is zeroed on lock. No cloud, no account recovery.
PBKDF2 × 600K · HMACBLS aggregate signatures
BLS12-381 signatures (same curve as Ethereum 2.0) allow N signatures to be collapsed into one 96-byte aggregate, verifiable in a single pairing check. Implemented using the blst library — the same code used in the Ethereum consensus layer.
BLS12-381 · blst · G1/G2Confidential transactions
Transaction amounts can be hidden using Pedersen commitments over Ristretto255. Bulletproof range proofs (~675 bytes, no trusted setup) prove values are non-negative without revealing them. The validator verifies proofs and checks homomorphic balance.
Pedersen · Bulletproofs · Ristretto255No legacy constraints
Bitcoin cannot switch signature algorithms without near-unanimous miner consensus. These are frozen decisions from 2009. I designed Axiom in 2026 with 15 years of blockchain failure history — and no legacy to protect.
Designed 2026 · No legacy debtComparison
Axiom vs prior systems
As of March 2026, no major production blockchain has migrated to a post-quantum signature scheme. QRL uses XMSS — stateful, with strict key-use limits. I chose ML-DSA-44: stateless, no key-use restrictions, NIST FIPS 204.
| Feature | Axiom | Bitcoin | Ethereum | Monero |
|---|---|---|---|---|
| Quantum-safe signatures | ✓ ML-DSA-44 (FIPS 204) | ✗ ECDSA secp256k1 | ✗ ECDSA secp256k1 | ✗ Ed25519 |
| Signature standard | NIST FIPS 204 (2024) | Legacy (2009) | Legacy (2015) | Custom (2014) |
| BLS aggregate signatures | ✓ BLS12-381 (blst) | ✗ None | ✓ ETH2 BLS | ✗ None |
| Confidential transactions | ✓ Pedersen + Bulletproofs | ✗ None | ✗ None | ✓ RingCT |
| Implementation language | ✓ Pure Rust | ~ C++ | ~ Go / C++ | ~ C++ |
| Memory safety | ✓ Rust ownership | ✗ Manual | ✗ Manual | ✗ Manual |
| Difficulty algorithm | ✓ LWMA-3 per-block | ~ 2,016-block | EIP-1559 (PoS) | LWMA-3 |
| Transaction model | UTXO | UTXO | Account | UTXO (stealth) |
| Built | 2026 | 2009 | 2015 | 2014 |
Technology
How I built it
Every component exists because of a specific, documented failure in prior systems. The cryptography is NIST-standardized. The difficulty algorithm fixes a known oscillation problem. I assembled these pieces correctly — that is the entire claim.
ML-DSA-44 — Post-quantum signatures
Based on the hardness of Module Learning With Errors (MLWE). No known quantum algorithm provides a speedup against MLWE. Standardized by NIST in August 2024 as FIPS 204. Signature size is 2,420 bytes vs ECDSA's 64 bytes — larger, but quantum-resistant.
// Key generation: 32-byte seed → full keypair let seed: [u8; 32] = rand_core::OsRng.gen(); let signing_key = ml_dsa_44::SigningKey::from_seed(&seed); let verifying_key = signing_key.verifying_key(); // Signature: 2420 bytes Security: 128-bit post-quantum
LWMA-3 — Difficulty adjustment
60-block window, 30-second target. Most recent block weighted 60× more than oldest. Reacts instantly to hashrate changes without overshooting. I chose this to fix Bitcoin's difficulty oscillation problem.
// k = N·(N+1)/2 · T // weighted_sum += i · solvetime[i] (i = 1..N) // new_target = base_target × (weighted_sum / k) const LWMA_WINDOW: u32 = 60; // blocks const TARGET_TIME: u64 = 30; // seconds
Wallet security
Private keys derived from 32 bytes of OS entropy. Encrypted with SHA-256 CTR mode, authenticated with HMAC-SHA256. Encryption key derived via PBKDF2-HMAC-SHA512 at 600,000 iterations. Decrypted keys exist only in RAM and are cleared on lock. The 24-word BIP-39 seed phrase is your only backup — no server, no cloud, no account recovery.
# Wallet encryption pipeline
salt = os.urandom(32)
nonce = os.urandom(16)
enc_key, mac_key = PBKDF2_HMAC_SHA512(
password, salt, iterations=600_000
)
ciphertext = SHA256_CTR(enc_key, nonce, private_key)
mac = HMAC_SHA256(mac_key, ciphertext)Consensus & storage
Nakamoto consensus (longest-chain rule) with full UTXO set tracking and a complete reorg engine. I use fjall for storage — an LSM-tree key-value store written in Rust with crash safety and atomic batch writes.
// Consensus parameters BLOCK_REWARD: 50_000_000_000 // 50 AXM COINBASE_MATURITY: 100 // blocks MAX_SUPPLY: 21_000_000 // AXM P2P_PORT: 9000 RPC_PORT: 8332
Download
Run a node
Axiom Network v0.1.0 — mainnet, March 21, 2026. Compiled release build for Windows. Source compiles on Windows, Linux, and macOS with Rust 1.75+.
Full package
axiom-node.exe, axiom_wallet.py, and README. Everything you need to run a node and mine AXM.
↓ axiom-network-v0.1.0-win64.zipWallet only
GUI wallet — encrypted storage, BIP-39 seed phrase, auto-lock, send/receive.
↓ axiom_wallet.pyBuild from source
14 Rust crates, zero unsafe in consensus paths, complete test suite.
→ GitHubBuild from source
git clone https://github.com/axiom-network/axiomClone the repository
cargo build --release -p axiom-cliBuild release binary (Rust 1.75+)
./target/release/axiom-node --network mainnet --mine --miner-address <addr>Start node and mine to your wallet address
python axiom_wallet.pyOpen GUI wallet
About
I built Axiom alone, on a single computer. No investors, no team, no institution behind it. The entire stack — 14 Rust crates covering primitives, cryptography, consensus, storage, P2P networking, RPC, wallet, and CLI — designed, implemented, tested, and shipped by me.
My motivation was simple: every major blockchain today will eventually be broken by quantum computers. ECDSA's security reduces to a problem that Shor's algorithm solves efficiently. This is a mathematical fact established in 1994. The question is only when quantum hardware is large enough to run the attack at scale. I built Axiom to not depend on the answer to that question.
I'm not trying to compete with Bitcoin on brand recognition. I'm trying to be technically correct where Bitcoin is not.
“I make it look easy, but this shit really a process. I'm really a millionaire, still in the projects.”
Network
Join the network
Axiom is in genesis phase. The chain is young, the network has few participants, and every node matters. CPU mining is accessible now — before hashrate concentrates.
Validate the chain
A full node independently verifies every block and transaction — no trust required. Nakamoto consensus requires participants.
Mine PoW blocks
CPU mining with SHA-256d. LWMA-3 adjusts difficulty every block — the chain is accessible now before hashrate concentrates.
Read the code
14 crates, full test suite, zero unsafe in consensus paths. Verify the cryptography yourself.