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, tests, deploys, and manages wallets.
  5. Otigen Binary Spec v1.0 — the CLI surface. Every command, every flag.
  6. Otigen Test Spec v1.0 — the contract-behaviour test framework (Foundry-grade, TOML). Read once you have a working contract.

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; write tests/contract.test.toml

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

# 4. Run the behaviour tests
otigen test

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

This loop is detailed in OTIGEN_BINARY_SPEC §3.2 + §3.10. The TOML format for tests/contract.test.toml is documented in OTIGEN_TEST_SPEC.md.

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 launch plan.

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.