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. Browse the packages →

3. Build

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

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. How verification works →

6. Deploy

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

Already live

This is not a roadmap. Deployed and byte-verified today, on the gno.land mainnet and the onyx-1 testnet:

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.

Those three are not a curated pick: they are the applications that compose the most first-party packages, ranked from the catalog and re-ranked whenever it changes. Every chip above is an import the chain reports.

assetsauctionbooksbudgetscashflowcrowdfunddepositsfee_split/v2inventoryinvoiceslatefeesloansmetersnettingpayrollpayslipspermission_registryreceivablesreimbursementsrevsharesealedbidservice_marketservice_registrystatementssubscriptionstimelock_guardianupgrade_registryupkeepvesting

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 →

Don't trust, verify

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 onyx-1 is actually executing for one package and prints their digest:

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

The result should equal the sha256 on that package's page. Each deployment carries its own command, against its own chain. The verification model in full →

Start building

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 — recognized around the working ecosystem. None of that is live yet, and this site will not pretend otherwise — how participation will work.