Why Pyde
Pyde is the chain you'd build if you started today — with the post-quantum cryptography NIST standardized in 2024, the Mysticeti consensus Mysten Labs proved in production in 2024, and the WebAssembly runtime Fastly and Microsoft ship at scale. Nothing here is exotic. The combination is.
Most production chains had to pick which properties to ship first and migrate the rest later. Pyde was built greenfield to ship all of them at once.
For businesses
The properties production needs, defaulted from day one — not retrofitted to a chain holding live value.
- 01
Quantum-proof from genesis.
Every other production L1 — Bitcoin, Ethereum, Solana, Cardano, Sui, Aptos — secures account paths with classical cryptography that breaks the day a cryptographically-relevant quantum computer exists. NIST standardized the post-quantum replacements in 2024, but retrofitting them into a chain holding trillions in value is a multi-year coordination problem none have solved. Pyde uses FALCON-512 signatures, Kyber-768 encryption, and Poseidon2 hashing from block zero. Long-tail contracts — insurance policies, multi-year escrows, intellectual-property registries, legal records — sign once and remain cryptographically valid into the quantum era. No migration to budget for.
- 02
MEV protection at the protocol layer, not via a trusted relayer.
Other chains' answer to MEV is a third-party relayer — Flashbots on Ethereum, Jito on Solana — a service you opt into and trust to behave. On Pyde, MEV-sensitive transactions are encrypted under a Kyber-768 threshold key held jointly by 128 validators. The committee commits to a canonical order before any decryption share is released. The information asymmetry MEV needs simply doesn't exist. Your users keep what they paid; you don't owe anyone a trust assumption you can't independently verify.
- 03
Settlement in ~500 milliseconds.
Mysticeti consensus reaches finality at roughly half a second median. Your customer's payment confirms before their hand leaves the mouse. On Ethereum that's 12 seconds — long enough for users to refresh, retry, or abandon. Checkout abandonment drops. Cash flow accelerates. Customer-support tickets stop being about "I paid but it didn't go through."
- 04
Predictable fees under load.
EIP-1559 base fee. No tips. No MEV race driving gas competition during popular drops. When an NFT mints on Ethereum, gas can 10x in 30 seconds and your unit economics break. Pyde's structural absence of MEV competition combined with the no-tip fee model keeps cost predictable. You can quote your operations team a number that's true tomorrow.
- 05
Cryptographic receipts your auditors can verify offline.
Every committed transaction comes with a HardFinalityCert — a FALCON quorum certificate signed by 85 of 128 independent validators. Your compliance team doesn't trust the chain; they verify the math. The certificate is portable: any external system that can verify FALCON signatures can verify a Pyde commitment, on or off chain.
- 06
Run your own validator on a normal machine.
Most high-throughput chains have made validation a premium-hosting business — Solana production validators run on 12+ cores and 256+ GB RAM, costing $20K+/month. A Pyde committee validator runs on 8 cores, 16 GB RAM, and a 500 Mbps – 1 Gbps connection. Your enterprise can verify Pyde independently without an infrastructure budget that defeats the purpose of running your own node.
For developers
Familiar tools. Honest performance. Real extensibility.
- 01
Real toolchain today, not a someday promise.
The otigen developer toolchain is shipping: scaffold a new contract, build it against the chain's host-fn ABI, run behavior tests through the same wasm executor mainnet uses, deploy + verify on-chain, read state, drive an interactive REPL — all from a single binary. The `pyde devnet` companion gives you a one-command local devnet with 10 prefunded accounts and real chain semantics, not a mock. Iterate against the actual protocol, not a sandbox approximation. Available now; no waitlist, no preview access.
- 02
Write in any language that compiles to WebAssembly.
Rust, AssemblyScript, Go (TinyGo), C, C++, Zig — anything that targets wasm32. No Solidity to learn. No Move. No Cairo. No proprietary VM to internalize. Your team uses the stack they already know; Pyde meets you where you are. Rust authors additionally get a macro substrate (`#[pyde::entry]`, typed storage, native enum/struct support, typed cross-contract calls) so contracts read like idiomatic Rust libraries — not as `#[no_mangle]` boilerplate.
- 03
Build your own parachain — a chain inside the chain.
This is what no other production L1 offers without auctioned slots or central gatekeeping. Pyde's parachain framework lets you author a WASM module that runs as its own execution environment with its own state, validated by Pyde's committee. Want to ship a privacy-first application chain? A custom VM optimized for your domain? A confidential-vote chain? An oracle network? A gaming-specific subchain with its own throughput profile? Build a parachain. Pyde validators stake PYDE to run yours; they earn the fees you set. Your parachain inherits Pyde's HardFinalityCert, cross-parachain messaging, security model, and threshold-encryption infrastructure for free. This is how dev communities get built around real innovation — you bring the logic, Pyde brings the substrate. No auction. No bidding war. No "we'll consider your team in the next batch." Parachains land post-mainnet; v1 reserves the protocol surface so contracts written today survive the v2 upgrade unchanged.
- 04
Cross-parachain composability through one cryptographic primitive.
Pyde's HardFinalityCert is portable. Any chain that can verify FALCON signatures can verify a Pyde commit. Your parachain talks to other parachains, to Pyde's main chain, and (post-mainnet) to external chains through a single signed certificate. No bridge multisig to trust. No oracle latency to budget for. No fragile relayer in the middle.
- 05
Hybrid parallel execution.
Pyde's scheduler combines static access-list parallelism (the Solana model — declared accesses run in parallel) with Block-STM speculation (the Aptos model — dynamic accesses speculate and re-execute on conflict). Most chains pick one. Pyde ships both — fast path when the compiler can statically analyze your contract, optimistic fallback when it can't. Your contracts get parallelism for free without giving up dynamic dispatch.
- 06
Performance numbers you can defend in production.
Performance is measured, not marketed: a multi-region harness with real network latency will set the numbers, and we publish only once it has — never lab extrapolations. Until then, throughput figures are awaiting measurement. If we promise it, you can build on it.
- 07
Runtime that already powers production at scale.
wasmtime + Cranelift AOT — the same WebAssembly runtime Fastly serves edge functions on, Microsoft ships in Hyperlight, Shopify uses for app extensions, and the Bytecode Alliance maintains with 50+ corporate contributors. Not a homegrown VM with a 1.0 release ahead of it.
- 08
Native session keys and programmable accounts are planned.
v1 ships native multisig (up to 16 signers). v2 ships scoped session keys and programmable accounts at the protocol layer — not retrofitted like Ethereum's ERC-4337. Your dApp gets bounded, revocable delegation as a first-class primitive: gaming sessions, AI-agent delegation, recurring payments, all without a wallet popup per action. v1 reserves the protocol surface so contracts written today survive the v2 upgrade unchanged.
- 09
16 concurrent transactions per account.
Most chains lock you to one in-flight transaction per account. If one stalls, your queue stalls. Pyde maintains a 16-slot nonce window — submit up to 16 transactions concurrently per account, out of order within the window. Wallet UX, exchange settlement, and high-frequency dApps all benefit.
For users
Your transactions. Your funds. Kept yours.
- 01
No more sandwich attacks.
On most chains, bots watch the mempool and trade against your transaction — buying before your swap to push the price, selling after for profit. You lose 1-5% of trade value to actors you don't know exist. Pyde encrypts your transaction's content under a threshold key held jointly by 128 validators. The order is committed before any decryption share is released. The information asymmetry MEV needs cannot structurally exist. You keep the price you signed.
- 02
Confirmations in half a second.
~500ms to finality at the median. Your wallet shows the result immediately. No "12 seconds and counting" spinner. No refresh-and-pray.
- 03
Predictable fees.
Your $5 swap costs $5 in fees. Not $5 plus $80 of MEV extraction. Not $50 because someone launched an NFT mint at the same moment.
- 04
See exactly what you're signing — before you sign.
Pyde wallets run your transaction locally first (deterministic wasmtime simulation) and show every state change — balances moved, contracts called, events emitted — before asking for your signature. No "approve this transaction" leap of faith. No surprise approval draining your wallet a week later.
- 05
Quantum-proof funds.
Your funds stay yours even when quantum hardware can break the cryptography securing Bitcoin and Ethereum. Built in from genesis, not a retrofit you have to wait for.
- 06
Cross-chain by certificate, not by trusted bridge.
Custodial bridge multisigs have lost over $3B since 2021. Pyde's cross-chain finality is verified cryptographically by 85+ validator signatures — math your wallet checks, not a multisig you have to trust.