install the scry launcher

scry never sees a key. That is the rule, and it is a rule about scry rather than about this program. The client can hold a key, and it says so when it does. scry account new generates a secret on your machine from the operating system's entropy, encrypts it with a passphrase you choose, and writes it as an encrypted V3 keystore — so while that account is unlocked, this process is holding the key. It is generated locally, encrypted with your passphrase, and transmitted nowhere. Point the client at a browser wallet or a hardware signer instead and it holds nothing at all.

Making one prints the address out loud so you know what you just made and that it is empty, asks the passphrase twice, and refuses rather than overwrites if an account is already there. Nothing underneath is hand‑rolled: the standard curve, keccak, scrypt and AES libraries do the work, because a novel key routine leaks with no symptom until somebody else has the money.

The exit was chosen before the format was. The keystore is the Web3 Secret Storage format that geth, MetaMask, Rabby and cast wallet all open, at geth's own work factor, written readable only by you. An account only this client could open would be a worse deal than no account. Already hold a wallet? Import a key… adopts yours instead of making you a second one.

There is no recovery phrase, and that is the one thing to know before you make one. This client neither generates nor accepts twelve‑word phrases: the encrypted file is the key. Back it up, and keep the passphrase, because nobody — scry included — can reset either. And an address on its own proves nothing here: it is a claim, not a login, so every act that matters asks for a signature.

A server, a CI job or an agent has no display, so everything the Account window does is a command too. Both halves read one keystore, so an account made either way is the same account.

scry account                  # who this machine is (exit 3 if no account)
scry account new              # make one — generated here, sent nowhere
scry account import           # adopt a key you already have
scry account sign "message"   # sign with it, EIP-191

Passphrases are read without echoing where the terminal allows it, and the client says so when it cannot. Nothing in these commands touches the network.

A game never asks you for a key. It asks the launcher, over a local socket, and whichever signer you configured does the private part — the same shape Steam uses so a game never sees your password. Consent is per game, counted, and dies when you close the launcher; there is no “always allow”.

The backend comes from your own settings file and from nothing else — never from a game, a catalog, a manifest or a depot. That is what stops a hostile listing pointing your signing somewhere it chose.

Unlocking is one place, on purpose, and it sits beside the sentences saying what may then be signed. The command line unlocks per command and forgets at exit; the window relocks an account nobody has used for a while, and Lock now is beside Unlock, because forgetting the key should cost one press and getting it back should cost the passphrase.

An account you made in the launcher is a real wallet, but a web page cannot knock on a socket on your desktop. So the page asks for a short code, you carry the code the other way, and the launcher signs.

1. the page shows a code, like ABCD-2345
2. you type it into the launcher — scry signin ABCD-2345, or Account ▸ sign a website in
3. the launcher writes the message itself, shows it to you, and asks once for your passphrase
4. the page reads as you: the heading over your balances becomes what you hold

There is no clickable pairing link, and that is a decision. A code you can click is the classic phish: a stranger pastes their code into a chat dressed as a free mint, and your approval signs their browser in as you. A code you read off your own screen and type into your own launcher cannot be somebody else's. Nobody legitimate will ever send you one to enter. A code lives ten minutes and works once.

Nothing is stored anywhere by this: no session, no cookie, no account row, no password. A signature and a public address are all that cross. And the door carries messages only — it can never move a coin, so buying anything still wants a wallet extension or a hardware signer.

A title publishes its own list of running servers and the window draws the rows: name, address, map, ping, and how many people are on. The launcher does not invent, cache or rank them, and it does not average a count into the document either — a number baked into a file is stale the moment the file is written, so each row may name where that shard answers for itself and the window asks it. A shard that does not answer keeps whatever the row said, and a count nobody could read draws ? rather than 0, because a busy shard rendering as empty is the worse mistake. Until a title publishes a list, the window names the field that would fill it instead of drawing an empty grid.

scry servers gates            # the same list from a terminal
scry join scry://join/gates/eu-1.example:7777

The launcher owns scry://join/<title>/<host:port>. A friend sends you that link and the game comes up on the shard they are standing on. The launcher owns it rather than the game for one reason: the launcher is the piece that is installed, so a link for a title you do not own is still useful — it can say what the link is for and offer to get it. A game‑owned scheme cannot, because the game is the thing that is missing.

A link may name a title and an address and nothing else. Not an identity, not a token, not a flag, not a path — anything past the address is refused rather than ignored, because an ignored segment is how an unnoticed one quietly becomes supported. A join link arrives from a stranger by construction; being pasted into a chat window is its whole purpose. On Linux the .deb registers the handler for you; from a tarball, xdg-mime default scry-join.desktop x-scheme-handler/scry.

One window that answers the three questions a support conversation starts with, and one command that answers them without a desktop. scry check prints the platform, the origin it is pointed at, where it keeps games, what is installed, and whether it can reach that origin — then exits. Ask it rather than guessing.

scry check

It also carries the credit the toolkit's licence requires: the window is drawn with FLTK, which is why the binary is small and needs nothing installed beside it.

1 · scry never sees a key. An account made here is generated on your machine, encrypted with your passphrase, and transmitted nowhere. The settings file has no key‑shaped field and drops a hand‑edited one on load, and the crypto is confined to one place by a test rather than by review. Point the client at a browser wallet or a hardware signer and it holds nothing at all — and when it is holding your key, it says so, every time.

2 · Nothing you own lives inside it. A native game may need this client to install and start it — that is what a launcher is for, and a persistent world does not run in a page. What is refused is the other thing: your copy is a token on the chain, your items are tokens, your achievements are a predicate over chain state. Delete the client and you still own everything you bought. Every browser title needs nothing installed at all.

3 · It is not a source of truth. It renders what the origin and the chain say and adds nothing — no local leaderboard, no cached balance shown as current, no invented server list. A failed read reads as “could not reach the origin” and never as “there are none”, which matters more on a desktop than on a page, because a laptop's wifi drops and a page's does not. A launcher that renders “0 games” on a train is lying about the catalog.

git clone https://github.com/AnthonE/scryward
cd scry/launcher-rs && cargo build --release

Two binaries come out: scry, the command line, and scry-gui, the window. Neither needs a runtime installed — that is the whole reason the client is Rust.

Anything erroring? Ask it why instead of guessing — scry check prints the platform, where it keeps games, what is installed and whether it can reach the origin, then exits.