How dependencies are handled
When you run an app in Apptrope, you don’t have to install anything by hand, edit your system, or worry about one app breaking another. Apptrope reads what each app needs, resolves it, and builds a private environment just for that app. The first run does the resolving and locking. Every run after that reuses what was already prepared. This page explains what happens under the hood so you know exactly what Apptrope touches (and, just as importantly, what it doesn’t).
The short version
- Every app gets its own isolated environment. Nothing is shared between apps.
- No global installs. Apptrope does not add packages to your system-wide R or Python.
- No version conflicts. One app can use an old version of a package while another uses a new one, side by side.
- Nothing on your system is touched. Your existing R, Python, and installed packages are left exactly as they are.
- First run resolves and locks. Later runs reuse. You pay the setup cost once.
What resolves what
Apptrope picks the right resolver based on the kind of app you’re running.
| App type | Resolver | What it does |
|---|---|---|
| R apps | rv | Resolves each R app’s packages and writes a lock so the exact set is reproducible. |
| Python apps | uv | Resolves each Python app’s packages into the app’s own environment. |
| R apps with no system R | micromamba | Provisions a portable R toolchain so the app can run even when R isn’t installed. |
Whether your app is Shiny (R or Python), Streamlit, Gradio, Flask, Panel, Voila, Marimo, Dash, Bokeh, Solara, or a bare Python web app, the same principle applies. Apptrope figures out the dependencies and keeps them contained to that app.
R apps: rv resolves and locks
For an R app, Apptrope uses rv to work out the full set of packages the app depends on and to lock them. Locking means the resolved set is written down, so the next run uses the same versions rather than re-resolving from scratch. That’s what makes runs repeatable and fast after the first time.
The resolved packages live in the app’s own environment. They are not installed into your system R library, so nothing you’ve set up elsewhere is disturbed.
When you don’t have R installed
If Apptrope can’t find R on your system, it can provision a portable R toolchain via micromamba. This lets R apps run on a machine that has never had R installed, without you needing to install R yourself.
A “Portable R installed / Remove” control appears at the bottom of the app once a portable R has been provisioned. If you ever want to reclaim the space, you can remove the portable R from there.
Python apps: uv resolves per app
For a Python app, Apptrope uses uv to resolve the app’s dependencies into an environment that belongs only to that app. Because each Python app is resolved independently, two apps that need incompatible versions of the same library will each get what they need without stepping on each other.
First run vs. later runs
Here’s what the two-phase behavior feels like in practice:
- First run: Apptrope resolves the app’s dependencies and prepares its environment. This is the step that takes a little longer, because it’s doing the real work of figuring out and preparing everything the app needs. The full output is captured in that run’s logs.
- Later runs: Apptrope reuses the environment that was already resolved. There’s nothing new to install, so the app starts more quickly.
If you ever want to watch what’s happening during a run, open the per-run logs, where the full output is captured live.
One environment per tab
The Workbench is multi-tab. You can run several apps side by side, and each tab has its own environment. Running three apps at once means three separate, isolated environments. Nothing leaks from one tab to another, so an app in one tab can’t change the packages another app depends on.
Inspecting an app’s environment
Each app in your Library has a per-app ⋯ actions menu. From there you can choose Environment… to look at the app, along with the other actions available for it (Open, Rename, Pin, Remove, View logs, and Export bundle…).
What Apptrope does not do
To be completely clear about the boundaries:
- It does not install packages into your system R or Python.
- It does not modify globally installed packages or their versions.
- It does not require you to manage virtual environments yourself.
- It does not let one app’s dependencies affect another app’s.
Every app stays in its own lane. That’s the whole idea. Point Apptrope at an app, and it takes care of the dependencies without touching anything else on your system.