Skip to content

Introduction

The Polkadot Products Devnet is a public developer preview of the Polkadot app and the app platform behind it. These docs are here to help you do something concrete first: install the app, create an account, try Products, build one of your own, or understand how the platform fits together before reading source.

The larger idea is simple: Products should feel like polished web experiences, while running on decentralized blockchain infrastructure. A Product can be named, published, discovered, opened, and used through Polkadot-native services instead of a traditional app server. The Polkadot app and web gateway provide the smooth entry point, while the Devnet gives developers a place to test those web3 flows end to end.

This is a public Devnet

The Polkadot Products Devnet is an early developer preview. Tokens on it have no real value, chains and services may be reset, and flows described here may change. Do not use it to hold anything of value, and expect rough edges.

What you can do

For users, the Devnet is the Polkadot app: a self-custodial client for mobile and desktop, with a web gateway at dev-dot.li. You can create an account, claim a human-readable username, try CASH flows, chat, and use Products.

For developers, it is a way to ship a web Product into a Polkadot-native host. You build a frontend, give it a .dot name, publish the bundle, and use host-provided services such as accounts, signing, identity, payments, contracts, and storage.

Products are addressed by human-readable .dot names. A name resolves to the published bundle, and the bundle runs inside the Polkadot app or the web gateway. The Product talks to the surrounding host through the Host API, so the same experience can run across mobile, desktop, and web entry points without asking users to manage raw keys, RPC endpoints, or chain-specific plumbing.

The model to keep in your head

Four layers stack on top of each other. When you are blocked, first identify which layer you are working in: the entry point, your Product, the developer tools, or the platform services.

flowchart TD
  subgraph U[Entry points]
    APP[Polkadot app<br/>mobile + desktop]
    GW[Web gateway<br/>dev-dot.li]
  end
  subgraph D[Your dApp]
    BUNDLE[Static web bundle<br/>.dot name -> content]
  end
  subgraph S[Developer tooling]
    SDK[Product SDK<br/>@parity/product-sdk]
    HOST[Host API<br/>@novasamatech/host-api]
    CLIS[CLIs: pad / dotns / cdm]
  end
  subgraph P[Platform services on Paseo]
    NAME[DotNS naming<br/>Asset Hub contracts]
    STORE[Bulletin content storage]
    ID[Identity + personhood<br/>People chain]
    MONEY[CASH + assets<br/>People chain / Asset Hub]
    CONTRACTS[PolkaVM contracts<br/>pallet-revive + CDM]
    BROWSE[Browse directory<br/>Publisher registry]
  end
  APP --> BUNDLE
  GW --> BUNDLE
  BUNDLE --> HOST
  BUNDLE --> SDK
  SDK --> HOST
  CLIS --> NAME
  CLIS --> STORE
  CLIS --> CONTRACTS
  HOST --> ID
  HOST --> MONEY
  NAME --> STORE
  BROWSE --> NAME
  • The Polkadot app keeps keys on-device, runs Products in a sandbox, and exposes the Host API.
  • Your app is a static web bundle addressed by a .dot name.
  • The SDK and CLIs help you build, name, publish, and connect a Product.
  • The platform services provide naming, content storage, identity, money, contracts, and discovery.

A tour of the pieces

The network

The Devnet runs on the community-operated Paseo network: a relay chain plus system parachains. App developers mainly target Asset Hub for contracts and assets, People for identity and personhood, and Bulletin for published app bundles. See The network.

The Polkadot app (client tier)

The native clients share one model: keys stay on-device, and Products run in a sandboxed view that talks to the host for accounts, signing, permissions, payments, chat, storage, and chain access. See The Polkadot app.

Naming (DotNS)

DotNS is the .dot naming system. You use it to register a name and point that name at your published Product bundle. See Naming (DotNS).

App delivery

The @parity/polkadot-app-deploy CLI (pad) publishes a built static bundle and updates the .dot name that should load it. The gateway then resolves the name and renders the Product. See App delivery.

Smart contracts and CDM

Contracts run on PolkaVM through Asset Hub. The Contract Dependency Manager (@polkadot-community-foundation/cdm-cli, cdm) helps you build, deploy, and register contracts so downstream projects can install them by name. See Smart contracts & CDM.

Identity and personhood

Identity spans a username system and proof-of-personhood tiers (Lite and Full) on the People chain, readable by any contract through a personhood precompile. See Identity & personhood.

Money (CASH and funding)

"CASH" is the in-app display name for a Devnet digital-dollar asset, spent through a privacy-preserving coin system. You get Devnet funds from the in-app "Get CASH" flow or the external faucet. See Money (CASH & funding).

App discovery (Browse)

Browse is the app directory. A Publisher contract records which .dot apps are listed; clients read that set and hydrate display metadata off-chain. See App discovery (Browse).

Steps for developers

The usual path is:

  1. Build a static frontend with the Product SDK.
  2. Register or choose a .dot name.
  3. Publish the built bundle with pad.
  4. Add contracts with CDM only when your Product needs custom on-chain logic.

The developer packages

The CLIs all target a network preset. For this Devnet, use devnet: pad and dotns use --env devnet; CDM uses -n devnet.

# App development
npm i @parity/product-sdk          # typed platform access (chains, contracts, identity)
npm i @novasamatech/host-api        # the host <-> product transport protocol

# Command-line tooling
npm i -g @parity/dotns-cli          # register and manage .dot names
npm i -g @parity/polkadot-app-deploy # bin: pad — package + publish a dApp
npm i -g @polkadot-community-foundation/cdm-cli            # bin: cdm — build, deploy, register contracts
npm i @polkadot-community-foundation/cdm-env               # resolve a network's contract registry

Common blocker

The Product SDK routes all chain access through the host container, so it is designed to run inside the Polkadot app or the web gateway rather than as a standalone Node process. For automated end-to-end testing there is a thin test host that speaks the real protocol with auto-signed dev accounts.

Start here

  1. Install the app: Android (Play), Android APK, iOS TestFlight, or Desktop. You can also browse dApps in the web gateway at dev-dot.li.
  2. Follow Create an account & get funds.
  3. Explore: get and use CASH, claim a username, and discover apps.
  1. Read the developer getting-started page.
  2. Build and ship a dApp: Build & publish a dApp and Register a .dot name.
  3. Go deeper: deploy contracts with CDM, use platform services from the SDK, and list your app in Browse.

What to expect from a preview network

  • No-value tokens. Everything on the Devnet is for experimentation only.
  • Rough edges. Services are operated by the community and may change or reset.
  • Operator-provided details. The concrete --env network name and live chain endpoints are supplied by the team running the network; this documentation uses package names, contract shapes, and public URLs that are stable across those details.

Learn more