# Pokedex Compose is a Jetpack Compose sample that happens to be a Pokémon browser

> skydoves/pokedex-compose demonstrates modern Android development with Jetpack Compose, Hilt, Coroutines, Flow, Room, ViewModel and Material Design on an MVVM architecture, with an offline-first data layer and a repository pattern. It is a teaching project that ships as an APK, and the author keeps the same libraries in his own separate projects.

**skydoves/pokedex-compose** — 🗡️ Pokedex Compose demonstrates modern Android development with Jetpack Compose, Hilt, Coroutines, Flow, Jetpack (Room, ViewModel), and Material Design based on MVVM architecture.

- Repository: https://github.com/skydoves/pokedex-compose
- Website: https://skydoves.github.io/pokedex-compose/
- Stars: 1,136 · Forks: 200
- Language: Kotlin
- License: Apache-2.0
- Published: 2026-10-19 · Updated: 2026-10-19 · Language: en
- Canonical page: https://hysenlabs.com/projects/skydoves-pokedex-compose

## A sample with an APK and a sibling in XML

Pokedex Compose demonstrates modern Android development with Jetpack Compose, Hilt, Coroutines, Flow, Jetpack for Room and ViewModel, and Material Design, based on MVVM architecture.

The Pokémon theme is the vehicle rather than the point. A sample needs a domain with recognisable data and a screen that is not a text field, and a list of creatures with images, types and statistics does that better than a to do list. The readme also points at the XML version of Pokedex in a separate repository, which is a useful pairing, because the two show the same application written with the two different UI approaches.

The project is a published application rather than a library. The Download section sends you to the releases to download the latest APK, and the topics list the whole stack, with android, coroutines, hilt, jetpack-android, jetpack-compose, kotlin, motion, mvvm, mvvm-architecture, pokedex, pokemon and skydoves on it.

The badges set the requirements and the pedigree. The minimum SDK is 21, the licence is Apache-2.0, and there is a build status badge for the Android CI workflow, a Google Dev Library badge for the project, a Medium article badge about the differences between Dagger Hilt and Dagger Android, a Google Developers video badge, and a badge for the author's other lettered project.

The last push was on 2026-04-10, and the releases are 1.0.4 from 2025-08-15, 1.0.3 from 2024-08-15 and 1.0.2 from 2024-04-21, so the sample is updated when the stack moves rather than on a schedule.

## The stack, and the reason each piece is there

The tech stack section is where the teaching happens, because every entry comes with a sentence explaining what it is for rather than a link alone.

The base is Kotlin, with Coroutines and Flow for asynchronous operations. On top of that sit the Jetpack libraries. Jetpack Compose is Android's modern toolkit for declarative UI development. Lifecycle observes the Android lifecycles and manages UI states upon lifecycle changes. ViewModel manages UI-related data and is lifecycle-aware, ensuring data survival through configuration changes. Navigation facilitates screen navigation, complemented by Hilt Navigation Compose for dependency injection. Room constructs a database with an SQLite abstraction layer for seamless database access. And Hilt facilitates dependency injection.

The architecture section names the pattern explicitly. MVVM architecture, the View, ViewModel, Model, facilitates separation of concerns and promotes maintainability, and the Repository Pattern acts as a mediator between different data sources and the application's business logic.

Around that sits the network and the plumbing. Retrofit2 and OkHttp3 construct REST APIs and facilitate paging network data retrieval. Kotlin Serialization is the multiplatform, multi-format, reflectionless serialisation. ksp, the Kotlin Symbol Processing API, is there for code generation and analysis. Baseline Profiles enhance app performance by including specifications of classes and methods in the APK that can be used by the Android runtime.

That last one is the item most sample projects leave out, and its inclusion is a signal about what the author thinks matters in a real application rather than only in a demo.

## Two layers, and a data layer that knows nothing about the UI

The Architecture section is the most substantial part of the readme, and it is written as a description of two distinct layers with specific responsibilities.

The project adheres to the MVVM architecture and implements the Repository pattern, aligning with Google's official architecture guidance, and the readme says it follows the principles in the Guide to app architecture, making it an exemplary demonstration of architectural concepts in practical application.

The overview explains the mechanism. Each layer adheres to the principles of unidirectional event and data flow, so the UI layer sends user events to the data layer, and the data layer provides data streams to other layers. The data layer operates autonomously from other layers, maintaining purity without dependencies on external layers.

That last clause is the one worth dwelling on. A data layer that has no dependency on the UI layer is a boundary you can test without an emulator, and it is what makes the repository pattern more than a naming convention.

In the UI layer, the readme is specific about the split. The UI layer encompasses the UI elements responsible for configuring screens for user interaction, alongside the ViewModel, which manages app states and restores data during configuration changes, and the UI elements observe the data flow, ensuring synchronization with the underlying data layer.

So the event direction and the data direction are opposite, and the ViewModel sits in the middle holding the state that both are expressed in terms of. The readme claims that this loosely coupled architecture enhances component reusability and app scalability, and the figure/ directory holds the diagrams that the readme embeds.

## The data layer is offline-first

The Data Layer section is where the sample stops being generic.

The data layer is composed of repositories that handle business logic tasks such as retrieving data from a local database or fetching remote data from a network. This layer is designed to prioritize offline access, functioning primarily as an offline-first repository of business logic. It adheres to the principle of a single source of truth, ensuring that all data operations are centralized and consistent.

The readme then states that Pokedex Compose is an offline-first app, and the text is cut off mid-sentence in the available version, so the details of what it can do offline are not spelled out here.

Even so, the structure is clear and it is the more demanding choice. A repository that is a cache of a network API is a common pattern and it fails in a way that is easy to miss, because the network is treated as the source of truth and the cache as a copy. A repository that is offline-first inverts that, so the database is the source of truth and the network is a synchroniser, and the user interface observes the database.

The single source of truth phrase is doing real work there. It is the rule that stops two layers from both mutating the same data, and in a Compose application where the UI observes a Flow from Room, it is what makes the flow a single stream rather than several.

## Two of the libraries are the author's own

The library list has an entry that is different from the others, and it is worth noticing.

Sandwich is described as an adaptable and lightweight sealed API library designed for handling API responses and exceptions in Kotlin for Retrofit, Ktor and Kotlin Multiplatform, and it is by the same author. Landscapist Glide, animation and placeholder are described together as a pluggable, highly optimized Jetpack Compose and Kotlin Multiplatform image loading library that fetches and displays network images with Glide, Coil and Fresco, and that one is also by the same author.

So two of the components in the sample are libraries the author maintains separately, and the sample is where they get exercised. That is worth knowing when you read the code, because the idioms in it reflect two particular opinions about how a sealed result type and an image loader should be written.

The rest of the tooling is community. Compose HotSwan gives instant Compose UI changes on a running Android app with the state preserved, and it generates the preview images automatically. Turbine is a small testing library for kotlinx.coroutines Flow, and the .hotswan/ directory in the repository is its configuration. ksp handles the code generation.

There is a linked article for the technical contents, on shared element transitions in Jetpack Compose, and the Technical Contents section says the detailed information about the stacks used to build the project is in the articles linked below.

## The repository layout is a multi-module project

The top level listing shows a project with a build setup that is more elaborate than a single application module.

There is an app/ directory, a core/ directory and a feature/ directory, which is the conventional split for an Android project that has been modularised, and it matches the two layer description in the readme rather than contradicting it.

The build machinery is the more interesting part. There is a build-logic/ directory and a buildSrc/ directory, so the convention plugins live in the project rather than in a shared library, and a build.gradle.kts and settings.gradle.kts at the root. There is a spotless/ directory, so the code formatting is enforced by Spotless in the same way the Kotlin projects usually do it, and a .editorconfig for the parts Spotless does not cover.

Then there are directories that are specific to this project. A baselineprofile/ directory is the Baseline Profile module, which is the counterpart of the Baseline Profiles entry in the tech stack list. The .hotswan/ directory configures the hot reload tool. The figure/ directory holds the architecture diagrams the readme embeds, and previews/ holds the screenshot and the animated preview the readme shows.

The remaining files are the usual ones. There is a gradle.properties, the gradle/ directory, the gradlew and gradlew.bat launchers, a renovate.json for the dependency updates, and the .github/ directory, plus a CODE_OF_CONDUCT.md, a CONTRIBUTING.md, a LICENSE and a README.

## Conclusion

Adopt Pokedex Compose as a reference when you are setting up a new Android project and want a working example of Compose, Hilt, Room, Flow and MVVM in one codebase rather than a collection of snippets. Do not adopt it as a starter template to fork, because the release cadence is slow and the stack moves. Verify first which Compose and Kotlin versions the build scripts pin, that your minimum SDK is at least 21, and that the build uses the Gradle version in the wrapper, since the project uses a build-logic directory and a convention plugin setup rather than a single root build file.

## FAQ

### What is the Pokedex Compose project?

It is a sample application that demonstrates modern Android development with Jetpack Compose, Hilt, Coroutines, Flow, Jetpack for Room and ViewModel, and Material Design, based on MVVM architecture. The releases page carries the latest APK.

### What architecture does Pokedex Compose use?

MVVM with the Repository pattern, following Google's Guide to app architecture, split into a UI layer and a data layer. The UI layer sends user events to the data layer and the data layer provides data streams back, and the data layer operates autonomously with no dependencies on the layers above it.

### What does offline-first mean in this sample?

The data layer is composed of repositories that retrieve data from a local database or fetch it from a network, and it is designed to prioritize offline access, functioning primarily as an offline-first repository of business logic. It follows the single source of truth principle so that all data operations are centralized.

### Which libraries in Pokedex Compose are written by the same author?

Sandwich, a sealed API library for handling API responses and exceptions in Kotlin for Retrofit, Ktor and Kotlin Multiplatform, and Landscapist, the image loading library with the Glide, animation and placeholder modules. The other libraries are from the wider community.

### What are the minimum requirements for Pokedex Compose?

A minimum SDK level of 21, and the build uses the Gradle wrapper in the repository with a build-logic directory and a buildSrc directory for the convention plugins. The project is Kotlin based and licensed under Apache-2.0.

### How often is Pokedex Compose updated?

The last push was on 2026-04-10 and the recent releases are 1.0.4 from 2025-08-15, 1.0.3 from 2024-08-15 and 1.0.2 from 2024-04-21, so it is refreshed when the stack moves rather than on a fixed schedule.

## Sources

- [License: Apache-2.0](https://github.com/skydoves/pokedex-compose/blob/main/LICENSE)
- [Project website](https://skydoves.github.io/pokedex-compose/)
- [README](https://github.com/skydoves/pokedex-compose/blob/main/README.md)
- [Releases](https://github.com/skydoves/pokedex-compose/releases)
- [skydoves/pokedex-compose on GitHub](https://github.com/skydoves/pokedex-compose)

---

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