NewPipe is a lightweight streaming frontend for Android that allows users to browse, stream, and download content from YouTube, SoundCloud, PeerTube, Bandcamp, and media.ccc.de without using official APIs or requiring a Google account. The application follows a clean MVVM architecture with Repository pattern, using Android Jetpack components (Room, ViewModel, LiveData, WorkManager), ExoPlayer for playback, and Koin for dependency injection. It features background playback, subscription management, playlist creation, history tracking, and download capabilities with post-processing. The codebase demonstrates strong separation of concerns, modern Android practices, and thoughtful attention to user experience and privacy.
Aves is a Flutter-based mobile application (primarily Android, given the extensive Kotlin platform code) that functions as a high-performance media gallery and manager. It browses local storage, indexes media into a SQLite database, extracts and allows editing of extensive metadata (EXIF, XMP, IPTC, MP4), and provides a rich viewing experience including maps, video playback with subtitle support, and custom gesture-driven zoom/pan. The codebase is notable for its modular plugin architecture (magnifier, map, video, model, services), its defensive approach to parsing potentially corrupt media files on the native Android side, and its comprehensive internationalization and multi-calendar support. It is a mature, actively developed application with a strong focus on user experience and data integrity.
This repository is a web application for generating privacy policies and terms of service for mobile and web apps. Built with Vue.js 3 and Bulma CSS, it features an 8-step wizard interface where users configure policy type (Simple, No Tracking, GDPR), app details, platforms, features, and third-party services. The application generates customized HTML/Markdown policies deployable to Flycricket or downloadable directly. It includes a PWA with service worker for offline support, internationalization (English/German), and a persistent theme toggle. The architecture centers on Vue composables for state management (app state, wizard navigation, content generation) and a Go-based build system that processes Go templates, compiles Less to CSS, and minifies assets. Key reusable patterns include modular template mixins, a flexible modal system, and utility functions for DOM manipulation. An ancillary tool in `tools/reviews-page-generator` fetches GitHub issue comments to generate a static testimonials page. The codebase demonstrates strong engineering practices: comprehensive Playwright test suite, golden HTML regression tests, dependency management via Go modules and package.json, and automated deployment workflows. While the custom build pipeline adds slight complexity, the separation of concerns and reusable components indicate maintainable, craftsmanship-driven development.
v2rayNG is a production-grade Android VPN/proxy client that provides a comprehensive interface for managing V2Ray and Xray proxy configurations. It supports multiple proxy protocols (VMess, VLESS, Shadowsocks, Trojan, WireGuard, Hysteria2, SOCKS, HTTP), subscription management with auto-update, routing rules, per-app proxy, and backup/restore via local files or WebDAV. The app runs in three modes: VPN (TUN), proxy-only (local SOCKS/HTTP), and root (iptables transparent proxy). It uses native cores (Xray or v2fly) via JNI and manages complex configuration generation, including DNS segmentation, observatory-based load balancing, and fragment settings. The architecture follows standard Android patterns with Compose UI, ViewModels, and background services in separate processes. The codebase is actively maintained with a large community, though some modules (e.g., CoreConfigManager) are monolithic and could benefit from further decomposition.
This is an Android PDF viewer application built with Jetpack Compose that uses Mozilla's pdf.js library for rendering. The app displays PDFs in a sandboxed WebView with strict security policies, handles encrypted PDFs, provides navigation controls, outline viewing, document properties, and various UI features like zoom, rotation, and text layer visibility. The architecture follows MVVM with a ViewModel managing state and a Compose UI layer. The app uses content providers to securely load PDF content without granting the WebView access to files or network.
Otter Music is a cross-platform music player application that aggregates multiple music sources (NetEase, QQ Music, Kuwo, Kugou, Migu, Bilibili, etc.) into a unified interface. It features music search, playback, playlist/favorites management, lyrics display, sleep timer, offline downloading, and cross-device synchronization via Cloudflare KV. The architecture combines a React/Vite frontend with Zustand state management, a Cloudflare Workers/Hono backend for API proxying and sync, and Capacitor for native Android integration. Key entry points include src/main.tsx (frontend root), functions/app.ts (backend), and android/app/src/main/java/com/otterhub/music/MainActivity.java (native). Data flows involve unified music API calls to platform-specific providers, audio URL resolution with caching, encrypted IndexedDB persistence for user state, and sync via Cloudflare KV. External dependencies include numerous music APIs, Capacitor, React, Zustand, Tailwind CSS, and Radix UI primitives.
Czkawka is a multi-tool file cleanup utility written in Rust that finds and removes duplicate files, similar images/videos/music, empty directories, broken files, temporary files, and more. It is structured as a Rust workspace with a shared core library (`czkawka_core`) that implements all scanning algorithms and a common architecture (traits, caching, progress reporting). Three frontends exist: a CLI (`czkawka_cli`), a legacy GTK4 desktop GUI (`czkawka_gui`, in maintenance mode), and a modern Slint-based desktop GUI (`krokiet`) which is the primary focus. An additional Slint-based Android app (`cedinia`) also reuses the core. The codebase demonstrates strong software engineering practices: modular design, extensive use of traits, parallel directory traversal with a builder pattern, generic caching, and comprehensive localization via Fluent. Despite some duplication between frontends and the deprecated GTK GUI, the core library is well-crafted and reusable.
App Manager is a production Android package-management application rather than a data or research codebase. The source code confirms a deep, privileged management tool: it inspects installed applications, edits components/permissions/app ops, freezes and uninstalls packages, backs up and restores app data with multiple encryption schemes (AES, RSA/ECC, OpenPGP), applies profiles and batch operations, manages root/ADB execution, performs APK/tracker/VirusTotal analysis, and bundles ancillary tools such as a file manager, code editor, logcat viewer, PDF/audio viewers, and terminal. The hybrid-looking data features—VirusTotal scan caching, tracker signature datasets, usage statistics, debloat lists—are product features, not the repository's primary purpose.
This is an Android application that wraps the DeepL translation website in a WebView to provide a native-like experience. The app features text selection integration, dark mode support, popup mode for floating translations, and settings persistence. It uses a custom NestedScrollWebView to properly handle scrolling interactions within bottom sheets and other nested scrolling contexts. The architecture follows standard Android patterns with Activities, Services, and helper classes for specific functionalities like URL manipulation, cookie management, and WebView configuration.
QRServ is an Android application that turns a device into a local file-sharing server. Users select files (or use Direct Access Mode for single files without copying), and the app starts an embedded Ktor HTTP server on an unused port. The server URL is displayed as a QR code for other devices on the same network to scan and download files. Optionally, on Android 13+, QRServ can create a private Wi-Fi hotspot (with band selection on Android 16+) so that only devices joining the hotspot can access the files. The app runs a foreground service with a persistent notification, handles HTTP range requests for large files, and includes an idle timeout that automatically stops the server when no downloads occur for a configurable period. The architecture follows a standard Android MVVM pattern with Jetpack Compose UI, using StateFlow for reactive state management and a centralized ViewModel (QRServViewModel) that orchestrates server lifecycle, network callbacks, and hotspot control. The codebase demonstrates strong engineering practices including comprehensive unit tests, separation of concerns into repositories and controllers, and careful handling of Android-specific edge cases such as permission revocations, network changes, and file removal during sharing. The app is available on Google Play and IzzyOnDroid with multi-language support.
ReVanced Manager is an Android application that applies custom patches to Android APKs using the ReVanced Patcher engine. It provides a user interface for downloading patch bundles, selecting and configuring patches, patching applications (including a background patcher service), signing the resulting APKs, and installing them. The app is built with modern Android technologies: Jetpack Compose for UI, Room for local persistence, Koin for dependency injection, Ktor for networking, and WorkManager for background tasks. It follows an MVVM architecture with a repository pattern and supports root-based installation via Magisk modules. The application manages a complex state of patch selections, downloaded apps, installed apps, and options through a Room database with schema migrations. It includes a downloader plugin system for acquiring APK files from various sources, automatic update checks for the manager itself, patches, and downloaders, and extensive localization support via Crowdin.
EhViewer is a high-performance Android client for browsing, reading, and downloading galleries from the E-Hentai / ExHentai image hosting sites. It is a modern fork of the classic EhViewer app, built entirely with Kotlin Multiplatform for shared logic and Jetpack Compose with Material Design 3 for the UI. The architecture is modular (app, core/common, core/data, core/ui, core/i18n) and leverages Rust via JNI for performance-critical HTML parsing and image processing (border detection, QR code detection, WebP animation). The app features a full-featured reader with multiple reading modes, a foreground download service with speed tracking, comprehensive offline support via Room/SQLite, and integration with GitHub releases for updates. The codebase is actively maintained, uses the latest Kotlin, Compose, and Ktor versions, and demonstrates strong engineering practices with clean abstractions, coroutine-based reactive state, and type-safe preferences. It is a dedicated application project with no data science or research components.
Termux is an Android terminal emulator and Linux environment app that provides a full command-line experience on Android devices. It combines a VT100/xterm-compatible terminal emulator (written in Java with JNI for PTY creation) with a bootstrap Linux environment containing common command-line tools (bash, ssh, compilers, etc.). The architecture is modular: a core terminal-emulator library handles escape sequences, Unicode, sixel graphics, and session management; a terminal-view module provides the Android View widget for rendering; a termux-shared library contains reusable utilities for file I/O, IPC, preferences, error handling, and shell execution; and the app module ties everything together with activities, services, and a plugin ecosystem (API, Float, Tasker, Widget, etc.). Key entry points include TermuxActivity (main UI), TermuxService (foreground service managing sessions), RunCommandService (plugin command execution), and TermuxInstaller (bootstrap setup). External dependencies include Android SDK (target 28, compile 36), Gradle, NDK for native code, and libraries like Apache Commons IO, Guava, and Markwon for markdown rendering.
Threema Android is a secure messaging application with end-to-end encryption using NaCl/libsodium. It features a modular architecture following clean architecture principles with separation into app, domain, data, and common layers. The app uses MVVM with ViewModels and StateFlow/LiveData, dependency injection via Koin, and Kotlin coroutines for asynchronous operations. Key functionality includes text/media messaging, voice/video calls, group chats, polls, contact management, backup/restore, multi-device synchronization, and availability status indicators. The application supports multiple build variants for different distribution channels (Google Play, Huawei AppGallery, F-Droid, Threema Shop) and includes enterprise features for business users. It relies on SQLCipher for encrypted local storage, implements custom CSP/D2M protocols for server communication, and provides web client functionality for desktop access.
Loop Habit Tracker is a mature, open-source Android application for building and maintaining habits through daily check-ins, scoring, streaks, and detailed statistics. The system is architected as a Kotlin Multiplatform project with a shared core module (`uhabits-core`) containing all business logic, models, commands, and platform abstractions, and an Android-specific module (`uhabits-android`) providing the UI, widgets, notifications, and platform implementations. The core uses an MVP-like pattern with presenters, immutable state, and a command pattern for all habit mutations (create, edit, delete, archive, toggle checkmarks). Data is persisted locally in SQLite with a custom migration system supporting 25+ schema versions. The app features extensive home screen widgets (checkmark, score, streak, frequency, history, target), reminders with snooze, Tasker/Locale automation, CSV export, and import from other habit trackers (HabitBull, Rewire, Tickmate). External dependencies include AndroidX, Material Components, Ktor (for sync), AppIntro, and OpenCSV. The codebase demonstrates strong engineering practices: dependency injection via kotlin-inject, platform-agnostic canvas drawing for custom charts, a robust caching layer for list performance, and comprehensive test coverage including unit tests, instrumented UI tests, and snapshot-based rendering tests.
WiFiAnalyzer is a mature, open-source Android application for analyzing Wi-Fi networks. It scans nearby access points, displays signal strength graphs (channel and time-based), provides channel ratings for optimizing Wi-Fi performance, and identifies vendor names via OUI lookup. The architecture is a standard Android app with Activities, Fragments, Navigation (drawer + bottom navigation), and a modular package structure. It uses Kotlin, AndroidX, and the Vico charting library for real-time graph rendering. The codebase exhibits strong software engineering practices: extensive unit and instrumented test coverage (over 50 test files), CI/CD with GitHub Actions, dependency version catalog, and high code quality standards enforced by lint and ktlint. While primarily an application, it processes Wi-Fi scan data to derive actionable insights (channel ratings, signal strength over time), giving it a minor data-research character. Key entry points include MainActivity and the ScannerService, which orchestrates periodic scanning and data transformation.
Rush is a cross-platform lyrics application built with Kotlin Multiplatform and Compose Multiplatform, targeting Android, iOS, and Desktop (JVM). Its primary function is to search for, display, and share synced lyrics (line-synced and syllable-synced) from multiple sources including LrcLib, Genius, and a custom LyricsPlus API. The app integrates with the system's media playback to auto-detect the currently playing song and fetch matching lyrics. Notable features include romanization of lyrics for non-Latin scripts (Japanese, Korean, Hindi, Punjabi, Cyrillic) via a dedicated Android library, customizable visualizers (wave, gradient, hypnotic) for lyrics backgrounds, and a variety of share card styles (Spotify, Rushed, Brat, etc.). The architecture follows MVVM with Koin for dependency injection, Room for local persistence, DataStore for preferences, and Ktor for networking. The codebase is well-modularized with shared core, logic, and UI modules, though significant parts of iOS and Desktop support remain stubbed or incomplete.
LibrePods is a cross-platform application suite whose verified purpose is to liberate Apple AirPods from the Apple ecosystem, providing full accessory management on non-Apple hardware. The Android app (Kotlin/Jetpack Compose) offers battery monitoring via BLE manufacturer-data parsing, noise-control mode switching, ear detection, head-gesture recognition, hearing aid adjustments, custom EQ, device takeover, home-screen widgets, Quick Settings tiles, and iOS-style popup overlays. The Linux companion (Qt6/QML) delivers the same control surface through a system tray app backed by BlueZ and PulseAudio, with a Rust rewrite in progress per the ci-linux-rust.yml workflow.
This repository is the manifest and build orchestration layer for Nova Video Player, an open-source Android video player. It does not contain the application source code itself; that resides in referenced submodules (Video, MediaLib, FileCoreLibrary, native/avos, etc.). The repo provides a repo-based manifest, Makefile, Dockerfile, CI/CD workflows, release scripts, comprehensive FAQ documentation, and SDK setup scripts. The build system is sophisticated, supporting native code compilation (FFmpeg, dav1d, libtorrent, etc.) via Android NDK, Gradle wrappers, and external dependency management. The repo is actively maintained with frequent releases and detailed changelogs. While the core application code is not present here, the build infrastructure demonstrates high craftsmanship with clear documentation, automated releases, and continuous integration. The repo serves as an entry point for building the entire application across multiple stores (Google Play, Amazon, F-Droid).
This repository is a GitHub template for bootstrapping Kotlin Android projects with a modern, opinionated build setup. It provides a multi-module structure (app, library-android, library-kotlin, library-compose) with pre-configured static analysis via detekt, CI/CD via GitHub Actions, and publishing to Maven Central. The codebase demonstrates best practices for Gradle Kotlin DSL, version catalogs, and precompiled script plugins. The sample modules include a simple factorial calculator to illustrate cross-module dependencies and testing patterns (unit, instrumentation, and Compose UI tests). While the template is not a production application itself, it serves as a solid foundation for new Android projects, emphasizing code quality and automation from the start.