# tv-samples is a collection of seven Android TV sample projects > The android/tv-samples repository is a menu rather than a library: seven individual sample projects, three in Java and four in Kotlin, including examples that use Leanback and Compose for TV. Two of the Compose samples cover the same libraries from different angles, and picking between them is most of what an adopter does here. **android/tv-samples** — Multiple samples showing best practices in app development on Android TV. - Repository: https://github.com/android/tv-samples - Stars: 1,283 · Forks: 398 - Language: Kotlin - License: Apache-2.0 - Published: 2026-10-17 · Updated: 2026-10-17 · Language: en - Canonical page: https://hysenlabs.com/projects/android-tv-samples ## Seven projects, seven build roots, one repository The repository is described as a set of individual Android TV projects to help you get started writing Android TV apps, and the top-level listing shows what that means in practice. Each sample is its own directory with its own project: AccessibilityDemo, ClassicsKotlin, JetStreamCompose, Leanback, LeanbackShowcase, ReferenceAppKotlin and TvMaterialCatalog. There is no library module, no published artifact and no aggregator. That has an immediate consequence for anyone trying to use it as a dependency. You cannot add it to a build file. What you can do is clone it and open the individual project you are interested in: ```sh git clone https://github.com/android/tv-samples.git ``` Then open that project in Android Studio, which is what the Getting Started section instructs. The clone is the whole repository, so a reader who wants one sample still pulls all seven, and the README does not describe a way to fetch a subset. For a repository of this kind that is the correct structure. Android TV samples are instructive rather than reusable, and keeping each one independently buildable means a stale sample can be updated or removed without breaking the others. The cost is that each sample carries its own dependency versions and its own idea of a good starting point, so two samples cloned on the same day may disagree about library versions. ## The Java and Kotlin split is really a Leanback and Compose split Read the sample list and the first thing that appears is a language split, but the more useful dividing line is the UI stack. Three samples are Java and use the Leanback SDK: Leanback, described as demonstrating a basic Android TV app, and LeanbackShowcase, which demonstrates many different parts of the Leanback SDK and how to customise them. AccessibilityDemo is the third, and the README describes it as a Java sample showing how to support accessibility on TVs. The other four are Kotlin. ClassicsKotlin is described as a modern Android TV app that shows classic videos. TvMaterialCatalog and JetStreamCompose are described as Kotlin Jetpack Compose apps using the Compose for TV libraries. ReferenceAppKotlin is described as the newest sample, demonstrating a variety of Android TV and Google TV integrations in Kotlin. The Leanback and Compose samples are not two styles of the same code. They are different UI models, different view systems and different navigation assumptions, and the repository does not attempt to bridge them. A team with an existing Leanback codebase will find the Java samples immediately legible, and a team starting fresh in Kotlin will find the Compose samples closer to what they write every day. The Google TV mention is confined to ReferenceAppKotlin, which is a hint that the newest sample covers the current platform surface while the rest are organised around the older Android TV framing. ## TvMaterialCatalog and JetStreamCompose cover the same libraries from two directions Two samples use the same libraries and they are not redundant, which is worth being explicit about because the descriptions look similar at a glance. TvMaterialCatalog is described as a Jetpack Compose app built with Kotlin that demonstrates the usages of components from the Compose for TV libraries in isolation. JetStreamCompose is described as a Jetpack Compose app using Kotlin that demonstrates the usage of components from the same libraries. The difference is the word in isolation. A catalogue answers a lookup question: what does this component look like, what props does it take, what happens when it gets focus. It is a reference you keep open in a second window while you work. A composed application answers a different question: how do these components behave together, what does a real navigation flow look like, how does focus travel between screens. That is a meaningful split for adoption. If you are porting a design system onto Android TV and your questions are per component, the catalogue is the faster path. If you are building a whole app and want to see the structure, the composed sample is the faster path. Reading both is also defensible, since they are small enough to be a single sitting each. The README links both Compose for TV descriptions to the same AndroidX release page, but it does not specify which libraries each sample uses. ## ReferenceAppKotlin is the one to open first in Kotlin Among the Kotlin samples, ReferenceAppKotlin carries a different description from the rest, and it is the one to read first. The README calls it the newest sample and says it demonstrates a variety of Android TV and Google TV integrations. The word integrations is the signal. Every other sample is scoped to one concern: accessibility, classic video content, a catalogue of components, a composed application, or the Leanback SDK. ReferenceAppKotlin is the broad one, and for a team trying to work out what an Android TV app is expected to plug into, that is the sample with the answers. It is also the sample most likely to be out of step with the others in terms of library versions, because it is the one that tracks the newest platform surface while the catalogue and the composed application are organised around demonstrating components. That is a feature rather than a defect, and it is the reason to read it first and then treat the others as focused references. The classics sample sits at the other end. It is described as showing classic videos, which makes it the least abstract of the Kotlin set and the easiest one to run end to end if you want something that plays content before you have written any code of your own. ## AccessibilityDemo has no modern counterpart, and that is where it earns its place AccessibilityDemo is listed among the Java samples, which by association makes it look like the least current entry in the list. It is not, because it is the only sample in the repository whose subject is not the UI stack. Every other project teaches a framework: Leanback, LeanbackShowcase, TvMaterialCatalog, JetStreamCompose, ReferenceAppKotlin, ClassicsKotlin. AccessibilityDemo is described as showing how to support accessibility on TVs, which is a platform concern rather than a library concern. It stays relevant whichever UI stack you adopt, and the repository offers nothing equivalent in Kotlin. That is worth knowing before cloning, because the conventional expectation for a sample repository is that everything is current. Here one sample is deliberately framework-neutral while the rest track two different generations of the platform, and a reader who opens AccessibilityDemo expecting Kotlin and Compose examples will not find them. For a team shipping a TV app, the practical sequence is to take the accessibility requirements from here and apply them to whichever of the Kotlin or Java samples matches the codebase. ## What the repository does not tell you, and how it is governed The README is short and its silences are informative. It states no minimum or target SDK level, no dependency versions, no required Android Studio version and no statement about which samples are maintained. It also does not say which of the seven projects is expected to work with which release of the Compose for TV libraries. All of that lives in each sample's own Gradle files, which is the normal arrangement for independent projects, and it is another reason to clone selectively rather than treat the repository as a maintained collection with a single baseline. The governance files are visible at the top level and are worth a glance. CODEOWNERS assigns review responsibility per path, CONTRIBUTING.md sets out how to contribute, and scripts/ sits alongside them, which is consistent with a repository that checks its samples in automation rather than by hand. The.github/ directory is present as well. There are no GitHub releases. The last push was on 2026-07-22, and the repository is not archived. For a samples repository that is a normal cadence, since the artefacts that matter are the individual projects rather than a packaged build. The licence is Apache-2.0 with a LICENSE file at the root, as the README states. No legal advice is offered here, but for sample code that teams routinely copy fragments from, a permissive licence with the attribution requirement attached is what you want. ## Conclusion Start from ReferenceAppKotlin if you are building a new Android TV or Google TV app in Kotlin, and from Leanback or LeanbackShowcase if your codebase is Java or already on the Leanback SDK, because the two toolchains do not share a UI model. Use TvMaterialCatalog when you need one component in isolation and JetStreamCompose when you need to see the same components composed into a working app. Verify first, before cloning, which of the two UI stacks your project already uses, and read each sample's own build files for its SDK levels, since the repository README states no version requirements for any of them. ## FAQ ### How do I get the Android TV samples? Clone the repository with `git clone https://github.com/android/tv-samples.git` and then open the individual project you are interested in Android Studio. Each of the seven samples is a separate project in the repository. ### What is the difference between TvMaterialCatalog and JetStreamCompose? Both are Kotlin Jetpack Compose samples using the Compose for TV libraries. The README describes TvMaterialCatalog as demonstrating the components in isolation, and JetStreamCompose as demonstrating their usage, so the first is a per-component reference and the second is a composed application. ### Should I use the Leanback samples or the Compose for TV samples? It depends on your existing code. The Leanback and LeanbackShowcase samples are Java apps built on the Leanback SDK, while TvMaterialCatalog and JetStreamCompose are described as Kotlin Jetpack Compose samples using the Compose for TV libraries. ClassicsKotlin and ReferenceAppKotlin are also Kotlin projects, but the README does not describe their UI stack. The two do not share a UI model. ### Is there an accessibility sample for Android TV? Yes. AccessibilityDemo is described as a Java sample showing how to support accessibility on TVs, and it is the only sample in the repository whose subject is accessibility rather than a specific UI framework. ## Sources - [android/tv-samples on GitHub](https://github.com/android/tv-samples) - [Issues](https://github.com/android/tv-samples/issues) - [License: Apache-2.0](https://github.com/android/tv-samples/blob/main/LICENSE) - [README](https://github.com/android/tv-samples/blob/main/README.md) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/android-tv-samples