Each app on this desktop does one thing. The interesting work happens when you chain them — extract text with a regex, diff the change, keep the patch; query a CSV, reshape the answer; render a diagram, edit the markup. The seam that makes that possible is the Stash: a shared data hub every app can write into and read from. This piece is about how routing actually works, so you can predict where a Send will land before you press it.
The Send ▾ button
Any app that can produce something carries a Send button in its toolbar. Press it and you get two things:
- Open in — a list of apps that accept what you're holding. Pick one and it opens (or focuses) pre-loaded with the item. This is a direct handoff: the item is queued for exactly that app and consumed the moment it mounts.
- Save to Stash — drop the item into the shared bank without leaving. It sits there until you pick it up from another app, or from the Stash itself.
Both paths go through the same bank — a direct send also banks the item, so nothing is ever lost if the receiving app wasn't what you wanted. The bank keeps up to 100 items. Text-ish items (text, JSON, CSV) persist in your browser's localStorage across sessions; file items — images, audio, PDFs, fonts — live for the session only, because a blob is too big to serialise and never worth uploading.
What routes where
Every item has a kind, and each kind has a fixed list of receivers. This is the actual routing table, in the order the menu shows them:
| Kind | Opens in |
|---|---|
| text | Editor, Notes, Diff Viewer, Regex Lab, Convert, Crypto & Hash |
| json | Convert, Editor, Notes, Diff Viewer |
| csv | SQL Playground, Convert, Editor, Diff Viewer |
| image | Squeeze, Image Studio, Archive |
| audio | Player, Audio Studio, MediaInfo, Archive |
| PDF Toolkit, Archive | |
| font | Type, Archive |
| binary | Archive |
Only apps that actually receive a kind are listed — the menu never opens an app that can't take the item — and the sending app is excluded from its own menu, so SQL never offers to send a result set to SQL.
One deliberate oddity: a dropped .svg file routes as text, not image. SVG is markup you edit far more often than a raster you recompress, so it goes to the Editor rather than Squeeze. If you want to recompress a rendered SVG, rasterise it first.
Drop a file anywhere
You don't need an app open to start a pipeline. Drop a file anywhere on the desktop and the OS classifies it by extension and MIME type, then routes it:
- One app takes that kind — it opens directly, pre-loaded. A dropped
.pdfgoes straight into a chooser between PDF Toolkit and Archive; a lone binary goes straight to Archive. - Several apps take it — you get a small chooser listing them. A
.csvoffers SQL, Convert, Editor, Diff. - Nothing takes it — the file lands in the Stash with a notification, so it's still there when you decide what it is.
The Files app is the same idea as a browser: select any file and its Send menu offers the receivers for that file's kind. Anything you can see in Files, you can open anywhere — which makes it the universal source at the head of most chains.
Three real pipelines
1. Extract with a regex, diff the change, keep the patch. Paste a messy log or config into Regex Lab, build the match-and-replace against the live highlight, then Send the cleaned result to the Diff Viewer. Paste the original alongside it and read the word-level diff — you're reviewing your own transformation before trusting it. Happy? Send the text on to Notes to keep it. Three apps, no copy-paste through an external editor, and the intermediate lives in the bank if you need to back up a step.
2. CSV → SQL → answer → CSV → JSON.
Drop a .csv on the desktop and pick SQL Playground from the chooser — it imports as a table. Write the GROUP BY or window function that answers your question. The Playground's Send hands off the first result set as a fresh CSV (same construction as its Copy CSV button), so send it to Convert and turn the answer into JSON, YAML, or a .env for whatever consumes it next. The original import and the result both sit in the bank, timestamped.
3. Graphviz → Editor.
Describe an architecture in DOT in Graphviz and the Send button hands off the rendered SVG — not the DOT source — as a text item named graph.svg. Send it to the Editor to tweak fill colours or strip the XML prolog by hand, or to Notes to keep it beside the doc it belongs to. Because SVG routes as text, the whole text row of the table is open to it: you can even Diff two renders to see exactly what a layout change moved.
The trap: a handoff is consumed exactly once
A direct send queues the item for one app id and the app takes it on mount — once. If the target app was already open, it receives the item and replaces what it was showing; there is no merge. And if you send two things to the same app back to back without letting it open in between, the second overwrites the first in the queue — only the latest handoff is pending per app. The bank is your safety net: both items are still in the Stash, so open it and re-send the one that got skipped. Rule of thumb: direct send for the next step, Save to Stash for anything you'll want twice.
The other subtle one is persistence. Text items survive a reload; blobs don't. If your pipeline has an image or PDF mid-flight, finish the chain in the session — after a refresh the text half of your bank is intact and the file half is gone. That's by design (nothing is uploaded, ever), but it surprises people the first time.