The Taxi repository implements a comprehensive language workbench for the Taxi DSL (Domain Specific Language) used to define data models, service contracts, and API interfaces with semantic meaning. It features a polyglot architecture with JVM-based compiler, type system, and language server, alongside TypeScript/JavaScript client tools and documentation. The system provides code generation for multiple targets (Java, Kotlin, TypeScript, OpenAPI, Protobuf, etc.), IDE integration via LSP, a CLI for project management, and a query language (TaxiQL). Key strengths include a sophisticated structural type system, expression compilation with intelligent caching and error handling, reactive LSP architecture preventing excessive recompilation, and a clean plugin system for extensibility.
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 repository is the open-source 'Rainbow Brackets Lite' IntelliJ IDEA plugin, a free and feature-limited version of the popular Rainbow Brackets plugin. The plugin colorizes nested brackets (round, square, squiggly, angle) with distinct colors to improve code readability, and provides additional features like rainbow indent guide lines and scope highlighting via mouse shortcuts. It is implemented as a JetBrains plugin using the IntelliJ Platform SDK, with core logic split between an Annotator (for simple leaf-elements) and a HighlightVisitor (for more accurate per-language matching via BracePairProvider extension points). The architecture follows standard IntelliJ plugin patterns: extension points for brace providers, custom text attributes, and a thorough settings UI integrated into the IDE's color scheme page. The codebase is well-structured with proper separation of concerns, utility functions (memoization, color blending), and comprehensive tests for multiple languages. While tightly coupled to the IntelliJ API, several components (BracePairProvider interface, memoization utility, color blending) demonstrate non-obvious skill and could be extracted for reuse in other JetBrains plugins or JVM projects.
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.
This is a monolithic Spring Boot web application built with Kotlin that implements a blog engine. The application serves both HTML pages via Mustache templates and provides a REST API for articles and users. It uses Spring Data JDBC for data access with an H2 database, and includes sample data initialization. The architecture follows standard Spring MVC patterns with controllers handling web and API requests, repositories for data access, and configuration properties for externalized settings. The code demonstrates idiomatic Kotlin usage with extension functions, data classes, and proper null safety.
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.
SmsForwarder is an Android application written in Kotlin that monitors SMS messages, incoming calls, and app notifications on a device and forwards them to multiple third-party channels such as DingTalk, WeChat Work, Feishu, Telegram, email, Bark, Webhook, and others. It also provides a local HTTP server for remote control (query/send SMS, call logs, contacts, battery status, location, and Wake-on-LAN) and an automation engine with configurable conditions (cron, battery, network, Bluetooth, location, screen state, etc.) and actions (forward, send SMS, trigger alarm, control frpc tunnels, etc.). The architecture follows a standard Android pattern with Room database, WorkManager for background tasks, XUI for UI components, and a fragment-based navigation system. The codebase is large and feature-rich, with over 15 sender channels and a flexible rule engine, but exhibits some technical debt such as deprecated API usage, hardcoded vendor-specific intents, and a few large monolithic fragments.
ObjectBox Java is an open-source, embedded NoSQL database library for Java and Kotlin, targeting Android, JVM, and desktop platforms. It provides a high-performance, native-backed object persistence engine with type-safe querying, reactive data observation, object relations (ToMany/ToOne), vector search via HNSW indexes, and optional client-server or mesh peer-to-peer synchronization. The code is organized into multiple Gradle modules including a core `objectbox-java` module with JNI bindings, an annotation API (`objectbox-java-api`), Kotlin extensions, RxJava 2/3 adapters, Android-specific integrations (LiveData, Admin web UI, Paging DataSource), and a mesh sync module using Google Nearby Connections. The architecture is library-centric with a clear separation between Java-facing API, internal serialization (vendored FlatBuffers), and native runtime. Extensive unit and integration tests cover core CRUD, transactions, queries, relations, sync, and error handling. The repository is actively maintained with a version 6.0.0-beta, publishes to Maven Central, and uses multi-platform CI (GitLab, Jenkins). While the codebase includes some legacy APIs and generated FlatBuffers code, the core abstractions exhibit solid software engineering practices with reusable patterns for reactive subscriptions, property converters, and cross-platform native library loading.
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.
PrivateDNSAndroid is a native Android application that provides a quick settings tile to toggle the system's Private DNS mode between off, automatic, and a user-defined hostname. It allows users to manage a list of DNS servers (add, edit, delete, reorder) stored in a Room database, and cycle through them via the tile or shortcuts. The app requires the WRITE_SECURE_SETTINGS permission, which can be granted via Shizuku or ADB. The architecture follows standard Android patterns: Activities, Services (TileService, ShortcutService), ViewModel, Repository, and Room DAO. The UI uses both traditional XML layouts and Jetpack Compose for dialogs. The codebase is well-structured, uses modern libraries (Kotlin Coroutines, Room, Compose, Material 3), and includes features like settings export/import and multi-language support. It is a focused, single-purpose utility app with clean separation of concerns.
AppUpdater is a multi-module Android library that provides in-app update functionality: it checks a remote version, downloads the APK, shows progress via notification or dialog, and installs the APK across Android versions. The core `app-updater` module contains the update orchestration, download/install services, notification handling, and file/checksum utilities; the `app-dialog` module provides a ready-made update dialog; the `app` module is a sample. The main entry point is the `AppUpdater` builder/facade, which accepts an `UpdateConfig` and optional custom parser/strategy implementations, so consumers can plug in their own update-info JSON schema.
This is an Android application that serves as a GUI client for XTLS/Xray-core, a proxy/VPN tool. The app provides a comprehensive interface for managing proxy profiles, subscription links, and VPN configurations. It supports both standard VPN mode (using tun2socks) and transparent proxy mode (requiring root). The architecture follows MVVM with Room database for persistence, coroutines for async operations, and a native Go library (XrayCore) for core proxy functionality. The codebase is well-structured, using modern Android development practices (Kotlin, Jetpack libraries, Material Design 3). It includes features like QR code scanning, clipboard import, link management with auto-refresh, per-app routing, and a quick settings tile. The app is actively maintained with frequent updates and a CI/CD pipeline for release builds.
The kotlin-playground repository provides a self-contained web component for embedding interactive Kotlin code editors in websites. It enables users to write, run, and see the output of Kotlin snippets directly in browser environments, supporting multiple target platforms (JVM, JavaScript, WebAssembly, Native) via communication with the Kotlin compiler service. The architecture follows a modular client-side design with clear separation between UI components (CodeMirror-based editor), execution logic, and API communication. Key features include automatic initialization via HTML attributes, configurable themes and compiler versions, extension points for custom event handlers, and iframe-based sandboxing for secure code execution. While dependent on the external kotlinlang.org compiler service, the frontend implementation demonstrates solid engineering practices with reusable patterns for API abstraction, configuration management, and platform-specific execution handling.
NoWakeLock is a production-grade Android Xposed module and companion app that provides granular control over system power management. It intercepts and selectively blocks or limits WakeLocks, Alarms, and Services at the Android framework level via Xposed hooks, enabling users to reduce battery drain. The system consists of two processes: an Xposed module running in the system_server process that performs the actual interception using both legacy (XposedBridge) and modern (libxposed API 102) APIs, and a standard Android application with a Jetpack Compose UI that allows users to configure per-app and per-item blocking rules, view real-time statistics, and manage settings. Data flows from the Xposed hooks through a ContentProvider-based IPC (XProvider) into a dual Room database architecture (AppDatabase for configuration, InfoDatabase for runtime events). The app features Material Design 3, multi-language support, backup/restore via JSON, multi-user profiles, module health diagnostics, and hot reload support for modern Xposed frameworks. The codebase demonstrates a clean MVVM architecture with Koin dependency injection, Kotlin Coroutines/Flow for reactive data flow, and comprehensive unit/instrumentation tests. While primarily a standalone application, several core concurrency utilities (BoundedEventQueue, ReloadableEventConsumer, WakelockRegistry) could be extracted and reused in other Android or system-level projects.
Grazel is a Gradle plugin that migrates Android projects from Gradle to Bazel build systems. It analyzes Gradle project configuration, extracts Android-specific information (dependencies, variants, resources, manifest), and generates equivalent Bazel BUILD and WORKSPACE files. The plugin supports incremental migration, allowing parts of a project to use Bazel while others remain on Gradle. Architecture follows Gradle plugin conventions with modular separation: core plugin implementation, extension points for configuration, dependency analysis/resolution components, Android-specific extraction logic, Bazel rule generation using a type-safe Kotlin DSL for Starlark, and task management for orchestrating the migration process. Dependency injection via Dagger/Hilt ensures loose coupling and testability.
Seal is an Android application that serves as a graphical frontend for yt-dlp, enabling users to download videos and audio from a wide range of websites. Built with Kotlin and Jetpack Compose, it features a Material Design 3 interface with dynamic color theming. The app manages download tasks through a state machine, supports playlists, custom command templates, cookies, SponsorBlock integration, and extensive format selection. It relies on yt-dlp (via youtubedl-android), FFmpeg, and aria2c as external engines, and uses Room for local database storage, MMKV for preferences, and Koin for dependency injection. The architecture is a single-activity Compose Navigation app with a foreground download service. While the codebase is well-organized and actively maintained, it exhibits some technical drift (e.g., deprecated Accompanist WebView, minimal test coverage) and contains a few monolithic modules. Notable reusable components include a standalone color science library implementing CAM16/HCT, a backup/restore utility for database objects, and a custom motion system for Material Shared Axis transitions.