Nuvio Desktop: a Kotlin Multiplatform media client, labelled alpha and meant only for testers

An alpha media client that says so first

Nuvio Desktop is a media app for Windows, macOS and Linux that lets you browse metadata, manage collections and watch progress, download media, and play streams from user-installed extensions or user-provided sources. Before describing any of that, the README leads with a warning: this is alpha software under slow development, intended only for testers, not suitable for daily use, with breaking changes expected on every update.

That honesty defines who should look at it. Nuvio Desktop is for a tester or a developer curious about a Kotlin Multiplatform media client, willing to accept that features, settings, stored data and compatibility may change or stop working without notice. It is explicitly not for someone wanting a stable media app to rely on, and the README says so in the first section rather than burying it.

Like similar clients, Nuvio ships no content. The README's legal section states it functions solely as a client-side interface for browsing metadata and playing media provided by user-installed extensions or user-provided sources, intended for content the user owns or is authorized to access, and that it does not host, store or distribute media. It is GPL-3.0 licensed.

Kotlin and Compose Multiplatform across three desktop targets

The technical interest in Nuvio Desktop is its stack. The README lists Kotlin Multiplatform, Compose Multiplatform, Compose Desktop packaging and native desktop player integrations. That combination lets one shared codebase target Windows, macOS and Linux, with the UI written once in Compose and platform-specific pieces layered on top.

The repository structure reflects this. The README describes `composeApp/` as the app code, `composeApp/src/commonMain/` as shared UI, features, repositories and platform-agnostic logic, and `composeApp/src/desktopMain/` as desktop-specific integrations. The tree also shows `androidApp/` and `iosApp/` directories alongside submodules like `MPVKit` and `libass-android`, indicating the shared code is designed to reach mobile too, even though this repository is the desktop app.

The native player integrations are the part that matters for a media client, and the presence of MPVKit as a submodule points to mpv-based playback underneath the Compose UI. For a project evaluating how to build a cross-platform media player without Electron, Nuvio Desktop is a concrete Kotlin and Compose reference, which is arguably more valuable right now than the app itself given its alpha state.

Installing a build, or running from source

For testers, the README points to prebuilt packages on GitHub Releases, with a Windows MSI, a macOS DMG, and Linux DEB, RPM, Flatpak and AppImage builds. That covers the platforms without a toolchain.

Running from source is a Gradle flow. After cloning, the app runs directly:

git clone https://github.com/NuvioMedia/NuvioDesktop.git
cd NuvioDesktop
./gradlew :composeApp:run

On Windows PowerShell the equivalent is `.\gradlew.bat :composeApp:run`. Building a distributable for the current host uses a single task:

./gradlew :composeApp:packageReleaseDistributionForCurrentOS

Platform-specific packaging tasks exist too, `./gradlew :composeApp:packageReleaseMsi --rerun-tasks` for Windows and `./gradlew :composeApp:packageReleaseDeb` for Linux, while macOS uses a script, `./scripts/build-macos-release-dmgs.sh --package-only`. Because the project uses git submodules for MPVKit and libass-android, a clone needs its submodules initialized for a source build to succeed. The Gradle wrapper is committed, so no separate Gradle install is required.

Versioning wired into properties, and the alpha reality

Nuvio Desktop's release versioning is explicit and scripted, which is a small sign of discipline in an otherwise early project. The README says desktop versions live in `composeApp/Configuration/DesktopVersion.properties`, holding a `VERSION_NAME` and `VERSION_CODE`, and the current values are `0.1.1-alpha` and `1`. A helper script changes them:

./scripts/set-version.sh --desktop 0.1.2-alpha --desktop-code 2

That a version bump has a dedicated script and a single source-of-truth properties file is a good practice, and it makes the alpha status machine-readable rather than a claim in prose.

But the alpha reality is the dominant fact about adopting this. The README warns that features, settings, stored data and compatibility may change or stop working without notice, and asks testers not to rely on it as a primary media app. Version `0.1.1-alpha` is not a soft label here; it is the accurate description of a project that expects to break your setup between updates. Anyone evaluating it should treat every install as disposable and expect to lose stored state on upgrades.

The honest limitations are the headline

Unusually, the limitations are not something to dig for, they are the README's opening. Slow development, testers only, breaking changes every update, and unsuitability for daily use are all stated up front. That candour is the right way to set expectations, and it means the main risk of adopting Nuvio Desktop is exactly the one the maintainers named: instability.

The second limitation is shared with every client of its kind: it ships no content and no extensions. Out of the box it browses metadata and plays nothing until the user installs extensions or provides sources, which is a deliberate legal and design stance. Nuvio is only as useful as the sources the user already has and is authorized to use.

There is no polished support promise either. This is a passion-stage project with the maintainers asking testers to report issues, and the DMCA and legal information is deferred to an external page. For a tester that is fine. For anyone hoping to depend on it, the absence of stability guarantees is not a detail, it is the whole point the README is making.

Against a mature player like Kodi

The natural comparison is an established open-source media player such as Kodi, which is stable, cross-platform, extensible through addons and used daily by many people. Against that, Nuvio Desktop is plainly less finished: alpha, testers-only, and warning of breaking changes.

The difference in approach is the stack and the stage. Kodi is a mature C++ application with a long history; Nuvio Desktop is a young Kotlin and Compose Multiplatform app whose interest is partly in demonstrating that approach across desktop and, potentially, mobile from one codebase. For a user who just wants to watch media reliably, Kodi wins today without contest. For a developer curious about building a modern cross-platform media client in Kotlin, or a tester willing to help shape an early project, Nuvio Desktop offers a current, GPL-3.0 example to run and study. The choice is not really about features; it is about whether you want a finished player now or an early Compose Multiplatform project you are prepared to see break.

GPL-3.0 and what to expect if you test it

Nuvio Desktop is GPL-3.0, so derivatives distributed to others must be released under the same terms, keeping the codebase and its improvements open. For a project whose value right now is partly as a Kotlin Multiplatform reference, copyleft fits: forks and adaptations stay in the open.

Maintenance expectations should be set by the README's own words. Development is slow, updates bring breaking changes, and the version helper and properties file exist precisely because versions move and stored data may not survive. Because playback relies on submodules like MPVKit, keeping a source build working also means keeping those submodules in sync on each update.

The concrete first step, if you decide to test it, is to treat it as throwaway: install a Releases build or run `./gradlew :composeApp:run` from a submodule-initialized clone, add your own extensions or sources since Nuvio ships none, and do not migrate any collection or watch-progress data you care about, because the README says stored data may change or stop working without notice. Report what breaks; that is what the project is asking of its testers.

Editorial conclusion

Nuvio Desktop is worth a look only if you are a tester or a developer interested in a Kotlin and Compose Multiplatform media client and are willing to accept breaking changes on every update: the shared commonMain code and mpv-based native playback make it a useful current reference for cross-platform desktop UI. It is the wrong choice for daily use or any setup you care about, since the README itself calls it alpha, testers-only, and warns stored data may stop working without notice. If you test it, install a GitHub Releases build or run ./gradlew :composeApp:run from a submodule-initialized clone, add your own extensions since it ships none, and keep nothing you are not prepared to lose on the next update.

Frequently asked questions

Official sources

1. License: GPL-3.0
2. NuvioMedia/NuvioDesktop on GitHub
3. Project website
4. README
5. Releases