Gno Application Factory

The factory

The factory is a repeatable way of making on-chain software, not a pile of contracts. Each application goes through the same lifecycle, and each stage leaves a public artifact you can read: discovery records, composition decisions, test results, audits, byte-matches and deployment records.

1. Discover

   Search what already exists — on the chain and in the ecosystem — before writing anything. Every build decision starts from a committed discovery record.

2. Compose

   Prefer assembling verified, reusable packages over new infrastructure. The applications here import the same primitives offered to you.

3. Build

   Write the smallest realm that completes the objective, in the open, with its design decisions written down.

4. Test

   Unit tests, file tests and adversarial cases against a chain-matched toolchain, with the dependency set proven to match the target chain before a green result is believed.

5. Verify

   Audit the code, byte-match the deployed bytes against the committed source, and record what was checked — and what was not.

6. Deploy

   Deploy to gno.land with the transaction, cost, live verification and known limitations written into a permanent record.

Already live

This is not a roadmap. On the pearl-1 testnet today:

Every deployment has a transaction hash, a byte digest and a written record. Nothing on this page is aspirational.

Applications and packages

Applications are complete on-chain realms — marketplaces, bounty systems, grants programs, vaults, fee splitting, registries. They demonstrate what the factory can build.

bountiesbounty_panelcoindemoduebook_demofee_splitgrantsmarketpermbook_demopermission_registryservice_marketservice_registrysubscriptionstimelock_guardianupgrade_registryvault

All applications, with provenance →

Packages are the reusable primitives those applications are composed from. They demonstrate what you can build with.

The packages, with their APIs →

Check, not just trust

Every important claim here is checkable against the chain, a generated artifact, or a committed record. Each package page shows the transaction that deployed it, the digest of the bytes the chain is running, what was proved about it, and — stated as plainly as the rest — what was not.

You do not need our tooling to test the central claim. This fetches the bytes pearl-1 is actually executing for one package and prints their digest:

curl -sS 'https://pearl.testnets.gno.land/p/g1ut6uspuh73e02yauxpmyt8g3wwddaq8utagvm3/coinio$download&file=coinio.gno' | shasum -a 256

The result should equal the sha256 on that package's page. The verification model in full →

Start building

Import a verified package into your own realm — on gno.land the import path is the deployed address — or call a live application from the command line with a generated call. The whole journey, one page →

An ecosystem, not a contract collection

The factory is the foundation. On top of it sits the software — applications and the packages they share — and around the software, the people: developers who import the packages, users who call the applications, contributors who improve both. That is the ecosystem this site is the home of, and it stands on its own: everything described above exists today and works without any further layer.

Participation has a future shape too: contributions — code, documentation, testing, research — and, later, a distribution and community layer ($SHAMS) introduced around the working ecosystem. None of that is live yet, and this site will not pretend otherwise — how participation will work.