ARVIO: an open-source media hub for Android TV, phones and the web

A client for media you already own, not a streaming service

ARVIO is a media hub application whose repository is described as a source-code and development mirror for the Android application. The primary language is Kotlin and the UI is built with Jetpack Compose, and the app targets Android TV and Fire TV as well as phones and tablets, with a separate web build at a different address.

The scoping sentence in the README is the one to read carefully. ARVIO does not host, store, sell, or distribute movies, series, live TV channels, playlists, streams or other third-party media. What it does is provide a media browser, a player shell, profile support, optional cloud sync, IPTV playlist support, catalog configuration, home-server integrations and integrations with user-configured sources.

That division shapes who the project is for. The audience is someone who already has the content, whether as a TMDB-backed catalog, an IPTV provider playlist, or a home server running Jellyfin, Emby or Plex, and who wants one interface for browsing and playback across form factors. The project is licensed Apache-2.0 and describes itself as a free hobby project, with the README stating that it is built and maintained with a lot of time, testing, hosting and service costs.

Where the metadata comes from and what the catalogs hold

The metadata layer is TMDB. The feature list names TMDB-powered browsing of movies, series, cast, collections, franchises and metadata, and the self-hosting section makes the dependency explicit by saying you supply your own TMDB, Trakt, Simkl and other integration credentials.

On top of that metadata sit the content sources you configure. IPTV M3U and Xtream playlist support is listed with provider categories, favorites, hidden categories, EPG, and fullscreen playback on phones and tablets. Home-server support covers user-owned Jellyfin, Emby and Plex libraries. Catalog management works with manual URLs as well as public Trakt and MDBList list discovery, and there is third-party addon support for user-configured sources.

The state that travels with your profile is the interesting part. Watchlist and continue-watching state is kept with profile isolation, and the optional ARVIO Cloud sync covers profiles, settings, catalogs, IPTV state, watch state and custom profile avatars. Per-profile Trakt.tv integration is optional and adds watchlist, history, progress and continue watching. Subtitles and audio tracks are selectable, with subtitle language filtering and AI subtitle tools.

Playback runs on ExoPlayer with Media3, and the controls differ per form factor, with TV remote support on the big screen and touch controls on phones and tablets. A Telegram integration is also listed, scoped to searching video files in your own connected channels and groups.

Getting the Android build onto a device without a store

ARVIO is available through official app stores, direct GitHub releases and Obtainium. For a sideloading setup the README recommends Obtainium, which installs from GitHub Releases and then keeps the app updated from there.

Adding the app through Obtainium is a single deep link, which you open on the Android device:

[`obtainium://add/https://github.com/ProdigyV21/ARVIO`](obtainium://add/https://github.com/ProdigyV21/ARVIO)

If you would rather type the source in, the manual app source URL is the repository address itself:

`https://github.com/ProdigyV21/ARVIO`

There is a setup guide at docs/distribution/OBTAINIUM.md that covers pre-configured JSON import and APK filtering, which matters because a repository with many release assets can pull in more than the one APK you want on a device.

The manual path is also supported directly. Signed APKs named ARVIO-v*-sideload-release.apk are published on GitHub Releases together with a SHA256SUMS.txt file of checksums, so you can verify the download you fetched rather than trusting the transport. The releases page is where you get both.

The version history shows a project moving fast through 2.x. Release 2.0.0 was tagged on 2026-09-19, 2.0.1 on 2026-09-30, and 2.2 on 2026-10-12, with the last push on 2026-10-19, so a build you sideload today may be newer than the APK you fetched last week unless you use Obtainium.

Self-hosting the web app means supplying your own credentials

The web application can run on your own computer or server without an ARVIO Premium subscription, using your own TMDB, Trakt, Simkl and other integration credentials. The paid hosted web app is optional rather than required.

The starting point is the webapp setup guide at web/README.md, which includes Node.js and Docker Compose instructions, a self-hosted environment template, and a configuration checker. Security, updates and limitations are covered separately in web/docs/SELF-HOSTING.md, and the local-only caveat is stated plainly: local profiles are stored per browser, and this setup does not provide cross-device ARVIO Cloud sync.

That last point is the boundary to plan around. Self-hosting gives you control of the deployment and no subscription, but the profile you build in a browser stays in that browser. On the Android side, cloud sync is the optional ARVIO Cloud feature and it is what carries profiles, settings, catalogs, IPTV state, watch state and avatars between devices. Treating the two as substitutes is the mistake; one is a hosting choice, the other is a sync choice.

The repository layout shows how much lives in the web side: a web/ directory for the app, a netlify-arvio-tv-site directory for the marketing and screenshot site, a netlify-auth-site directory for the authentication site, and a resolver-worker directory, which suggests the deployment assumes those pieces can be hosted separately.

What the repository is for, and what it deliberately is not

The README states the purpose of the GitHub repository explicitly. It is for source code review and development, issue investigation and technical discussion, build documentation, license and privacy documentation, and contribution review. It is not intended as an advertising page, a download landing page, or a content distribution repository.

That framing is reinforced by the tree. Beyond the app and web code there is a CHANGELOG.md, a COPYRIGHT.md, a LICENSE, a PRIVACY.md, a docs/ directory, a distribution/ directory, a scripts/ directory, a benchmark/ directory, and per-platform folders such as an unraid/ directory, a supabase/ directory, a templates/ directory and a collections/ directory. A keystore.properties.template sits at the top level next to secrets.defaults.properties, which is the standard way to keep signing keys out of the tree while leaving the expected entries documented.

The build is Gradle, with build.gradle.kts, settings.gradle.kts, gradle.properties, a gradlew wrapper and gradlew.bat for Windows, plus a ca_profile.xml and a .gitlab-ci.yml. That last file suggests continuous integration runs outside GitHub Actions for at least part of the pipeline.

Licensing is Apache-2.0, and the project keeps separate license and privacy documents, so if you fork it for a private library, the LICENSE and PRIVACY.md files are the two to read first.

Where ARVIO is the wrong choice

The clearest wrong-tool case is wanting a turnkey service. If you want someone else to supply the catalog, the streams and the account system, ARVIO is the wrong project, because by design it hosts and distributes nothing and expects you to bring TMDB credentials, an IPTV playlist or your own home server.

The second case is cross-device state without paying. The self-hosted web app keeps local profiles per browser and explicitly does not provide cross-device ARVIO Cloud sync, so on the free path your watch state and profiles live in one browser. Anyone whose core requirement is a shared watchlist across a TV and a phone has to either take the ARVIO Cloud subscription or wire up the optional per-profile Trakt.tv integration, which covers watchlist, history, progress and continue watching but is a different model, tied to Trakt accounts rather than to ARVIO profiles.

The third is project maturity and the cost of running it yourself. The README is explicit that the project is a hobby project that costs money every month to run and improve, which is a fair argument for supporting it and also an honest signal about what happens if you take on the self-hosting. A self-hosted deployment is Node.js and Docker Compose with a configuration checker, and the limitations are documented in a separate file, which means you own the upgrades too.

Editorial conclusion

Adopt ARVIO if you own your media setup and want a single client across Android TV, phone, tablet and browser, with signed APKs you can sideload and a web app you can point at your own TMDB and Trakt credentials. Step back if you expected a service that supplies content or a sync layer that carries state between devices for free, because cloud sync is an optional paid ARVIO Cloud feature and the self-hosted web app keeps local profiles in the browser. Before installing, read PRIVACY.md and the self-hosting limitations page, and confirm that release 2.2 from 2026-10-12 is the build you want, since the last push was on 2026-10-19.

Frequently asked questions

Official sources

1. License: Apache-2.0
2. ProdigyV21/ARVIO on GitHub
3. Project website
4. README
5. Releases