A streamed app should take part, not just be watched
You can stream almost any Windows app without touching it. That is a feature, and also a ceiling. Here is what lies above it.
By the Onscryn team · November 15, 2026 · 7 min read
The easiest way to put a Windows app in a browser is not to touch it. You run it on a host, capture its window, and send back the mouse and keyboard. It works for software you bought, software you inherited and software nobody understands any more. That is a real advantage, and it is the right starting point for most of the apps in most organizations.
It also has a ceiling, and the ceiling is the same for every tool that works this way. The app does not know it is being streamed. Everything the browser gets, it gets by watching.
What watching cannot give you
Watch an app from outside and you see its pixels. You can find its buttons, because the operating system describes them, and you can click and type. You cannot easily ask it a question. You cannot ask for the order that is open, or the total on the invoice, except by finding the right label and reading its text.
You also cannot make it generous. A report that finishes cannot hand its PDF to the person who asked for it. A link inside the app cannot open in the person's own browser. A print command ends up on a printer that does not exist. All of these are small, and together they are the difference between an app that works in a browser and one that feels at home there.
What changes when the app cooperates
Suppose the app links a small library. It still draws its own windows and runs its own logic. But now it can say what it drew, so the picture comes from the app itself and not from a screenshot of it. It receives input in its own window without anyone guessing where the cursor is. It can send a file or a link to the person using it, as an ordinary function call.
None of that needs a rewrite. It is a handful of calls added to code that already exists, around the edges of what it already does.
The bigger prize is automation
The real step up is that an app can expose functions. Register a function called getOrder, and automation can call it by name and get the order back as data. No screen to find, no layout to survive. Register a few more and a workflow can read the day's orders, approve the large ones and write the outcome somewhere else, all without a human or a browser.
That turns a closed application into a part of the system around it. It is the thing legacy software has lacked for decades, and it is available to any team that can change its own code.
When it is worth it
Do not do this for everything. The cost is real, even if small, and for packaged software it is impossible. A reasonable rule has three parts.
- If you cannot change the app, stream it from outside and be happy.
- If you can change it and people use it daily, add the library and start with files and printing, which users notice at once.
- If other systems would benefit from its data or its actions, expose a few functions and let automation call them.
Notice that the choice is per application. An organization can stream a dozen vendor tools from outside and take part in one internal app, and nobody has to choose a side.
Start where you are. Stream the app as it is, see who uses it and for what, and spend the effort of integration only where it buys something people will notice.