Set Ryno up

Nothing on this page is on the road to your first deep link. These are the side doors: the list you already keep in a spreadsheet, the window tuned to the machine you are on, the assistant you want to hand the project to, and the one subject that has to be said plainly — what Ryno measures about the way you use it, and what it never looks at.

Bring an existing list in

A team that adopts Ryno rarely starts from nothing. There is a spreadsheet somewhere with a column of links in it, and retyping it is not a plan.

Open the importer from the File menu, at Import from CSV…, or with I. That key belongs to the menu rather than to the window, so it is one of the few that works the same wherever your cursor happens to be. The command palette carries the same entry if you would rather not reach for the menu bar.

The importer walks four steps, named across the top so you always know how far in you are: Upload, Map columns, Conflicts, Done. The third is skipped outright when no name clashes, which is the common case.

Ryno guesses the columns, you correct it

Drop the file in and Ryno reads its header row, then guesses which column feeds which field by looking at the names. A column called link, href or redirect is taken for the link; name or label for the title; note or comment for the description. French headings are recognised too, since that is what half of these files turn out to hold.

A guess is only a guess, so every column is listed with a sample of its first value and a dropdown to re-point it. Four choices: URL, Title, Description, or — Ignore — for a column that feeds nothing. A column feeds at most one field, and a field takes at most one column, so pointing a second column at the title quietly releases the first.

The link column is the one you cannot skip. When no header matches, the guess comes back empty and the import stays out of reach until you pick a column yourself. Nothing else is required: a file that is nothing but a column of links imports fine, and each request is named after its own address.

You also pick where the requests land, and you can create a collection from inside the importer rather than backing out to make one first.

A row that cannot become a link is left behind, not in the way

A row is importable when its link carries both a scheme and a host — the same test the editor applies to anything you type by hand. A row that fails it is dropped, with its row number and the reason, and the import carries on. One bad cell in a file of two hundred is not a reason to refuse the other hundred-and-ninety-nine.

The last step counts the outcome three ways, and the three mean different things:

• Imported — rows written as request files.
• Errors — rows whose link was malformed or missing.
• Skipped — rows that would have overwritten an existing file and were left alone.

Under the counters is a log, one line per incident, with the row number so you can go back to the spreadsheet and fix the source. The same lines are kept in a journal at the foot of the sidebar after the window closes, so a report you skimmed too fast is not lost.

Three ways out of a name clash

Requests are files, and two rows can want the same file name. When any do, the third step appears and asks once, for the whole import:

Outcome	What happens to the existing file
Overwrite	It is replaced by the imported row.
Skip	It is left untouched, and the row counts under Skipped.
Duplicate	It is left untouched, and the row lands beside it with a number appended — checkout.json stays, the newcomer is checkout-1.json.

Duplicate is the one to reach for when you are not sure. It costs you a cleanup and it loses nothing, whereas Overwrite is the only choice on this screen you cannot undo from inside Ryno.

Open the settings

The settings open on ,, with a rail of sections down the left. Everything here is a setting of this machine: none of it is written into your project, and none of it travels to a colleague who clones it.

Section	What it holds
Workspace	The folder this window has open, where it keeps its files, the ones you opened recently, and the remote it was cloned from.
Android · adb	Which adb Ryno is driving, restarting the daemon when it wedges, and pairing a phone over Wi-Fi.
iOS · xcrun	The Xcode tooling, and how often simulators are counted again.
Account	The work account you are signed in with, and a way to sign in or out.
MCP	The local server that lets an assistant read and drive the project, and what it may do.
Privacy	Whether anonymous usage data is sent, and the two screens that let you check it.
Updates	Whether Ryno asks whether a newer version was published.
Appearance	The theme.
Shortcuts	Every action, with the keys that reach it.
What's new	Every version, and what it changed.
About	The version you are running, and a way back to the documentation.

Two of those rows are not on every machine. The device sections are built from the families this computer can actually drive, so iOS · xcrun exists only on macOS — elsewhere it is absent rather than greyed out, and if a machine could drive nothing at all the whole device group would be gone with it. A screenshot of this window taken on a Mac is therefore a screenshot of a Mac, and a colleague on another system is not missing anything: there is nothing there to miss.

Pick a theme

Appearance holds one control, with three positions: System, Dark and Light. System follows the light or dark setting of the machine and keeps following it, so a desktop that flips at sunset takes Ryno with it.

The choice is a setting of the app, not of the project, and it survives a restart. You can also toggle it from the command palette and from search, without opening the settings at all — and doing so leaves System for an explicit one, which is what you asked for the moment you toggled it by hand.

Look up a key you have forgotten

Shortcuts lists every action Ryno binds, grouped the way you would look for them: General, Run, Sidebar, Editor, Tabs, Environments, View. A search box at the top filters the whole sheet at once, which is faster than remembering which group an action was filed under.

The keys are drawn for the machine you are reading on. On a keyboard without a Command key the modifier is Control, and the sheet says so rather than leaving you to translate.

Newer versions, and what changed

Updates is a single switch: whether Ryno asks, on its own, whether a newer version has been published. Off means off — no request goes out at all.

What's new is the other half. It lists every version and what changed in it, so the note that greeted you after an update is still readable a month later, along with everything you missed before you started paying attention.

What Ryno measures, and what it never sees

Ryno is used to test links that belong to other people’s products. A link like com.client.app://checkout?token=… carries a client’s name, a client’s routes and sometimes a client’s secret. None of it has any business leaving your machine.

So the promise is narrow and worth reading twice. Your requests never leave this machine: no URLs, no schemes, no package names, no path or query values, no environment variables, no file, folder or workspace names. Not shortened, not hashed — never collected in the first place.

What Ryno can send instead are shapes: that a request used variables, how many query parameters it had, which kind of scheme it was. Knowing that people use variables decides something. Knowing which ones decides nothing, so it is not collected.

Nothing is sent until you say yes

The question is asked once, after you have opened your first project — not at the very first launch, when you have not seen enough of the app to have an opinion. Two answers, side by side, the same size: Enable or Don't send.

There is no Not now, and that is deliberate: a question that comes back is a question that wears you down. A refusal is final and is never put to you again. Until you answer, nothing is queued and nothing is sent — a refusal loses no data, because none was being held back waiting for it.

You can change your mind either way in Privacy, where the switch is Anonymous usage data. Turning it off takes effect immediately, deletes the random identifier that stood for your installation, and clears anything still waiting to go.

If your organisation has decided for you, the switch is shown off and disabled, and says Disabled by your organization rather than pretending to be a control you could move.

What travels with every event

Each event carries a small bag of context about the machine, and nothing else. This is the whole of it:

Sent with every event	What it says
telemetry_schema_version	Which version of this very list the event was written against.
session_id	A random number for this run of the app, drawn again at every launch.
os	Your operating system family.
os_version	Its release number.
arch	Your processor architecture.
app_version	The version of Ryno you are running.
locale	The language your system is set to.
timezone	Your timezone, as your system reports it.
device_platforms	Which kinds of device this machine can drive — never which devices.
adb_source	Which adb is in use: the one Ryno ships with, or your own.

The list of events themselves is longer, and it is in the app rather than here, because a copy on a website is a copy that can fall behind.

Check it rather than believe it

Ryno is used by people who can put a proxy in front of an app and watch what comes out. Two screens in Privacy are there so you do not have to:

• What is collected lists every event Ryno can send and every property it may carry. It is not written by hand — it is generated from the list the code enforces, so it cannot describe a version of the promise that is no longer true.
• View collected data shows the last events that actually left this machine, exactly as they were sent. Not what was intended: what went out.

The list is enforced, not merely documented. A property that is not on it is stripped before anything is queued, even when it was added by mistake while somebody was instrumenting a feature. That is why the promise is worth making at all: it does not rest on anyone remembering it.

Privacy policy opens the policy itself, kept in the repository with its history, so what changed and when is something you can read for yourself rather than something you are asked to trust.

Let an assistant drive your project

Ryno can expose the open project to an assistant over the Model Context Protocol: reading your collections, writing new ones, running a link on a device if you let it. It runs a small server on this machine only — the loopback address, never a network interface — and it is off until you start it.

Turn it on in MCP, then paste this in a terminal to register it with Claude Code:

claude mcp add --transport http ryno http://127.0.0.1:8791/mcp

Any other client that speaks the same protocol can be pointed at the server address, which the pane shows next to a button that copies it. The port is yours to change while the server is stopped, and locked while it runs.

Grant only what you need

Permissions are per action, they apply the moment you flip them, and reading is separated from writing throughout. Reads are on to begin with; anything that changes a file, or reaches a device, starts off.

Permission	On by default	What it lets an assistant do
Read open projects	Yes	See which projects are open, and nothing inside them.
Read collections	Yes	List your collections and read the requests in them.
Modify collections	No	Create, rename, move and delete collections and requests.
Read environments	Yes	List environments and read the shared values.
Modify environments	No	Set shared values.
Read flows	Yes	List flows and read their steps.
Modify flows	No	Create, update, rename and delete flows.
Read devices	Yes	List the Android devices that are connected.
Run requests	No	Send a link to a device.

Local values are never handed over, whatever you grant. The variables you marked as local — the ones kept out of your repository, holding the token that would let somebody act as you — are outside every permission on this list. There is no switch that turns them on, which is the only form of that guarantee worth having.

Start with the reads. An assistant that can list your collections and read your requests is already useful for the thing people actually want from one: answering what is in this project without opening thirty files. Grant Run requests when you have decided that a link going out on your phone, without you pressing anything, is something you want.