Get Started — for Developers

You're here because you want to build something on Pyde. This page is the on-ramp: enough orientation to land you on the right specs, without reproducing them.

What you can build

Pyde supports two contract surfaces:

  1. Smart contracts — sandboxed WASM modules deployed to the chain. Standard L1 contract development; read Chapter 3 — Execution Layer for the runtime model.
  2. Parachains — permissionless side-runtimes that share Pyde's finality and validator set, with their own state subtree and an extended ABI for cross-chain messaging + threshold cryptography. Read Chapter 13 — Parachains.

Both compile to WebAssembly. Pyde executes them via wasmtime + Cranelift AOT — deterministic feature subset, per-tx overlay isolation, fuel-metered gas.

What language?

Whatever targets wasm32. Pyde doesn't ship per-language SDKs; authors compile their .wasm themselves and use the otigen toolchain to package + deploy it. First-class examples ship for:

  • Rust — cargo build --target wasm32-unknown-unknown --release
  • AssemblyScript — npx asc contract.ts -o contract.wasm
  • Go (TinyGo) — tinygo build -target wasm-unknown -o contract.wasm
  • C / C++ — clang --target=wasm32 -nostdlib -Wl,--no-entry

The chain only sees the bytes. Pick what fits your team.

The five things to read

In order:

  1. Chapter 1 — Introduction — 10-minute orientation. Why Pyde exists, what it's not.
  2. Chapter 3 — Execution Layer — the runtime, the per-tx overlay, the determinism contract.
  3. Host Function ABI v1.0 — every pyde::* function your WASM can import. Signatures, semantics, gas costs, error codes. This is the contract the chain stands on.
  4. Chapter 5 — Otigen Toolchain — how otigen builds, deploys, manages wallets, runs a local console.
  5. Otigen Binary Spec v1.0 — the CLI surface. Every command, every flag.

Bookmark these. The rest of the book (state model, gas, accounts, consensus, networking, parachains, slashing, governance) you read on demand.

The minimum loop (once mainnet ships)

# 1. Scaffold a project
otigen init my-token --lang rust

# 2. Edit src/lib.rs + otigen.toml

# 3. Build (you run cargo; otigen post-processes)
cargo build --target wasm32-unknown-unknown --release
otigen build

# 4. Deploy to devnet / testnet / mainnet
otigen deploy --network devnet

This loop is detailed in OTIGEN_BINARY_SPEC §3.2.

Pre-mainnet status (today)

Pyde is pre-mainnet. What's already shippable:

  • The protocol spec (everything in this book).
  • The post-quantum cryptography crate: pyde-crypto.
  • The engine workspace's interface layer (MC-0 — phase-0-foundation tag on pyde-net/engine).
  • The marketing site you arrived from.

What's in active build-out:

  • The engine (execution + consensus + node binary). MC-1 in flight across two parallel streams — see Implementation Plan §3.2.
  • The otigen toolchain. MC-1 Stream α — see pyde-net/otigen.

What you can do right now:

  • Read the spec, file issues, propose PIPs.
  • Watch the repos.
  • Track the roadmap.

Where to ask

  • GitHub Discussions — design questions, spec ambiguities.
  • Telegram — quick chat, anything that doesn't need a paper trail.
  • PIPs — propose a protocol change.

Welcome aboard.