# ArchiveTune: a Kotlin YouTube Music client for Android that also plays your local files

> ArchiveTune is an open source Android music player built with Kotlin and Jetpack Compose that combines YouTube Music streaming with local file playback. It is a young, fast-moving app, and the repository is explicit that forks get no support.

**rukamori/ArchiveTune** — 🌸 The Cutest Music Player With Support Local File and Youtube Music for Android!

- Repository: https://github.com/rukamori/ArchiveTune
- Website: https://archivetune.koiiverse.cloud
- Stars: 6,627 · Forks: 284
- Language: Kotlin
- License: GPL-3.0
- Published: 2026-09-22 · Updated: 2026-09-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/rukamori-archivetune

## What ArchiveTune solves, and who it is actually for

Most Android YouTube Music clients pick one side of a divide. They either wrap the streaming service and ignore whatever you already own, or they are local-first players that treat streaming as an afterthought. ArchiveTune's README claims both: the feature list puts "Support local file and local song playback" directly next to ad-free background playback, multiple account support and playlists that appear after sign-in. That combination is the pitch, and it is a narrower audience than it sounds. If you only stream, a lighter client would do. If you only play files you own, a dedicated offline player is simpler. ArchiveTune is for the listener whose library is split across a YouTube Music account and a folder of files on the device, and who wants one queue instead of two apps.

The second audience is people who care about the playback chain rather than the catalogue. The README lists EBU R128 loudness normalization, tempo, pitch and speed controls, crossfade, and integration with the system equalizer and spatial audio. Those are engineering features, not marketing ones, and they are the reason the project describes itself as built from the ground up rather than as a wrapper. The repository is Kotlin throughout, with Jetpack Compose for the UI, Material 3 for the design system, and an MVVM architecture, so the codebase is legible to anyone who already works in modern Android.

## How the streaming and local playback paths fit together

The repository layout tells you more than the README does. Alongside app/, buildSrc/ and gradle/, there are top-level directories named shazamkit/, spotifycore/, lastfm/, lyrics/, canvas/ and div/, plus a DataServer.txt and ArchiveTuneKoiverseServer.txt at the root. Those names map onto the feature list: lyrics and romanization, music recognition, scrobbling, and canvas-style artwork. The project is not a thin client around one API. It aggregates several services behind one interface, and the MVVM structure is what keeps that aggregation out of the UI layer.

The split matters for reliability. Local file playback does not depend on any network service, so it keeps working when the streaming path fails. The streaming path does, and the README is upfront about the weakest link: "If YouTube Music is not supported in your region, a VPN or proxy set to a supported region is required for initial data fetching." That is a hard dependency on a third-party service the project does not control. When YouTube changes something, ArchiveTune breaks until the maintainer ships a fix. The README does not describe a fallback, and the repository has no documented offline cache for streamed tracks.

One structural detail worth flagging: the root contains Koiverse.jks and Koiverse.jks.base64, a signing keystore and its base64 copy, committed to the repository. That is a deliberate choice by the maintainer, and it has consequences for anyone who builds their own copy, which the next section covers.

## Installing ArchiveTune and playing your first track

The README points to the releases page and the official site at archivetune.koiiverse.cloud under a Download section, and the repository ships fastlane metadata, which is the standard structure for F-Droid-style distribution. The current release line is v15.0.0, published on 2026-09-10, following v14.1.0 and v14.0.0. Grab the APK from the release assets and install it on the device. Android will ask you to allow installation from that source, since the build is not distributed through the Play Store.

If you prefer to build it yourself, the repository is a standard Gradle project with a wrapper checked in. Clone it and run the wrapper:

```bash
git clone https://github.com/rukamori/ArchiveTune.git
cd ArchiveTune
./gradlew assembleRelease
```

The output lands under app/build/outputs/apk/. The README does not document the signing configuration or how the committed Koiverse.jks keystore is meant to be used for a self-built release, so expect to configure signing yourself before the release variant will install over an existing copy.

Once the app is running, sign in with your YouTube Music account. The README states that playlists, liked songs and subscriptions appear after sign-in, and that multiple accounts can be switched quickly. Then point the app at local audio: the feature list includes local file and local song playback, though the README does not give a step-by-step path for choosing a folder. Explore the settings screen, since that is where the audio controls live. The README names EBU R128 loudness normalization, crossfade, tempo, pitch and playback speed, and system equalizer and spatial audio integration. If YouTube Music is unavailable in your region, set the VPN or proxy before the first sign-in, because the README ties it to initial data fetching rather than to playback alone.

## Where ArchiveTune breaks, and when it is the wrong tool

The geographic restriction is the first real limitation, and it is not a bug that will be fixed. ArchiveTune depends on YouTube Music being reachable, so in unsupported regions the app needs a VPN or proxy just to fetch initial data. A music player that requires a proxy to start is a different proposition from one that does not, and the README offers no alternative source for that catalogue.

The second limitation is platform. Everything in the repository is an Android application: Kotlin, Jetpack Compose, Material 3, a Gradle build, fastlane metadata under a mobile app structure. There is no desktop target, no iOS target, and no web player described anywhere in the repository. The homepage is a project site, not a streaming client. If you want ArchiveTune on a laptop, there is nothing to install.

The third is the support boundary, and it is unusually blunt. The README carries a warning: "Forks are not supported in any way." No support, maintenance, troubleshooting or assistance for forked versions, and use at your own risk. That is a legitimate position for a solo maintainer, but it means a fork is a dead end for help. Combined with the committed keystore, it also means a self-built APK is your responsibility, not the project's. Finally, the app is young and iterating fast: three releases between 2026-07-19 and 2026-09-10. Rapid release cadence is good for features and bad for stability, and the README does not document a rollback path if a new version misbehaves.

## ArchiveTune against Metrolist and other YouTube Music clients

The obvious comparison is Metrolist, another Android YouTube Music client, and the question "archivetune vs metrolist" is common enough that Google surfaces it. The difference that matters here is scope. ArchiveTune's feature list puts local file playback in the same tier as streaming, and adds EBU R128 normalization, crossfade, tempo and pitch control, and system equalizer integration. A client built purely as a streaming front end would not carry that list. If your library is entirely in the cloud, that extra machinery is weight you will not use, and the simpler client is the better fit.

Against a local-first player, the trade runs the other way. ArchiveTune asks for an account sign-in and, in some regions, a proxy, in exchange for playlists, liked songs and subscriptions syncing into the app. A local player needs neither. The honest framing is that ArchiveTune is a streaming client that happens to handle local files well, not a local player that happens to stream. Choose it on that basis. The README also points to a Telegram group and a Discord server for support, which is where the practical comparison conversation actually happens.

## Licence, maintenance and the cost of upgrading

ArchiveTune is GPL-3.0. In practical terms, if you distribute a modified build, you must publish the source under the same licence. That is compatible with the project's stance on forks: you may fork, but you carry the obligations and you get no support. The committed keystore is a separate question from the licence, and anyone redistributing a build signed with it should think carefully about what that implies. This is not legal advice; read the LICENSE file and PRIVACY.md in the repository.

On maintenance, the last push was on 2026-09-21, one day before this writing, and the most recent release was v15.0.0 on 2026-09-10. The project is being worked on. The upgrade cost is the real question. Three releases in under two months means the app changes quickly, and the README does not document a rollback or downgrade procedure. If you install v15.0.0 and it regresses, your options are to wait for a fix or to find an older APK on the releases page. The repository does include a duplicate_checker.py at the root and a detekt.yml, which suggests some automated quality checking, but the README does not describe a test suite or a CI gate that would catch a playback regression before release.

## Conclusion

Adopt ArchiveTune if you want a single Android app for YouTube Music streaming and local files, you are comfortable installing an APK from GitHub releases, and you can build from source when you need to. Do not adopt it if YouTube Music is unavailable in your region and you will not run a VPN or proxy for the first data fetch, if you need a desktop or iOS client, or if you plan to maintain a fork, since the README states forks receive no support. Before installing, check the release page for the current version and the checksum you intend to verify, and read the privacy page at archivetune.koiiverse.cloud/privacy to confirm how account data is handled.

## FAQ

### Is ArchiveTune safe?

The README links to a VirusTotal report for a build hash, and the source is public under GPL-3.0, so you can read the code or build it yourself. Safety here depends on trusting the released APK, and the app requires a YouTube Music account sign-in, so review PRIVACY.md before you use it.

### Is ArchiveTune better than Metrolist?

The two are not documented against each other in the repository, so a direct verdict is not possible. The difference visible in ArchiveTune's own feature list is that it pairs YouTube Music streaming with local file playback and adds EBU R128 normalization, crossfade, tempo and pitch controls, and system equalizer integration. If you only stream, those extras may not matter to you.

### What is ArchiveTune?

It is an Android music player written in Kotlin with Jetpack Compose and Material 3, licensed GPL-3.0. It plays YouTube Music with ad-free background playback and also supports local file and local song playback, with multiple account support and synced lyrics.

### How do I install ArchiveTune?

Download the APK from the releases page linked in the README, or build it from source with the Gradle wrapper. The README points to archivetune.koiiverse.cloud under its Download section as well. If YouTube Music is unavailable in your region, set a VPN or proxy to a supported region before the first data fetch.

### Is ArchiveTune available on PC?

No. The repository is entirely an Android application built with Kotlin, Jetpack Compose and Gradle, with fastlane metadata for mobile distribution. Nothing in the repository describes a desktop or web client.

## Sources

- [License: GPL-3.0](https://github.com/rukamori/ArchiveTune/blob/main/LICENSE)
- [Project website](https://archivetune.koiiverse.cloud)
- [README](https://github.com/rukamori/ArchiveTune/blob/main/README.md)
- [Releases](https://github.com/rukamori/ArchiveTune/releases)
- [rukamori/ArchiveTune on GitHub](https://github.com/rukamori/ArchiveTune)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/rukamori-archivetune