The blockchain, finally.
Pyde is our attempt at what a blockchain could have been from the start: your assets stay secure, your trades stay fair, and anyone can run a node. Not as promises you have to trust, but as properties the protocol holds to from the first block.
Built for
Who builds on Pyde
The businesses that can't afford their value stolen, front-run, or broken, and the teams that want their own chain without asking permission.
Payments & remittance
Move money across borders without the fees, delays, or reordering. Sub-second settlement on hardware anyone can run, so value arrives fast, and arrives whole.
Exchanges & trading
Give your users execution that can't be front-run or sandwiched. Fair ordering is the protocol's default, so best price isn't a promise you have to police.
Tokenization & real-world assets
Issue bonds, deeds, funds, or IP meant to last decades. The cryptography protecting them is chosen to stay valid for that long, so the signatures won't quietly expire under your assets.
DeFi protocols
Build lending, perps, and AMMs where traders keep the price they signed, with no MEV tax skimming every swap and no relayer to trust.
Your own chain
As Pyde grows, launch an app-specific parachain, whether a game world, a confidential enterprise ledger, or an oracle network, with no slot auction. Inherit Pyde's security and finality, and set your own fees.
Built for the people who'll actually use it.
Pyde is technically dense underneath, but what it gives you depends on who you are. Three short reads, one for each audience.
The Protocol
A few decisions, made once, at the base layer.
Pyde doesn't patch these in after launch. They fall out of a handful of choices made carefully at the start, and then held to.
The price you sign is the price you get
Sensitive transactions can be sealed in the mempool until their order is already fixed. A keyless commit-reveal step settles the order before anyone can read the contents, so front-running and sandwich attacks have nothing to act on. No committee holds a key, so there is no trusted party left to fail. Users keep the price they signed, and businesses don't owe anyone a trust assumption they can't check for themselves.
One network, not another island
Every new chain splits liquidity and users a little further, and the bridges meant to reconnect them keep getting drained. Pyde is built to reach the rest of the world through its own security, not a bridge you have to trust. A Pyde transaction is verifiable by anyone today, and the parachain layer that connects it to other chains and to real-world data is the chapter we're building next.
Fast enough for real apps
Consensus and execution run in a single binary and a single process. Rounds advance in roughly 150 ms and wave commits land about every 500 ms. Throughput grows with the parallelism the hardware allows, and we publish numbers only after a multi-region harness has measured them, never lab extrapolations.
A network anyone can run
Validators run on modest hardware, and every committee seat carries one vote regardless of stake. The parachain layer that will handle cross-chain calls and oracles is permissionless, so anyone who meets the spec can take part. A business can verify the chain on a normal machine, and a team can launch its own parachain without a slot auction.
The Chain
Built to hold value through whatever comes next.
Designed from the ground up so that trades can't be front-run, records stay verifiable on their own terms, and any chain can check another without asking permission. For the businesses that need it to settle, the developers that need it to extend, and the users who need it to hold value through whatever the next decade brings.
Build on Pyde
A Foundation You Don’t Have to Trust.
Pyde gives developers a base layer that handles the hard guarantees, so you build the application, not the security model.
Honest Ordering. Transactions execute in the order the protocol commits to before their contents are revealed. Your users keep what they meant to spend.
Write in the Language You Know. Contracts compile from Rust, Go, C, or AssemblyScript to WebAssembly. No new language to learn, no proprietary virtual machine to internalize, and no starting over.
Trustless Interoperability. Pyde's finality certificates are portable proofs. Any chain that can verify Pyde's signatures can run a light client and prove a Pyde block was finalized. Cross-chain calls go through the parachain layer with the same gas fee as a local transaction.
Predictable Performance. Roughly 150 ms rounds and sub-second wave-commit finality, sustained.
Maximum Security
Lose a Key, Not Your Account.
Account security on Pyde is a protocol mode, not a contract you deploy yourself. The architecture is built so a leaked private key is an inconvenience, not a catastrophe.
- available at mainnet
Native Multisig
Require any M-of-N signatures to authorize a transaction. Built into the protocol itself, with no third-party contract to deploy and no per-app integration. If one of your keys leaks, the holder can't move anything on their own.
- planned
Programmable Accounts
Attach a sandboxed policy to your account that runs on every transaction: spend limits, time locks, allow-listed recipients, social recovery, tiered authorization. Opt-in by design, so simple accounts stay simple.
- planned
Native Session Keys
Issue scoped keys that can act on your behalf for one app, with hard caps on spend and a deadline. Games, AI agents, and consumer apps stop needing to wake up your wallet for every action. Revoke any time.
Mainnet ships with native multisig today. Programmable accounts and session keys are post-mainnet work, and the protocol is designed to grow into them without breaking accounts that prefer to stay simple.
Build with Pyde
Everything you need to build on Pyde: architecture specs, RPC references, and integration guides.