Yattee: a privacy oriented video player for iOS, tvOS and macOS

What Yattee actually replaces, and who it is built for

Yattee is a client, not a service. The README describes it as a "privacy oriented video player for iOS, tvOS and macOS", and the topics attached to the repository list invidious, piped, swiftui, ios, tvos and macos alongside youtube. That combination is the whole pitch: you keep a native Apple-platform player with a queue, history, gestures, Picture in Picture and background audio, but the video does not come from YouTube's own apps or web player. It comes from a backend you choose.

The intended user is someone who already has that backend, or is prepared to run one. If you have an Invidious or Piped instance, Yattee is a front end for it. If you do not, the README points at Yattee Server, described as "a self-hosted backend powered by yt-dlp that supports 1000+ sites". That phrasing matters: with Yattee Server the app is not a YouTube client at all, it is a player for whatever yt-dlp can extract.

The awkward part is that the repository is currently two products in one README. The top of the file announces that "Yattee 2 is in the works" with a refreshed experience, a TestFlight beta and a new documentation site. The feature list underneath (SwiftUI interface with customization settings, player queue and history, custom controls and gestures, 4K playback, fullscreen, Picture in Picture, background audio, SponsorBlock with configurable categories) reads as the established app. Nothing in the file says which of those features survive into 2.0, and the README does not document a migration path between them.

How the app gets video: a client, a backend and a source setting

The architecture visible in the repository is a thin Apple client plus an external extraction service. There is no bundled extractor in the top-level layout: the entries are Xcode project files, Swift source directories (Yattee/, YatteeShareExtension/, YatteeTopShelf/, YatteeTests/), fastlane, scripts, spec and a Gemfile. The .env.example file confirms the shape of the integration, because it asks for credentials for two different third-party services:

# Invidious credentials for UI tests (required for import_subscriptions tests)
INVIDIOUS_EMAIL=
INVIDIOUS_PASSWORD=

# Piped credentials for UI tests (required for import tests)
PIPED_USERNAME=
PIPED_PASSWORD=

Those variables are for the test suite, not for the shipping app, and the file says so in its own header comment. But they show that Invidious and Piped are first-class sources with account-based features such as subscription import, and that the code paths are exercised in CI rather than bolted on.

The same file carries commented overrides for the endpoints the tests hit:

# Optional: Override default test URLs
# YATTEE_SERVER_URL=https://yp.home.arekf.net
# INVIDIOUS_URL=https://invidious.home.arekf.net
# PIPED_URL=https://pipedapi.home.arekf.net

Three base URLs, three backends, one app. The practical consequence is that playback quality, search results and availability are properties of your instance, not of Yattee. When a video fails to play, the first thing to check is whether the backend can fetch it, because the client is only rendering what the backend returns. It also means the privacy claim is bounded by your choice: a public Invidious instance sees your requests, a self-hosted one does not leave your network.

Installing Yattee on iPhone, Apple TV and Mac

The README does not give install steps. It links to a TestFlight beta for version 2 and to docs.yattee.stream for guides, roadmap and changelog, and the repository ships an altstore-source.json at the top level, which implies an AltStore distribution path exists. Treat those three as the places to look, in that order, and do not expect a single canonical download button.

Building from source is the route the repository itself supports. The project is Swift with an Xcode project, a Gemfile for fastlane, and scripts. The checkout and the build loop look like this:

git clone https://github.com/yattee/yattee.git
cd yattee
bundle install
bundle exec fastlane list

Running bundle exec fastlane list prints the lanes defined in the fastlane directory so you can pick one instead of guessing. The README does not name a lane, so read that output before you run anything that touches signing.

For the test suite, the repository expects a .env file copied from the template. The header comment in .env.example states the instruction directly: copy the file to .env and fill in your values.

cp .env.example .env
# then edit .env and set INVIDIOUS_EMAIL, INVIDIOUS_PASSWORD,
# PIPED_USERNAME and PIPED_PASSWORD for the import tests

If you skip that step, the import and subscription tests have no credentials and cannot pass; the file marks those variables as required. A first real use is then: launch the app, pick a source (your Invidious instance, your Piped instance, or Yattee Server), and play something. The README does not document the settings screens, so expect to find the source configuration by exploring the app rather than by following a written guide.

Where Yattee is the wrong tool

The largest limitation is that Yattee has no content of its own. Install it on a device with no reachable backend and you have a video player with nothing to play. That is a structural dependency, not a bug, and it rules Yattee out for anyone who wants to hand a family member an app and walk away.

The second limitation is release status. The most recent published release is 2.0.0-beta.270 from 2026-08-23, preceded by 2.0.0-beta.269 and 2.0.0-beta.268. Everything in the 2.0 line is labelled beta in the release names themselves, and the README's own banner describes 2.0 as "in the works" with TestFlight for early builds. If you need a version with a stability promise, this repository does not currently offer one under that label.

The third is platform. iOS, tvOS and macOS only. There is no Android, Windows or Linux client here, and no web interface in the repository layout. If your household is mixed, Yattee covers part of it.

Finally, the AGPL v3 licence is a real constraint on anyone who wants to ship a modified build. The README states that Yattee and its components are shared under AGPL v3. If you fork it and distribute the result, the network-use and source-availability terms of that licence apply; if that matters to your plans, read the licence text rather than this article.

Yattee against FreeTube, and against the YouTube app

The honest comparison is not Yattee versus the official YouTube app. Those differ in distribution, in account model and in what the vendor can change under you, and the trade-offs are well understood. The more interesting comparison is Yattee versus FreeTube, because both are third-party players that avoid the official client, and they solve the backend problem in opposite ways.

FreeTube is a desktop application that bundles its own extraction logic, so installing it is enough to start watching. Yattee delegates extraction to Invidious, Piped or Yattee Server and therefore needs an endpoint that is already running. The upside of Yattee's split is that the heavy, frequently broken part (extraction, which sites like YouTube actively work against) lives outside the app, so a backend update does not require an App Store review or a new binary on your Apple TV. The downside is that you now operate or trust a second system, and the app is only as good as the instance you point it at.

A second difference is reach. FreeTube is a desktop program. Yattee is a native SwiftUI app for iOS, tvOS and macOS, which is the only one of the two that puts a remote-control-friendly interface on an Apple TV. If your goal is watching on a television without the official app, that is the deciding factor, and it comes with the backend requirement attached.

Maintenance, versioning and the cost of the 2.0 split

The repository is not archived, and the last push was on 2026-08-23. The release cadence visible in the release list is roughly weekly to monthly: 2.0.0-beta.268 on 2026-07-27, 2.0.0-beta.269 on 2026-08-03, 2.0.0-beta.270 on 2026-08-23. That is a project that is being worked on, but the work is landing under beta version numbers.

The upgrade cost is the part worth planning for. There are two codebases' worth of documentation in one README, a CHANGELOG.md at the top level, a cliff.toml (suggesting automated changelog generation from commits) and a separate documentation site for the new line. A user on the older client and a user on the 2.0 beta are not reading the same instructions. The README does not document rollback, so if you move a device to a 2.0 beta build, there is no stated path back. TestFlight builds expire, which is a general property of that distribution channel rather than something the README discusses, but it is the practical reason a beta install on a living-room Apple TV needs attention.

Licensing is AGPL v3, and the README says so plainly. For private use that changes nothing. For anyone embedding Yattee in a product, the copyleft and network-use obligations are the thing to review with someone qualified, because the repository does not summarise them for you.

Editorial conclusion

Adopt Yattee if you already run an Invidious or Piped instance, or if you are willing to run Yattee Server, because the app is a client and does nothing useful without a backend you can point it at. Skip it if you want a single App Store download that works out of the box, or if you need a stable release: the newest published build is 2.0.0-beta.270 from 2026-08-23. Before installing anything, verify which version you are getting, since the README describes a 2.0 beta paired with Yattee Server while the feature list still describes the older client, and check that your chosen backend answers before you blame the app.

Frequently asked questions

Official sources

1. Issues
2. License: AGPL-3.0
3. README
4. Releases
5. yattee/yattee on GitHub