One URL. One deterministic outcome. From anywhere in the app, no matter how fast the next URL arrives. That is the contract. This page maps how Iris delivers it, and where the proof lives. Iris turns deep links into a reliable input language for users, tests, Shortcuts, agents, and automation.
Most apps treat a deep link as a polite front door. A URL opens a screen and that is the whole story. Iris raises the bar: the URL becomes a true input language. Anything that can fire one (a person, a test runner, a Shortcut, or an agent) can drive the app to any reachable state, deterministically, from whatever state it is already in.
Iris collapses racing URLs with cooperative cancellation, resolves the right navigation from current state without polluting the URL grammar, keeps its footprint to a single folder, and can prime a mid-edit draft two sheets deep in one call. One study lays out the principle. The other five present the evidence from a reference demo app. This is the foundation for agentic and automated navigation you can trust.
Deep linking has a reputation as plumbing. A marketing link opens the app, the app opens a screen, and everyone moves on. The contract stays thin because the input is assumed to be rare and polite: one URL, arriving alone, into an app sitting quietly at its home screen.
None of those assumptions survives automation. The moment URLs become the way tests drive the app, the way demo recordings are staged, and the way a Shortcut or an agent reaches a feature, they arrive in bursts, mid-animation, into whatever state the app was left in. A layer that only handles the polite case fails quietly everywhere else: stacked sheets, half-applied navigation, a screen that belongs to the previous URL.
Iris is the layer I built for the impolite cases. It turns one URL into a deterministic sequence of structural navigation steps and side effects, applied in order, with cooperative cancellation when the next URL lands before the last one has finished. Four properties carry the weight.
Every claim in this series is measured against a demo messaging app built as Iris’s consumer. The recordings are captures of that app running; the numbers come from its codebase. The app exists so Iris has somewhere honest to prove itself.
The panel below replays Iris’s signature scenario: six URLs fired in under a second, each cancelling the one before, the last one winning, nothing stacking. The recorded version, captured from the demo app with no animation tricks, opens the case study it comes from.
One study states the principle the others rest on: making the deep-link URL the canonical form of every state-dependent navigation. The five measurements that follow each take one property and show the receipts: scenario tables, measured footprints, recorded races. The last property carries two articles. They read best in order, and each stands alone.
The principle
Five measurements
Five cold-launch burst scenarios, all resolving last-writer-wins. No stacked sheets, no half-applied state, and a trace that proves it.
The containment test for any infrastructure library: a folder name and a low percentage. How the demo consumer answers it.
Keeping URLs short and readable when the right destination depends on where the user already is.
Search, filters, scroll targets, expansion overlays: a closed set of effects, and one apply step every entry point converges on.
Cold launch to a user-ready, mid-edit compose state, two sheet layers deep, in one call. The agentic bar for deep linking.
The studies above measure Iris from the outside, through the demo consumer that fires URLs at it. The internals track goes the other way: four short pieces on the mechanisms inside the library that make those guarantees hold, written for anyone integrating Iris or reading its source.
Iris is an open source Swift package built and maintained by Async Digital, MIT licensed. The demo app this series measures is its reference consumer. The repository is public at github.com/async-digital-ltd/iris, tagged from 1.0.0, listed on the Swift Package Index, and installs as a standard Swift Package Manager dependency.
The series above is the story behind the design; the repository carries the DocC reference and an integration guide for coding agents. If race-safe, state-aware deep linking is a capability your product needs, the package is yours to use, or write to info@async-digital.com. What shipped is what these articles describe.