# Capy Reader for Android: Local Feeds and Server Accounts > Capy Reader is a Kotlin-based Android RSS reader for local feeds and accounts on Feedbin, FreshRSS, and Miniflux. Its strongest fit is readers who want Android 11 or later, several distribution options, and a small client rather than a separate server application. **jocmp/capyreader** — A smallish Android RSS reader - Repository: https://github.com/jocmp/capyreader - Website: http://capyreader.com/ - Stars: 1,424 · Forks: 81 - Language: Kotlin - License: GPL-3.0 - Published: 2026-10-16 · Updated: 2026-10-16 · Language: en - Canonical page: https://hysenlabs.com/projects/jocmp-capyreader ## Capy Reader's Supported Feed Model Capy Reader solves the problem of reading RSS and Atom feeds on Android without requiring one dedicated client for every publishing or aggregation service. The README identifies local feeds as one supported source, then names Feedbin, FreshRSS, and Miniflux as compatible services. That makes the app relevant to two distinct groups. Some readers maintain an RSS file or collection of local feeds and only need an Android reader. Others already keep subscriptions in one of the three named server-backed systems and want to use that existing library from a phone. The application is not a hosting platform for feeds. It does not present itself as a FreshRSS or Miniflux replacement, and the repository layout separates `minifluxclient`, `feedbinclient`, `readerclient`, `feedfinder`, and `rssparser` from the main `app` and `capy` directories. Based on those module names, Capy Reader contains client and parsing responsibilities around an external reading experience. The documentation does not describe server deployment, multi-user administration, or self-hosting the app itself. That boundary matters when choosing software. A person without a compatible feed service can still use local feeds, but the README does not explain how to import a large OPML file, migrate subscriptions from another app, or connect to arbitrary self-hosted RSS services. Those omissions make the supported source list a more reliable adoption boundary than the app's broader description as an RSS reader. ## Android 11 and Jetpack-Compose Delivery Capy Reader is written primarily in Kotlin and is delivered as an Android application rather than a command-line feed processor. Its Android 11 minimum requirement is concrete and easy to check before installation. The repository topics include `android`, `android-app`, `jetpack-compose`, and `material-design`, while the presence of `app/`, Gradle build files, and Android-specific resources is consistent with a conventional Android project. The README offers four download paths: Google Play, F-Droid, IzzyOnDroid, and GitHub Releases. All are described as free, but they are not interchangeable in maintenance expectations. Google Play and F-Droid releases are expected roughly weekly depending on features, fixes, and translations. GitHub Releases is the repository's direct release source. A separate nightly channel uses package names with the `-nightly` suffix and is explicitly labeled unstable and untested. This release structure gives users a clear choice between stable channels and a fast-moving package. It also creates a concrete warning: the three recent releases visible in the project record are all nightly builds, so a user who follows release recency without reading the suffix could confuse those artifacts with the weekly stable distribution. Capy Reader should be judged as an Android client with several supply channels, not as a server-side feed engine. ## Installing Capy Reader and Running the Android App For ordinary use, the README directs users to Google Play, F-Droid, IzzyOnDroid, or GitHub Releases. Choose the stable channel that matches the desired distribution source. Do not substitute a `-nightly` package if stability matters, because the README calls those builds unstable and untested. After installation, Android 11 or later is required. For development, the documented first-use path is to install Android Studio, sync Gradle, and run the `app` configuration. The README does not print a shell command for cloning or syncing, so no unsupported command is added here. Based on the repository layout, a developer should open the repository root in Android Studio and use the standard Gradle project contained there. The repository also exposes a documented test command through the Makefile. This runs the project test suite with Gradle's build cache enabled: ```bash make test ``` The Makefile expands that target to `./gradlew test --build-cache`, so a successful target means the wrapper-based Gradle test task completed. This is a developer verification step rather than an RSS subscription workflow, and the README does not document a command for adding a feed or signing in to a supported service. For a signed release, the README requires `release.keystore` in the repository root and a root-level `secrets.properties` file containing these keys: ```properties key_alias= store_password= key_password= ``` Those values must come from the developer's signing setup. The repository also includes `debug.keystore`, while the README says the default app build uses a debug keystore. Publishing release credentials is handled by separate Fastlane targets and should not be treated as part of normal local setup. ## Feedbin, FreshRSS, Miniflux, and Local Feeds Compared The most useful comparison is not Capy Reader against another Android reader, because the project documentation does not describe one. It is between the feed sources Capy Reader names. Local feeds keep the subscription source in files rather than in one of the listed server accounts. Feedbin, FreshRSS, and Miniflux are compatible service choices within Capy Reader's documented scope. The README does not state which features each service exposes through Capy Reader, so it would be misleading to promise identical folders, labels, states, or synchronization behavior across all three. Local feeds offer the narrowest documented path because no account provider is involved. That does not mean every RSS discovery or import feature is available, since those workflows are not documented. It does mean Capy Reader is not limited to users who already operate FreshRSS or Miniflux. A user with a direct feed URL has a supported route into the application. Service-backed reading serves people whose subscriptions already live with Feedbin, FreshRSS, or Miniflux. Capy Reader is the mobile client in that arrangement. If none of those services is acceptable, the relevant question is not whether Capy Reader is generally an RSS reader. It is whether the reader's feed source can be represented as a supported local feed. The repository's `readerclient`, `feedbinclient`, `minifluxclient`, `rssparser`, and `feedfinder` modules indicate separate integration areas, but the README does not describe their internal API contracts or guarantees. ## Full-Content Extraction and Its Documented Failure Mode Capy Reader has a full-content mode, but the README explicitly warns that it may fail on some sites because web pages are inconsistent. The failure is site-specific: the feed can still be supported while Capy Reader cannot extract the complete article from a particular publisher's page. The project asks users to submit a separate full-content request when this happens, which shows that parser coverage is maintained through site-specific work rather than presented as universally reliable. The repository also states that writing and verifying full-content parsers can be time-consuming. That affects the user in two ways. First, a missing site-specific parser cannot be assumed to be repaired automatically. Second, users who depend on clean article extraction should test the sites that matter to them rather than judging the feature only from the app's general interface. This is the clearest wrong-tool case in the documentation. Capy Reader is unsuitable as the sole reading path when every article must render reliably as extracted full text across an arbitrary set of sites and the project has not confirmed a parser for one of them. The README does not promise a fallback mode for every failed extraction, so the precise behavior after a parser failure should be checked in the app before adoption. ## Maintenance, Nightly Builds, and GPL-3.0 The repository is not archived, and its last push was on 2026-10-15. Recent release entries are dated 2026-10-07, 2026-10-10, and 2026-10-13, and the README describes stable Google Play and F-Droid releases as occurring every week or so depending on features, bug fixes, and translations. The last push date and release cadence indicate current project activity without proving that every device or site is fully supported. The nightly channel carries a different support expectation. Its package suffix is `-nightly`, and the README explicitly describes those builds as unstable and untested. That distinction affects upgrade cost: stable users are following the regular release path, while nightly users accept more frequent package changes and a higher possibility that a new build contains unfinished behavior. The README does not document a rollback procedure, so it also does not establish how a user should recover from a bad nightly package. Capy Reader is licensed under GPL-3.0. That identifies the repository's license, but this review does not give legal advice about distribution, modification, or compliance. Developers who fork the project, redistribute builds, or incorporate source code should read the actual `LICENSE` file and assess their obligations. Users choosing an APK from a store should also distinguish the stable and nightly packages by their package suffix. ## Conclusion Capy Reader suits Android users whose feeds are local or hosted by Feedbin, FreshRSS, or Miniflux, particularly those who want a dedicated APK from F-Droid, IzzyOnDroid, or GitHub Releases. It is a poor choice for readers who need an undocumented synchronization service, an iOS client, or reliable nightly builds. Before adopting it, verify that the required service is supported, Android 11 or later is available, and any full-content behavior needed for important sites meets expectations. ## FAQ ### What services does Capy Reader support? The README lists Feedbin, FreshRSS, Miniflux, and local feeds as supported sources. It does not document compatibility with arbitrary self-hosted RSS services. ### Does Capy Reader run on Android 11? Yes. The README states that Capy Reader is available for devices running Android 11 or later. ### Are Capy Reader nightly releases suitable for everyday use? The README describes `-nightly` builds as unstable and untested. They are separate from the regular Google Play and F-Droid releases. ## Sources - [jocmp/capyreader on GitHub](https://github.com/jocmp/capyreader) - [License: GPL-3.0](https://github.com/jocmp/capyreader/blob/main/LICENSE) - [Project website](http://capyreader.com/) - [README](https://github.com/jocmp/capyreader/blob/main/README.md) - [Releases](https://github.com/jocmp/capyreader/releases) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/jocmp-capyreader