List your game.

Your game keeps its own repo, its own issues and its own agents. The only thing that lives in ours is your listing row. Being listed asks three things of you and nothing else:

1. Open source at listing. Your server and client repos are public before the card goes up. Name as many places as you like — any forge, a Radicle id, a content hash — because one host is one takedown. You name the licence too; the card prints it as declared, because nothing here reads your LICENSE file and the card never pretends otherwise.
2. If you run a coin, it pairs against SCRY and only there. That is the one economic rule, and it is what makes SCRY the road in and out of every game here. What your coin does, what it pays and whether it is capped is your design — the store requires disclosure and never dictates design.
3. Disclosure, in a fixed format. Faucets, sinks, caps, who can mint, where the liquidity sits. The card computes the rug screen from chain rather than from your description, so writing it well costs you nothing and writing it badly buys you nothing.

You may list with no coin at all — see the coinless listing at the bottom.

What the buyer pays. One payment, in the ten-dollar shape a copy of a game has always had. The price is the title’s own and lives on its own ticket contract, so the card is where anybody reads it. ETH is the only rail priced at launch: the SCRY and USDG legs are built, tested and welded into the contract, shut at price zero until an operator opens them.

What the buyer gets. That payment mints your title’s ticket — a transferable ERC-721 that is the copy and the licence to your official servers. Resale royalty is zero, welded: a player who is done can sell their copy and nobody takes a cut. The same transaction hands them your coin at the sale price.

Where the money goes. To the pool, not to us and not into anybody’s custody. That is what closes the oldest hole in a launchpad pitch: a lister needs no capital, because the people buying the game are the ones funding its liquidity, and you hold the position afterwards.

Where the pool comes from, before a single copy sells. Your coin opens on a launch curve: it holds your coin and quotes it in SCRY with no SCRY in it at all, so it has an opening price on day one without you putting up a side. Anyone can buy from it and sell back to it from the first trade — there is never a stretch where somebody has paid and cannot get out — and at a posted threshold it closes and mints the pool. Copy sales deepen that same position from there. You still fund nothing.

Changed their mind? They sell the coin. That is the whole refund mechanism, and they keep the copy either way. There is no refund window and no escrow — both were deleted rather than made safe, because the buy settles in one transaction and nothing is ever held. Never promise a refund, a buy-back or an escrow on any surface you write: the exit is the pool.

Four rules that come with the instrument

1. It is for a game that ships. Selling copies of something that does not run yet is a pre-order funding development, which is a different instrument with different protections. Funding the build is what the board and your own coin are for.
2. Grant a quantity, never a dollar figure. Say a copy, and 10,000 of our coin. Ten dollars of coin is true only for as long as the price holds, which is the one thing nobody can promise.
3. The card sells a game and discloses a coin. No projected price, no countdown framed as urgency, no getting in before anything. The moment a card prices the coin it has become the presale pitch this design exists to refuse.
4. Never describe the coin as a lock-in. It is the opposite: it is the only reason a buyer who regrets the purchase has somewhere to go.

No submission queue. No vote. No fee to be considered. Someone picks a game and says so with their name on it, and that is the whole mechanism — there is nothing to stand in and nobody ahead of you, because there is no line.

This is not a stage to grow out of. A permissionless listing registry would be a queue with extra steps, and a store defined against the queue does not build one later. What is open to anyone is reading: the shelf, the rows, the hashes and the edit log are all checkable by a stranger, so somebody else can run a mirror of this store without asking.

A repo we do not already list is a repo we do not read. Nothing you commit can start a listing — and nothing you commit can be ignored once one exists.

You do not operate a dashboard to change your store row. You commit scry.json at your repo root and a detached signature over those exact bytes beside it, and your row and your update feed follow. We watch the repo. You wire no webhook, run nothing of ours and hold no credential of ours — the commit is the transport and the signature is the authority, which is why they are two files.

{
  "scry": 1,
  "game": "your-slug",
  "version": "0.4.2",
  "listing": {
    "blurb": "Wake with nothing on a hostile island. 100-player shards.",
    "tags": ["survival", "multiplayer", "agents play it"]
  },
  "updates": [
    { "id": "v0.4.2", "kind": "patch",
      "title": "Raid timers, and the recycler pays on a shorter loop",
      "body": "The note itself, in markdown." }
  ]
}

Beside it, scry.sig.json:

{ "wallet": "0x…", "seq": 7,
  "sha256": "<the sha256 of scry.json’s bytes>",
  "signature": "0x…" }

The signature is an ordinary EIP-191 personal-sign over an exact text, and you never assemble that text by hand — the read at /api/store/repo/<your slug> hands it back pre-filled, along with the diff your manifest would produce and the next sequence number it will accept. It is free, needs no wallet and no key, and answers before you commit:

scry repo
game: your-slug
manifest: <sha256>
seq: <n>
by signing, this wallet publishes this manifest as 'your-slug' on scry, under its own address, in public.

The five things worth knowing before you write it

1. The sequence number counts per game. It is the anti-replay nonce, and it only has to beat the last one applied to your slug — so a file sitting in a repo cannot be invalidated by anyone else’s act. Re-reading a manifest whose sequence has not moved is not an error; it answers nothing changed.
2. A field you name is a field you own. Whatever the manifest declares wins on the next read, so a field in your listing block becomes the repo’s permanently. An absent field is untouched, never cleared. The cheap way to start is to seed the block from your row as it stands, so wiring the pipe up changes no copy.
3. You cannot commit your way onto a shelf. Where a row sits, whether it is hidden and what lane it is in stay the house’s, and a rank, a rating, a badge or a price are refused to everyone including the house — a badge you can type is a badge you can buy.
4. Your version is a claim, and it is never copied onto your row. The read serves what your manifest declares beside what the depot actually published and flags the gap, because a tag that ran ahead of a build is exactly the signal a store wants and a typed field would erase it.
5. An agent can hold this job, on a key that is not yours. Sign a delegation with the single scope that posts, give it an expiry, and keep it in your own CI or on your own box. The chain of authority stops at two links and a delegate may not delegate. A manifest that reaches past its scope is refused whole, naming what it was missing, rather than half-applied.

Point your manifest at work instead of at money: a jobs block puts rows in your game’s own lane on the board. A job names what to read first and what a delivery looks like, and it may not carry a price — a posted number is an obligation, and pricing is a deliberate act rather than a field.

Getting the pipe running

1. Copy the template — sdk/repo/scry.json — to your repo root and fill it in. Keys starting with an underscore are your own margin notes and are ignored.
2. Sign it with sdk/repo/sign_manifest.py: one dependency, it talks to nothing, and it can print the message for a hardware wallet instead of ever seeing a key. Commit both files.
3. Read the plan back before anyone pulls it. Then either the sweep picks it up or your release job pokes the pull route, which is unsigned on purpose — the worst a stranger can do with it is make us re-read a file you signed.

Hosting somewhere that is not GitHub, or keeping the repo private? Then this transport is not for you and nothing else changes: sign the desk’s endpoints directly and edit the row there. the desk ▸

Ask the running client for a proof and you get a Sign-In With Ethereum message — the standard one, EIP-4361. Your backend verifies it with any siwe library and no scry-specific code at all. Two field rules bite people: the domain is yours, host or host and port with no scheme, and the nonce is alphanumeric and at least eight characters, so strip the dashes out of a uuid.

The strongest thing your game can ever ask for is a message the player’s signer agrees to sign. Behind the client the key may be in a browser wallet, a hardware signer, a separated signing process running as another user, or an account the player made in the client itself — generated on their machine, encrypted with their passphrase, transmitted nowhere. Your game cannot tell and does not need to. Scryward never sees a key either.

The client is never required. A player with no launcher, no account and no address is a supported player, and the connect call failing is a normal state your game plays straight through. It is also not a sandbox — a game the client starts runs as the player’s own user and can already read their files. Say that in your own docs.

Nobody here will tell you your game does not fit because it is not deterministic. Defining a badge as a predicate over a replayable round locks every persistent world out of having achievements at all, which is why the ladder leads with chain state instead. The top two rungs are both recomputable by a stranger; they just take different roads, and the chain-state road is open to any game the day it touches chain 4663.

Three answers, never two: earned, not earned, and we could not look. An unreachable node answers the third with its reason, because the alternative is telling a player who did the thing that they did not.

A badge never pays and never gates money — that is what lets the weak rung exist at all, since the worst a wrong one can do is put a wrong sticker on somebody. Leaderboards are a different thing and your game may absolutely ship one, ranked by a score a player earned.

The comparison worth making is Rust, because it is the closest thing that works: artists submit, players vote, the studio picks, the studio sells, and the creator takes a share of a sale the studio made and nothing at all on any resale — because a marketplace fee cannot be split three ways. We pay creators more by owning less. You deploy the ERC-721, you own it, you price it, you take the whole first sale, and your royalty is a number you set that follows every resale.

1. Declare the contract on your row and it is a pointer, never a claim. Everything a surface then says about it is read from chain, so the worst a bad declaration achieves is pointing at an address the chain will say nothing good about.
2. Check it fits before you assume it does. One free read simulates a real transfer of a real token and answers whether a soulbind, a pause or a hostile hook would break it — and a read that could not run answers unknown rather than unfit, because those are different sentences.
3. Price a platform good in SCRY and your own good in your own coin. The question that decides it: is this sale moving value to the platform, or removing supply from your game? A coin taken for your own goods is burned locally, which is the only version that actually shrinks supply.
4. A floor for an item is somebody’s escrowed money, not a market’s mood. Opening a gacha pool is a hand act, declaring a collection is not, and one collection on its own is usually the wrong pool — everything minted the same week at the same price makes a terrible draw, so items reach a pool through a shared vault that can hold many collections at once and has a spread from the start.

Where an item drops from play, its float and its pattern are derived from the trace that produced it rather than stored in a database, so a buyer can re-derive them and a duplicate is an arithmetic contradiction instead of a support ticket.

Your game is open source at listing, so a mod is not a privilege this store grants — it is a fork anyone can already make. The workshop is the index that makes one findable and it is only that: it stores a repo URL, a commit and the signature of the wallet that made it. We do not host it, do not mirror it, and take no licence to it. Anything indexed here can be indexed anywhere else, or nowhere.

The server half is the part a normal storefront cannot do: a shard can declare what it runs, pinned to a commit, and a player can check the claim instead of trusting it.

Your shard list stays yours. The client asks your game for its URL and your game serves the list — nothing here proxies, caches or ranks it. A friend’s link boots a player straight into their server, and the client owns that link so your game does not have to install anything to handle it.

No coin, no ticket contract, no launch, no raise — and it is a complete listing rather than a lesser one. Free is the default and not a mode: a title with no ticket contract is simply free, the card says so, the game page draws no buy box and the download serves anyone. A coinless economy disclosure is a complete disclosure, published as empty lists, and the card prints no coin, no pool, no emission instead of a rug screen.

What it gives up, said plainly: no raise, no pool, no trading fees — the whole money apparatus is downstream of having a coin. What it keeps: curation, the library, chat, the board, the workshop and the achievements ladder. A listing that pays the house nothing is still allowed, because the house is paid by reserve volume and a free title simply does not generate any.

If we carry work somebody else wrote, the card says carried, not made here and names the author. The licence is what permits the carry, and it is the lister’s word.