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.
Weylus is a cross-platform application that turns tablets and smartphones into graphic tablets/touch screens for computers. It operates by running a local web server that serves a web page to the tablet's browser. The web page captures pointer, touch, stylus, keyboard, and wheel events via JavaScript PointerEvents and sends them over a WebSocket connection to the server. The server then simulates these input events on the host machine using platform-specific mechanisms: on Linux it uses the uinput kernel module for full stylus/touch/mouse/keyboard support; on macOS and Windows it falls back to the autopilot library for mouse/keyboard simulation and Windows-specific synthetic pointer injection for touch/pen. Simultaneously, Weylus captures the screen (or a selected window/monitor) using platform-native APIs: X11 shared memory (XShm) on Linux X11, PipeWire/GStreamer on Wayland, CoreGraphics on macOS, and DirectX via captrs on Windows. The captured frames are encoded into a fragmented MP4 H.264 video stream using a statically linked ffmpeg (libx264) with optional hardware acceleration (VAAPI, NVENC, VideoToolbox, MediaFoundation). The video stream is sent to the browser via the same WebSocket connection and played using the Media Source Extensions API. The application provides a GUI (built with FLTK) for configuration and a headless mode for automation. It supports access codes, custom input areas, and multiple simultaneous clients.
This is an Android application that turns a smartphone into an SMS/MMS gateway. It exposes a local REST API (Ktor-based HTTP server) for sending and receiving messages, supports cloud server integration via Firebase and Server-Sent Events, and provides webhook delivery, end-to-end encryption (RSA-OAEP + AES-GCM), and device key rotation. The architecture is modular: foreground services (SSE, ping, local server), WorkManager workers for background tasks (message sending, webhook queue processing, inbox upload, settings sync), a Room database for persistence, and Koin for dependency injection. The codebase is well-structured with event-driven communication via a custom EventBus, a validated state machine for message lifecycle, encrypted storage, and rich UI fragments. It supports SMS, MMS, and data SMS, with inbound message capture via broadcast receivers and content observers.
LinkSheet is an Android application that intercepts URL intents and presents a Material3 bottom sheet allowing users to choose which app or browser handles the link. In production, it replaces the removed Android 12+ chooser, supporting preferred app per domain, usage-based sorting, browser modes (always ask, none, whitelisted, single browser), and advanced URL processing including AMP to HTML conversion, redirect following, ClearURLs (tracker removal), FastForward (redirect bypass), LibRedirect (privacy-friendly frontends), and a custom rule engine (scenarios) for fine-grained link routing. The architecture is multi-modular: core app module, feature modules (analytics, backup, browser, device compat, downloader, engine, libredirect, profile, remote config, shizuku, wiki), integration libraries (amp2html, clearurl, embed-resolve, fastforward, mime-types), and shared libraries (api, compose, bottom-sheet, scaffold, http). Key entry points are `BottomSheetActivity`, `MainActivity`, and `LinkEngineService`. The system uses Koin dependency injection, Jetpack Compose for UI, Room for local caching, Ktor/OkHttp for networking, and Shizuku for privileged operations. It is actively maintained with nightly builds, extensive unit/instrumentation tests, and a large localization effort across 20+ languages.
DUNE is a specialized Android TV client application for the Jellyfin media server ecosystem. It functions as a media consumption interface optimized for remote control navigation, featuring video/audio playback, library browsing, live TV (DVR) management, and extensive user customization. The architecture is a monolithic Android application with modularized internal structure (app, playback, preference modules), utilizing a hybrid UI approach that combines Jetpack Compose for modern screens (preferences, overlays) with Android Leanback widgets for traditional TV browsing. The codebase demonstrates strong separation of concerns, particularly in the playback layer which abstracts media rendering logic from the UI. It relies heavily on the Jellyfin SDK for API communication and ExoPlayer (Media3) for media rendering.
vkbind is a Vulkan API loader and code generator that creates a single header file containing all Vulkan API definitions and functions for dynamically loading Vulkan functions. It parses the official Vulkan XML specifications (vk.xml and video.xml) to generate a comprehensive C header that eliminates the need for the official Vulkan SDK. The generated header includes type definitions, enumerants, function prototypes, and loader functions like vkInit(), vkInitInstanceAPI(), and vkBindAPI() for accessing Vulkan functionality across different platforms.
SmartTube is a free, open-source Android TV YouTube client that replaces the official YouTube app with enhanced features like SponsorBlock integration, adjustable playback speed, 8K/HDR support, live chat, and no dependency on Google Services. The architecture is a modular Android application built on a heavily customized fork of ExoPlayer (v2.10.6, Amazon variant) for media playback, and AndroidX Leanback (v1.0.0) for the TV-optimized user interface. The codebase follows a presenter-view pattern with clear separation of concerns, using singleton presenters and view interfaces. Key entry points include SplashActivity, BrowseActivity, PlaybackActivity, and various settings dialogs. Data flows primarily from YouTube's unofficial API (via SABR streaming protocol) through custom ExoPlayer extensions, with additional integrations for SponsorBlock, DeArrow, remote control, and Google Drive backup. External dependencies include ExoPlayer (forked), Leanback (vendored), Glide, RxJava, WorkManager, and a few third-party UI libraries (chatkit, slidableactivity, filepicker).
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.
YTDLnis is a feature-rich Android application that serves as a graphical frontend for yt-dlp, enabling users to download video and audio from over 1000 websites. The app follows the MVVM architecture with Room database for local persistence, WorkManager for background download tasks, and a repository pattern for data access. It provides a comprehensive download management system including queue management, scheduling, format selection, metadata embedding, chapter splitting, SponsorBlock integration, and support for custom yt-dlp commands. The application also includes a built-in terminal emulator for advanced users, cookie management, YouTube PoToken generation, and an observe-sources feature for monitoring channels or playlists for new content. The codebase is well-organized into UI fragments, viewmodels, repositories, and utility classes, with extensive use of Kotlin coroutines and Android Jetpack components. While the app is actively maintained and demonstrates solid engineering practices, some modules like UiUtil.kt are monolithic and tightly coupled, and the heavy reliance on external tools (yt-dlp, FFmpeg, Python) introduces ongoing maintenance risks.
This is an awesome list curating applications, libraries, and tools that leverage Shizuku, an Android API for providing elevated privileges (ADB) to normal apps without root. The repository itself is not a software application but a meticulously maintained directory with automated tooling including link checking, formatting linting, and translation synchronization scripts. The Python scripts (check_links.py, lint.py, sync_translations.py) exhibit non-obvious skill in automating awesome list maintenance and are reusable for similar curation projects. The list is comprehensive, well-organized, and actively maintained with CI pipelines and regular updates.
This is not a conventional software application — it is a curated awesome-list repository (classified as 'application' only because its CI/CD pipeline and shell tooling are the sole executable content). The actual product is README.md: a comprehensive, categorized catalog of Android security resources covering online analyzers, static/dynamic analysis tools, reverse-engineering utilities, fuzzers, vulnerability scanners, intentionally vulnerable practice apps, research papers, malware datasets, exploit lists, and bug bounty programs. The repository ships no libraries, services, or user-facing code; its runtime behavior is limited to link-liveness checking (urlsup) and linting of the repository's own documentation and automation. The repository's engineering value lives in its maintenance infrastructure. GitHub Actions workflows lint Markdown (mdl), shell scripts (shellcheck), YAML (yamllint), and the workflows themselves (actionlint plus a zizmor security scan), while a scheduled job validates all README links weekly using a carefully curated urlsup configuration (.urlsup.toml) that distinguishes dead links (strikethrough-removed from the list) from flaky or bot-protected endpoints (allowed 403/429/503). Dead and archived tools are explicitly marked with strikethrough in the README, keeping the resource list honest without silently deleting historical references. All third-party actions are pinned to commit SHAs, permissions are least-privilege, and the cargo-based link checker is cached for fast CI runs. For an Android security practitioner, the repo serves as the de facto reference index for the ecosystem — many entries point to the actual tools (MobSF, Drozer, Frida, jadx, Androguard, QARK) and malware datasets (AndroZoo, Drebin, Kharon). For an engineer, the reusable assets are the link-liveness pipeline and the CI self-audit pattern, both of which can be transplanted into any link-heavy or automation-heavy repository. The repo is a hybrid: content-curation project with application-grade CI scaffolding around it, rather than either a true application or a data research project.
This is a comprehensive server monitoring and management platform called ServerBox (Flutter Server Box). It consists of a cross-platform Flutter mobile/desktop app, a Rust-based agent (monitor) that collects system metrics and exposes a REST/WebSocket API, and a Svelte web panel. The system supports SSH terminal sessions, SFTP file management, container management, virtual machine management (Proxmox VE and libvirt), BMC/Redfish power and sensor monitoring, firewall management (ufw/firewalld), cron, systemd/OpenRC services, process management, benchmark execution, custom commands, and push notifications. The architecture is heavily dependent on shared Rust crates (`sbm_parser`, `sbm_virt`, `sbm_redfish`, `sbm_ffi`) that are used both by the agent and via FFI by the Flutter app. This is a production-grade, actively maintained project with extensive test coverage across all layers.
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).
macroquad is a Rust game engine and graphics library inspired by raylib, providing a simple, immediate-mode API for 2D and 3D rendering, audio, input handling, and UI. The codebase is structured as a monolithic core library with several subcrates (particles, tiled, profiler, physics-platformer, macroquad_macro) that add specialized functionality. The architecture centers on a single-threaded game loop orchestrated by the `#[macroquad::main]` proc macro, with drawing batched via an internal OpenGL abstraction (miniquad). Key data flows include texture and font loading, immediate-mode UI widget rendering, and an experimental scene/coroutine system for game logic. The library is cross-platform (Windows, Linux, macOS, Web, Android, iOS) and emphasizes minimal dependencies and ease of use. While the core is tightly coupled, several subcrates and subsystems are well-encapsulated and demonstrate high craftsmanship.
FairEmail is a fully-featured, open-source, privacy-oriented email client for Android. It supports IMAP, POP3, SMTP, OpenPGP, S/MIME, and OAuth for major providers (Gmail, Outlook, Yahoo). The app is built as a standard Android application with Activities, Fragments, Services, and WorkManager workers. It uses Room for local persistence, LiveData for reactive UI, and a custom async pattern (SimpleTask) for background operations. The codebase is notable for its extensive use of vendored libraries: it includes modified copies of JavaMail (javax.mail, com.sun.mail), AndroidX internals (Room, Paging, Emoji2, RecyclerView Selection), Google Protocol Buffers, and native language/encoding detection engines (CLD3, compact_enc_det). This hybrid approach provides deep email protocol support and privacy features like tracker blocking, certificate transparency, and DANE, but also introduces maintenance overhead and potential drift from upstream versions. The app integrates AI features (Gemini, OpenAI) for summarization and rule actions, and includes a full rule/filter engine. Despite the heavy vendoring, the core application code demonstrates solid engineering with clean abstractions, custom views that work around Android platform bugs, and a consistent async pattern. The repository is actively maintained with frequent releases and responsive issue triage.
ReNative (rnv) is a cross-platform development CLI tool and framework that enables building applications for mobile (iOS, Android), web, TV (Tizen, webOS, Fire TV, Android TV, tvOS), desktop (macOS, Windows, Linux, Electron), wearables, and consoles from a single codebase. The system uses a monorepo architecture with modular packages: a core library (`@rnv/core`) providing configuration merging, plugin management, template injection, and task orchestration; platform-specific engines (`@rnv/engine-rn`, `@rnv/engine-rn-electron`, `@rnv/engine-rn-next`, etc.) that define build logic and native project templates; SDK packages (`@rnv/sdk-android`, `@rnv/sdk-apple`, `@rnv/sdk-tizen`, etc.) for platform-specific tooling like device management and code generation; and a CLI entry point (`rnv`) that dispatches commands to registered tasks. The primary data flow involves reading hierarchical configuration files (`renative.json`, `appConfigs/`), merging them with plugin definitions and engine defaults, injecting placeholders into platform templates (e.g., AndroidManifest.xml, Xcode project files, Webpack configs), and then invoking native build tools (Gradle, Xcode, Webpack, etc.) to produce deployable artifacts. External dependencies include React Native, Electron, Next.js, Webpack, and platform SDKs (Android SDK, Xcode, Tizen SDK, webOS SDK). The framework also includes a telemetry module, Docker integration, and a build hooks system for custom pre/post-publish scripts.
Kaspresso is a comprehensive Android UI testing framework built on top of Espresso (via Kakao) and UI Automator (via Kautomator), providing a Kotlin DSL for writing stable, readable tests. It offers extensive built-in reliability mechanisms: flaky safety (automatic retries with configurable timeouts), auto-scroll fallback, system dialog handling, and element reloading. The framework includes a modular interceptor architecture for customizing test behavior, device manipulation APIs (network, location, phone, permissions, logcat, screenshots, video recording), and integration with Allure for reporting and Jetpack Compose for modern UI testing. Additionally, it provides an ADB server for executing shell commands on the device and a command-line tool for generating page objects from UI dumps. The codebase is well-structured with multi-module Gradle projects, convention plugins, and extensive sample apps demonstrating real-world usage.
Carrier IMS for Pixel is an Android application that provides a comprehensive toolkit for configuring IMS (IP Multimedia Subsystem) settings on Google Pixel devices. It leverages Shizuku to perform privileged operations such as overriding carrier configurations (VoLTE, VoWiFi, VoNR, 5G NR), modifying APN settings, fixing captive portal detection, and reading IMS registration status. The app features a Jetpack Compose UI with multiple tabs (IMS, Extra, Support, Partners, About), per-SIM configuration management, Quick Settings tiles, in-app updates, and a donation/ad system. The architecture follows a clean separation with ViewModels, a central ShizukuProvider that bridges IPC to instrumentation classes, and reusable utility modules. While primarily an application, it includes diagnostic logging and data persistence for configuration backups, giving it a minor hybrid character.
Episteme is a modern, cross-platform e-book and document reader built with Kotlin Multiplatform and Compose Multiplatform. It supports a wide array of formats including EPUB, PDF, MOBI, audiobooks (M4B), FB2, DOCX, ODT, PPTX, and comic archives (CBZ/CBR). The app offers a rich reading experience with paginated and vertical scroll modes, text-to-speech, ink and text annotations, OPDS catalog browsing, cloud sync via Google Drive and Firestore, AI-powered summarization, and extensive customization (themes, fonts, brightness). The codebase is organized into a shared module containing core business logic, models, and policies, with platform-specific implementations for Android (native Compose, Room, WorkManager), iOS (Swift), and Desktop (Compose Desktop, Swing interop). The architecture follows a clean separation of concerns with expect/actual abstractions for platform services, making it a strong example of production-ready KMP application design.
Muviz is a modern Android application built with Jetpack Compose that serves as a movie and TV show discovery client for the TMDB API. It follows a clean MVVM architecture with feature-based packaging, using Hilt for dependency injection, Retrofit for networking, Room for local favorites persistence, and the Paging 3 library for efficient data loading. The app provides a bottom-navigation interface with Home, Search, Favorites, and Account screens, supporting both movies and TV series with categories like trending, popular, upcoming, and top-rated. It includes a custom theme system with light, dark, system, and Material You options, and features animated UI components such as a vote average arc indicator and swipe-to-delete on favorites. The codebase is well-structured and uses modern Android development practices, though some screens (like cast details) are incomplete and there is some code duplication in ViewModels.