ElegantFin is a comprehensive CSS theme for the Jellyfin media server, providing a modern, dark UI overhaul inspired by Jellyseerr. It is delivered as a single CSS import and relies entirely on CSS custom properties (design tokens) for customization, allowing users to adjust colors, layout, and visibility toggles. The theme is built with PostCSS and includes optional add-on stylesheets for custom media covers and third-party plugin support. The codebase consists of versioned, monolithic CSS files that override Jellyfin's default styling across desktop, mobile, and TV layouts. It is not an application backend or data pipeline; it is a pure client-side presentation layer. The theme demonstrates strong CSS craftsmanship through extensive use of modern selectors (`:has()`, `@container`, `@supports`), responsive card grids, and design token abstraction, though it suffers from duplication across versions and reliance on external CDN resources.
Curbox is a digital wellbeing Android application that leverages AccessibilityService to monitor and intervene in user behavior. It blocks distracting apps, websites, keywords, and short-form videos (reels/shorts), enforces focus sessions (with pomodoro), applies grayscale filters, displays mindful message overlays, and hides UI elements via a custom domain-specific script engine. The app tracks detailed usage statistics (app, website, reel, focus) locally in Room and optionally synchronizes across devices using Supabase with end-to-end encryption (paywalled subscription). It provides anti-tamper features including device admin protection, uninstall prevention, and a settings change delay mechanism. The architecture is a monolithic Android app with multiple build flavors (F-Droid, Play Store, full) that gate features like cloud sync, UI hider, and device admin. It exposes an AIDL-based API for external apps. The codebase demonstrates strong engineering with reusable components like a custom script interpreter, encryption utilities, and pattern-based accessibility node selectors, but carries technical drift from deprecated Android APIs and hardcoded app-specific identifiers.
Chocola is an offline music player for Android built with Kotlin and Jetpack Compose. It provides a full-featured music experience: library browsing by albums, artists, playlists, and folders; playback with equalizer, speed/pitch control, sleep timer, and shuffle/repeat modes; synced lyrics display and editing; metadata editing; Android Auto support; and home screen widgets. The app uses Material 3 design with a distinctive 'cute' theme, custom navigation, and extensive localization. The architecture follows a typical Android MVVM pattern with Room for playlist persistence, DataStore for preferences, ExoPlayer/Media3 for playback, and Koin for dependency injection. It scans local media via MediaStore and SAF, applies configurable filters (minimum duration, hidden tracks, whitelisted folders), and uses TagLib for metadata editing. While the codebase is well-organized and demonstrates solid Android engineering, it relies heavily on experimental Compose APIs and a custom navigation library, which introduces some technical drift risk. Overall, it's a mature, actively maintained open-source project suitable for reuse of specific UI components and data-layer patterns.
Geto is an Android application that allows users to apply specific device settings (like disabling Developer Options or USB debugging) when launching particular apps, and automatically revert those settings when exiting the app. The app follows a clean architecture with separate modules for presentation, domain, and data layers. It uses Jetpack Compose for UI, Hilt for dependency injection, and Kotlin Coroutines for asynchronous operations. Key features include creating app shortcuts that trigger settings changes, a foreground service to monitor system setting changes, and secure storage of app-specific configurations using Room database and DataStore. The application requires the WRITE_SECURE_SETTINGS permission to modify system settings, which must be granted via ADB or Shizuku.
Friendly Eats is an Android restaurant recommendation app that uses Firebase Firestore for real-time data synchronization and Firebase Authentication for user sign-in. The app features a main screen with a filterable and sortable list of restaurants, a detail view for individual restaurants, and the ability to add ratings. The architecture follows Android Jetpack guidelines with a single activity, multiple fragments, ViewModel for UI state, and the Navigation component for fragment transactions. Firestore queries are used to fetch and listen to restaurant data, with transactions ensuring data consistency when adding ratings.
Spam Call Blocker is an Android application written in Kotlin that blocks unwanted incoming calls using a combination of local blocklists, pattern matching, and real-time checks against multiple online phone reputation services (UnknownPhone, Tellows, Truecaller, and regional directories). It registers a call screening service to intercept calls, evaluates them against user-defined rules and external APIs, and can block, mute, or answer-and-hangup spam calls. The app provides a full settings UI for managing blocked/whitelisted numbers, pattern-based blocking, API toggles, and export/import of configuration. It also includes a donation screen and automatic update checking via GitHub releases. The codebase is well-structured with clear separation of concerns, uses Kotlin coroutines for concurrent API checks, and supports multiple languages.
SimpMusic is a production-grade Kotlin Multiplatform music player for Android and desktop (JVM) that streams from YouTube Music's undocumented backend. The codebase is organized around a shared Compose Multiplatform UI module (composeApp), Android entry points (androidApp), a desktop entry point (desktopApp), and optional feature modules for Google Cast, Last.fm scrobbling, and crash reporting. A separately referenced core submodule supplies domain and media-service logic. Internally it uses MVVM with Koin dependency injection, Repository interfaces backed by Room entities and DataStore, StateFlow-based ViewModels, and a large custom Compose component library covering home feed, library management, playlist sync, fullscreen player, lyrics, equalizer, podcasts, Android home-screen widgets, and a desktop mini-player. The app is shipped as a packaged consumer application with Play Store metadata, GitHub Actions, fastlane changelogs, and build variants that swap real integrations for empty stubs in FOSS builds.
This repository is an Android application that bridges device events (SMS, MMS, missed calls, battery changes, app notifications) to a Telegram bot for monitoring and remote control. It uses the Telegram Bot API to forward events and long-polls for incoming commands to send SMS, USSD, list/read/delete SMS, fetch logcat, and more. The architecture is a monolith with multiple background services, broadcast receivers, and job scheduler jobs, all within a single Android app. It uses MMKV for key-value storage, OkHttp for HTTP, Gson for serialization, and libsodium for encryption. The codebase is well-structured with reusable utility classes (e.g., custom Mustache template engine, Telegram API wrapper, encryption helpers) and has unit tests for several components. It supports multi-language, QR code configuration import, and carbon-copy forwarding to external services via HAR format.
Androidify is a modular Android application that allows users to create personalized Android robot avatars using AI. It accepts a photo (from camera or gallery) or a text prompt, then generates a custom Android mascot image via a fine-tuned Imagen model through Firebase Vertex AI, with on-device Gemini Nano as a fallback for prompt generation and image validation. The app uses ML Kit for pose detection in the camera flow and subject segmentation for background removal. It features adaptive Jetpack Compose UIs across phones, tablets, foldables, and Android XR with shared element transitions. A companion Wear OS app enables one-tap installation of the generated avatar as a watch face, including APK creation and transfer via the Wearable Data Layer. The architecture is multi-module with custom Gradle plugins, Hilt DI, and feature flags via Firebase Remote Config. It is primarily an applied AI sample app, not a data research project, though it heavily relies on configurable AI prompts and model names.
BatteryRecorder is an Android application for precise battery power recording and battery life prediction. It consists of a main app module with Jetpack Compose UI and a native server daemon that reads battery data directly from sysfs and dumpsys via JNI. The architecture follows a multi-module structure (app, server, shared) with AIDL-based IPC between the app and the privileged background server. The app provides real-time monitoring, historical charts, per-app and per-scenario battery endurance predictions, calibration settings, and export/import capabilities. It is a sophisticated tool aimed at power users and developers, but it relies on device-specific sysfs paths and hidden Android APIs, making it fragile across different devices and Android versions. The codebase demonstrates solid use of modern Android patterns (ViewModel, StateFlow, UseCase, Repository) and custom Compose components, though it lacks automated tests and has mixed-language documentation.
An Android audio recording and playback application with two coexisting architectures: a legacy Java MVP system (V1) and a modern Kotlin Compose MVVM system (V2). The app supports recording in M4A/AAC, WAV, and 3GP formats with configurable sample rate, bitrate, channel count, and audio source. It features waveform visualization during recording and playback, file management (rename, bookmark, trash, import/export), broken-record recovery, and a customizable name-format builder. The V2 codebase uses Jetpack Compose, Hilt dependency injection, Room database, ExoPlayer, and coroutines, while V1 uses Android Views, SQLite, and manual DI. The dual-codebase design adds complexity and maintenance risk, but the V2 components are well-architected with a clean unidirectional data flow and reusable patterns for media handling and UI state management. The project has extensive localization (18 locales), fastlane metadata for Play Store, and a custom home-screen widget.
This is a privacy-focused Android application for scanning and generating QR codes and barcodes, developed by the SECUSO research group (Security, Usability, Society) at TU Darmstadt. The app uses the device camera to decode codes, supports image picker scanning, and provides a QR code generator for various content types (URL, text, email, phone, SMS, WiFi, vCard, MeCard, BizCard, geo-location, product, calendar, etc.). It emphasizes minimal permissions (only camera, no internet required for scanning) and includes phishing protection by highlighting domains and requiring user confirmation before opening links. The architecture follows standard Android patterns: Activities with ViewModel + LiveData, Room database for scan history, Repository pattern, and a navigation drawer for main sections (Scanner, Generator, History, Settings, Help, About). The codebase is a mix of Java and Kotlin, uses AndroidX, Material Design, ZXing for barcode decoding, and Glide for image loading. It also integrates a backup service via a git submodule (privacy-friendly-backup-api). The app is part of the Privacy Friendly Apps suite and is licensed under GPLv3.
This repository is a Chinese-language translation and expansion of the Learn wgpu tutorial series, teaching the wgpu Rust implementation of the WebGPU graphics API through a Cargo workspace of ~25 runnable example crates. The curriculum progresses from window/surface setup (tutorial1-2), render pipelines and buffers (tutorial3-4), textures/uniforms/instancing/depth (tutorial5-8), through OBJ model loading, Blinn-Phong lighting, normal mapping, camera control, compute-shader terrain generation, HDR rendering, and particle systems. Each example is a small but complete winit application that runs natively and as WebAssembly via wasm-bindgen, sharing a common utils crate that provides the WgpuAppAction lifecycle trait, node-based render abstractions (ViewNode, ComputeNode, BufferlessFullscreenNode), and buffer/bind-group helpers. A VitePress documentation site embeds live WASM demos of the examples, and showcase crates demonstrate a Pong game, offscreen GIF encoding, multithreaded model loading, and compute-shader tangent generation. Although primarily a tutorial codebase, it is genuinely hybrid: it doubles as a deployable documentation site and a reference implementation of modern wgpu patterns.
This is an Android application named 'Parcel - Pickup Code' that automatically parses incoming SMS text messages to extract parcel pickup codes and delivery addresses. The app displays the extracted information on home screen widgets (available in multiple sizes) and provides a rich UI built with Jetpack Compose. Core features include: automatic SMS parsing with configurable custom regex rules, support for monitoring third‑party app notifications (WeChat, Pinduoduo, TikTok, Xiaohongshu) to capture pickup codes, address grouping with labels, senior mode with enlarged text, dark theme, and persistent data storage via SharedPreferences. The architecture follows standard Android patterns: a main activity orchestrates permissions and data refresh, a ViewModel manages state, a dedicated SMS parser processes messages, and background services (NotificationListenerService, periodic health checks) keep widgets updated. The app is deliberately offline and does not collect personal data.
Material Files is a sophisticated, open-source Android file manager built with Kotlin and Material Design principles. Its core architecture is a custom implementation of the Java NIO2 file system API (`java.nio.file.spi.FileSystemProvider`), providing a unified abstraction over multiple backends: the local Linux filesystem (accessed via JNI syscalls), Android's proprietary Documents/Content providers, and remote network protocols including SMB, SFTP, FTP, and WebDAV. The UI is constructed from Android Fragments, RecyclerView adapters, and custom Material Design widgets, orchestrated by a ViewModel/LiveData pattern for reactive state management. The application goes far beyond basic file browsing. It features a comprehensive background file job service for copy, move, delete, and archive operations with progress tracking and conflict resolution. It includes a built-in FTP server, an image viewer with EXIF support, a text editor, and deep file property inspection (APK metadata, audio/video tags, checksums, POSIX permissions, and SELinux context). Root access is achieved through a separate process communicated via AIDL (Android Interface Definition Language), demonstrating a sophisticated IPC architecture for privilege escalation. The codebase is actively maintained by a single developer, with recent commits and a clear version history. However, it suffers from high technical drift due to its heavy reliance on Android's internal, undocumented, and frequently changing APIs (e.g., `android.system`, `android.os.storage`). The extensive `compat` package is a testament to the constant battle against platform evolution. This makes the project fragile and high-risk for long-term maintenance without dedicated effort. Despite its overall complexity, the repository contains several genuinely reusable, high-craftsmanship components. Standouts include the `ByteString`/`ByteStringPath` classes for handling non-UTF-8 filesystem paths, a generic `ListDiffer` algorithm, a robust `Stateful`/`DataState` state machine pattern, and clean implementations of throttling/debouncing. These components are self-contained and could be extracted for use in other Kotlin or Java projects. The overall quality score is 7.5, reflecting strong engineering and feature depth, balanced against significant platform-specific technical debt.
Litube is an advanced Android WebView wrapper for YouTube, providing ad-free playback, native video/audio downloading, background play, Picture-in-Picture (PiP), SponsorBlock integration, and a customizable extension system. It uses a hybrid architecture where YouTube's mobile site is rendered in a WebView via `YoutubeFragment`, while video playback is handled natively using AndroidX Media3 (ExoPlayer) with custom `YoutubeHttpDataSource` for streaming. The app includes a full-featured download manager (multi-threaded chunked downloads, audio/video merging with MP4Parser), a queue system, a mini-player, and gesture controls. It reverse-engineers YouTube's streaming protocols using the NewPipe Extractor and generates PoTokens through a WebView-based mechanism to bypass bot detection. The application is structured as a single-module Gradle project with Dagger Hilt for dependency injection, MMKV for key-value storage, and Gson for serialization. It has extensive JavaScript injection (`init.js`) to manipulate the YouTube DOM for features like hiding Shorts, displaying dislikes, and injecting a custom settings page. While primarily an application, it includes data extraction components (stream catalog, delivery analysis) that could be considered a research layer for understanding YouTube's streaming infrastructure.
This is a cross-platform Flutter application that serves as an unofficial client for the Pixiv illustration and novel platform. It provides a full-featured browsing experience including OAuth login, search, ranking, bookmarks, following, recommendations, comments, and a download manager with offline viewing. The architecture follows a standard Flutter app structure with custom state management (StateController), a centralized network layer using Dio to interact with Pixiv's private API, and local SQLite storage for caching images, download history, and settings. The UI is built with Fluent UI for a desktop-native look on Windows, macOS, and Linux, with platform-specific adaptations for Android and iOS. The codebase demonstrates moderate craftsmanship with reusable components like a generic cache manager, custom image provider with retry logic, and utility classes for debouncing and periodic tasks. However, it has some maintenance risks including hardcoded API credentials, reliance on undocumented Pixiv API endpoints, and a few code quality issues such as fall-through bugs in keyboard handling and non-localized strings.
MTG Familiar is a mature, open-source Android companion app for Magic: The Gathering. It provides a comprehensive suite of offline-capable tools including card search with advanced filtering, life counter with commander damage and poison tracking, mana pool, dice roller, trade and wishlist management, round timer, comprehensive rules browser, judge documents (MTR, IPG, JAR), deck builder with import/export and statistics, and the MoJhoSto random card generator. The app is built as a single-module Android project using AndroidX, with a local SQLite database for card data (updated via JSON patches from a GitHub repository), TCGPlayer API integration for market prices, and Glide for card image loading. The architecture follows standard Android patterns: a main Activity (FamiliarActivity) manages a navigation drawer and fragment transactions, with each tool implemented as a Fragment. Data access is centralized through CardDbAdapter and DatabaseManager, with custom Views for mana symbols, color pie, and token-based input. The codebase is well-organized but shows signs of age with deprecated API usage (AsyncTask, PreferenceFragment) and some large, tightly-coupled fragments. It is actively maintained (last commit 2026-06-04) with regular database updates and community contributions.
The AN2Linux Client is an Android application designed to forward device notifications to a Linux desktop companion server over secure TLS connections. It intercepts notifications via Android's NotificationListenerService, applies user-configured filters (per-app and global), and transmits notification data to configured servers (Wi-Fi, mobile, or Bluetooth) using certificate-based authentication. The architecture combines Android components (Activities, Services, BroadcastReceivers) with modern patterns like ViewModels/LiveData for UI state management, custom preferences for advanced settings, and isolated cryptographic helpers for TLS operations. Key features include foreground service execution to bypass background restrictions, boot-time auto-start, granular notification filtering, and support for multiple connection types with SSID whitelisting for Wi-Fi.
Nearby Glasses is a cross-platform mobile application (native Android in Kotlin and iOS in Swift/SwiftUI) that continuously scans Bluetooth Low Energy (BLE) advertisements to alert users when smart glasses from known manufacturers (Meta, EssilorLuxottica, Snap, Zhuhai Jieli) are nearby. Detection is based on immutable BLE company IDs and device-name substrings, with configurable RSSI threshold and notification cooldown. The Android app runs a foreground service for background scanning; the iOS app currently scans only in the foreground and offers a 'Canary Mode' visual indicator instead of system notifications. The app is privacy-focused: no telemetry, no ads, local-only logs with user-initiated export.