RustNet is a cross-platform, real-time network monitoring terminal UI application. It captures packets via libpcap (or platform-specific backends like PKTAP on macOS, ETW on Windows), performs deep packet inspection (DPI) for protocols including HTTP, HTTPS, DNS, SSH, QUIC, BitTorrent, and many others, and attributes each connection to the owning OS process using eBPF (Linux), lsof (macOS), IP Helper (Windows), or sockstat (FreeBSD). The architecture is a multi-crate Rust workspace: `rustnet-core` provides connection tracking, DPI analyzers, GeoIP/OUI lookup, and rate/RTT tracking; `rustnet-capture` wraps libpcap; `rustnet-host` implements process lookup via a unified `ProcessLookup` trait; `rustnet-sandbox` handles privilege dropping and sandboxing (Landlock, Seatbelt, Windows job objects). The main binary (`rustnet-monitor`) orchestrates capture, enrichment, and a ratatui-based TUI with tabs for Overview, Details, Activity, Graph, and Host. It supports PCAP/PCAPNG export with process metadata, JSONL event logging, Kubernetes pod attribution, and a rich theme system with multiple presets. The codebase is well-structured, extensively tested, and actively maintained with CI/CD for multiple platforms and packaging (DEB, RPM, DMG, MSI, Homebrew, Chocolatey).
This is a mature, cross-platform React Native bottom sheet library (`@lodev09/react-native-true-sheet`) that provides native-feeling sheets on iOS (UISheetPresentationController), Android (BottomSheetBehavior + CoordinatorLayout), and Web (forked Vaul drawer). It is built exclusively for React Native's New Architecture (Fabric) with shared C++ shadow nodes for synchronous per-detent layout. The library offers an imperative API via refs and a global static method registry, plus optional integrations with React Navigation (custom stack router and sheet navigator), Expo Router (Sheet layout), and Reanimated (worklet-driven position tracking). Key features include automatic detent sizing, peek detents, header/footer overlays, keyboard avoidance, stacked sheets, dimming, and a portal-based overlay for toasts/dialogs. The codebase demonstrates high craftsmanship with clean native delegates, extensive event handling, and thorough test mocks. It is actively maintained with multiple example apps, CI/CD, Maestro E2E tests, and a documentation site.
HevSocks5Tunnel is a lightweight, high-performance tun2socks proxy written in C. It creates a virtual TUN interface and forwards all TCP/UDP traffic through a SOCKS5 proxy, supporting IPv4/IPv6 dual-stack, UDP-in-UDP and UDP-in-TCP relay modes, optional local ICMP echo replies, and a mapped DNS feature for transparent DNS resolution. The architecture is monolithic but modular: a YAML-based configuration parser, platform-specific tunnel backends (Linux, FreeBSD, macOS, NetBSD, Windows via Wintun), and a session management layer built on top of lwIP and the hev-task-system cooperative multitasking library. It can be used as a standalone CLI tool, a static/shared library, or embedded via JNI on Android. The codebase demonstrates strong C craftsmanship with clean abstractions, efficient I/O patterns (ring buffer with iovec, scatter/gather), and careful platform abstraction.
xmlutil is a Kotlin Multiplatform XML library that provides three layers: a streaming pull-parser/writer abstraction (XmlReader/XmlWriter with a pure-Kotlin KtXmlReader and platform StAX/Android backends), a portable DOM Level 2 implementation with JVM/JS/Native/Wasm wrappers, and an XML serialization format for kotlinx.serialization (the XML.v1 codec with annotations such as @XmlSerialName, @XmlValue, @XmlPolyChildren and policy-based configuration). It is a library, not an application: there are no servers or CLIs, only published Maven artifacts (core, serialization, xmlschema, serialutil, testutil) plus examples, benchmarks, and a Gradle plugin used for building/publishing the library itself. It targets JVM, Android (deprecated module), JS, Native, and Wasm. The architecture is strictly modular: core/base holds platform-independent streaming, DOM, namespaces, and entity handling; core/jdk and core/android are platform backends; serialization implements the kotlinx.serialization format including type/descriptor caching, polymorphic parent handling, and compact-fragment support; xmlschema is a near-complete XML Schema 1.0/1.1 parser/resolver with a custom XPath expression engine and a purpose-built regex engine for XSD pattern facets; serialization-io and core/kxio bridge kotlinx-io sinks/sources; testutil ships cross-platform XML assertion helpers. The dominant data flow is: XML text -> streaming events (XmlReader) -> DOM or direct object deserialization, and the reverse for output, with XmlSerializationPolicy controlling naming, lists, maps, namespaces, and encoding/decoding behavior. The engineering depth is genuinely high: a hand-written XSD regex engine with Unicode decomposition and surrogate set classes, flat-array namespace stacks with O(1) depth operations, DTD/entity expansion logic, an LRU format cache with recursion detection, and binary-compatibility validation (API and klib .api files) on every build. Test coverage is extensive, including regression tests for dozens of numbered GitHub issues, a W3C XML Schema test-suite harness, and JVM benchmarks. The main weaknesses are an intentionally large experimental API surface (@ExperimentalXmlUtilApi), some boilerplate near-duplication in schema facet classes, and platform-source-set sprawl that multiplies maintenance cost. Maintenance is active: recent commits (Aug 2026), GitHub Actions CI (runTests, publish-snapshot, upload_release), zero Dependabot alerts, and modern tooling (Gradle version catalog, BOM, Gradle wrapper validation). Some legacy artifacts remain (stale .travis.yml, deprecated core-android and xmlserializable modules), but they are explicitly marked deprecated rather than silently rotting. Technical drift is low; the codebase deliberately tracks fast-moving kotlinx.serialization APIs and documents Kotlin compiler workarounds, indicating a maintained rather than abandoned project.
The AdvancedSharpAdbClient is a .NET library that provides a managed implementation of the Android Debug Bridge (ADB) protocol, enabling developers to interact with Android devices without relying on the external `adb.exe` executable. It offers a comprehensive suite of features including device connection management, shell command execution, application installation and uninstallation, file transfer via ADB sync service, screen capture, and device state monitoring. The library is designed with a strong emphasis on testability and loose coupling, utilizing interfaces and a factory pattern for dependency injection. Architecturally, the library is structured as a set of cohesive, loosely coupled components. Core communication is handled by `AdbSocket` (low-level TCP) and higher-level operations are exposed through `AdbClient`, `DeviceClient`, `PackageManager`, and `SyncService`. The library makes extensive use of interfaces to allow for easy mocking in unit tests and provides asynchronous counterparts for most operations to support non-blocking programming models. It targets a wide range of .NET frameworks (from .NET Framework 3.5 to .NET 10+) using conditional compilation and polyfills to maintain compatibility. The library demonstrates solid engineering practices through its use of the factory pattern for object creation, extension methods to enhance interface usability, and careful handling of binary data structures for statistics and framebuffer headers. Its comprehensive test suite, which includes mock implementations for various components, ensures reliability and facilitates safe evolution. While the broad target range introduces some complexity via conditional compilation symbols, the code remains well-organized and maintainable, reflecting a commitment to serving a diverse set of .NET applications requiring Android device interaction.
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.
DashBeam is a peer-to-peer encrypted file transfer application that operates without a central server. Built on the Iroh networking stack (QUIC, BLAKE3, relays), it enables direct device-to-device transfers with end-to-end encryption, NAT traversal via relays, and local LAN discovery via mDNS. The application is cross-platform, targeting desktop (Windows, macOS, Linux via Tauri), Android, and web (via a Rust WASM bridge). Its architecture cleanly separates a core protocol crate (P2P wire format, pairing, identity) from platform-specific I/O crates (native disk I/O for desktop/mobile, in-memory for web), all wrapped by a unified engine facade. The frontend is a modern React/TypeScript SPA with Zustand state management, a comprehensive UI component library built on Base UI, and 20+ locale translations. The system supports one-time share tickets, permanent device pairing, broadcast mode, transfer progress with resume, and self-hosted infrastructure. No telemetry or accounts are required, and the AGPL-3.0 license ensures openness.
TEESimulator is a system-level Android root tool that intercepts and replaces hardware-backed key attestation for selected apps. It injects native libraries into the keystore daemon (keystore2 on Android 12+, keystore on 10/11) via ptrace, hooks Binder transactions, and routes KeyMint requests to an in-process Rust TA that implements AOSP's kmr-ta with BoringSSL. A Kotlin daemon runs as root, manages profiles (keybox, mode, device identity, patch levels), harvests real device parameters, and provides a WebUI for configuration. The system supports two modes: patch (re-sign real attestation leaf) and generation (mint keys entirely in software). It is designed for Android 10-17, requires root, and is distributed as a Magisk/KernelSU/APatch module. The architecture is a multi-process, multi-language system: a Kotlin control daemon (app_process), native C++ interceptors (keymint, keystore), a Rust TA (teesim-km), and a JavaScript WebUI. Communication between daemon and interceptors uses a custom JSON-based protocol over Unix domain sockets. The daemon harvests real device attestation parameters, resolves per-app profiles, and pushes configuration to the interceptors. The interceptors use PLT hooks (AIBinder_transact, ioctl) to redirect KeyMint/Keystore calls for target apps to the local TA, while forwarding non-target calls to the real hardware. The codebase demonstrates high craftsmanship in its handling of Android internals, with careful version branching, RAII wrappers for ptrace, safe file I/O via base64 heredoc, and a schema-driven WebUI. However, it is heavily dependent on Android API internals and may require updates with each major Android release. The project is actively maintained with recent commits and responsive issue triage.
This repository is a high-performance React Native library (llama.rn) that enables on-device Large Language Model (LLM) inference on iOS and Android devices. It wraps the C++ llama.cpp core using JavaScript Interface (JSI) and TurboModules, allowing mobile applications to run GGUF-formatted models locally without cloud dependencies. The architecture consists of a TypeScript/JavaScript layer for the React Native interface, a C++ core for inference and model loading, and native modules for Android (Java/Kotlin) and iOS (Objective-C++). Key capabilities include hardware acceleration via Apple Metal and Qualcomm Hexagon DSP, multimodal support (vision/audio), parallel decoding, and structured output generation. The project includes a comprehensive example app demonstrating chat interfaces, model management, and benchmarking tools.
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.
react-native-haptic-feedback is a React Native library providing comprehensive haptic feedback capabilities for iOS and Android. It implements a dual-tier fallback chain on both platforms: iOS uses Core Haptics (CHHapticEngine) with UIKit generator fallback, while Android uses View.performHapticFeedback constants and VibrationEffect API. The library offers both simple trigger methods and complex pattern-based haptic sequences, includes cross-platform AHAP file playback with Android fallbacks, and provides React-first APIs like the useHaptics hook and TouchableHaptic component. Architecture features platform-specific native modules bridged via React Native's TurboModule system, with TypeScript source and auto-linking support.
This repository contains a single Kotlin script, `deep-clean.main.kts`, which is a command-line tool for cleaning build caches and temporary files in Gradle and Android projects. The script provides options to clean local project directories (like 'build' and '.gradle'), remove IDE project files, and optionally clear global caches (Gradle, Maven, IDE settings) when the '--nuke' flag is used. It also kills related processes such as the Gradle daemon and ADB server. The script is built using the Clikt library for command-line argument parsing and features a set of well-designed helper functions for safe file operations (including dry-run, backup, and verbose modes). These helper functions, particularly the extension functions on File and Sequence<File> for deletion and backup, are well-crafted and could be reused in other projects with minimal modification.
Suwayomi-JUI is a multiplatform manga reader application built with Kotlin Multiplatform, targeting Android, Desktop, and iOS. It functions as a client for the Suwayomi-Server backend, communicating via GraphQL (Apollo) and REST (Ktor) to manage a personal manga library, download content for offline reading, and provide a customizable reading experience. The architecture follows a clean layered structure: core utilities, data layer (repositories and network clients), domain layer (business logic and use cases), and presentation layer (UI with Jetpack Compose/SwiftUI). Key features include library management with categorization, extension/plugin support, download queue management, reading interface with various navigation modes, backup/restore functionality, and comprehensive settings. The application employs dependency injection via custom annotations, reactive programming with Kotlin Flows and coroutines, and a cross-platform preference storage system. It is actively maintained with recent commits and demonstrates strong engineering practices in modularity and platform abstraction.
Kazumi is a cross-platform Flutter application for browsing, collecting, and streaming anime (番剧). At its core, it provides a curated media experience: users can discover anime via popularity rankings, weekly schedules, text and image (trace.moe) search; manage a local watchlist synced with Bangumi (bgm.tv) and WebDAV; and play videos using a hardware-accelerated media_kit (libmpv) player with danmaku overlay, Anime4K super-resolution shaders, Picture-in-Picture, and external player support. It also downloads episodes (HLS segments) for offline playback and supports synchronized group viewing via the Syncplay protocol. The application is built as a Flutter monolith with modular routing (flutter_modular), reactive state management (MobX), local storage (Hive), and a custom plugin system that defines scraping rules (XPath/API) to extract video sources from third-party websites. External dependencies include Bangumi, DanDanPlay, trace.moe, WebDAV servers, and a GitHub-hosted plugin catalog. The codebase demonstrates mature engineering practices including well-isolated async utilities, event-sourced history sync with conflict resolution, and platform-specific WebView integrations for video source extraction and captcha handling.
Fyne is a cross-platform GUI toolkit for the Go programming language, designed to build native desktop, mobile, and web applications from a single codebase. The repository contains the core framework including window management, event handling, a rich set of widgets (button, label, entry, list, table, tree, etc.), canvas primitives (lines, rectangles, arcs, text), layout managers, data binding, theming, storage abstraction, and platform-specific drivers (GLFW for desktop, mobile for Android/iOS, WebAssembly, and an embedded/no-OS driver). It also provides a command-line tool (`cmd/fyne`) for packaging, bundling resources, and releasing applications. The architecture is modular with clear interfaces (`fyne.App`, `fyne.Window`, `fyne.Widget`, `fyne.Canvas`) and extensive use of build tags for platform adaptation. The codebase is production-grade, well-tested with both unit and visual regression tests, and actively maintained by the Fyne community.
This is the official Bitwarden password manager for Android, a production-grade Kotlin application with a modular monorepo structure. It implements a full-featured password manager including vault management (ciphers, folders, collections, sends), autofill (standard and accessibility-based), FIDO2/WebAuthn passkey support, TOTP authenticator, password/username generator, secure credential exchange (CXF), and enterprise features like SSO, Duo, and policy enforcement. The architecture follows an MVVM pattern with Jetpack Compose UI, Dagger/Hilt dependency injection, Room SQLite for local persistence, Retrofit/OkHttp for networking, and the Bitwarden SDK for cryptographic operations. The codebase is organized into multiple Gradle modules: `app` (main app), `authenticator` (standalone TOTP app), `authenticatorbridge` (AIDL-based cross-app communication), `network` (API client), `data` (data sources and repositories), `ui` (reusable Compose components), `core` (platform utilities), `cxf` (credential exchange), and `testharness` (Credential Manager API testing). Key entry points include `MainActivity`, `CredentialProviderActivity`, `AuthCallbackActivity`, and `BitwardenApplication`. Data flows involve syncing vault data from Bitwarden servers to local Room databases, processing autofill requests from other apps via Android's Autofill and Credential Manager frameworks, and securely sharing TOTP secrets between the main app and authenticator app via the encrypted bridge. External dependencies include the Bitwarden SDK, AndroidX libraries (Compose, Navigation, Room, Biometrics, Credentials, etc.), Retrofit, OkHttp, kotlinx.serialization, and optional Firebase for push notifications and crash reporting.
Kvaesitso is a production-grade, search-focused Android launcher and home-screen replacement. The app aggregates local and cloud content - apps, contacts, calendar events, files, locations, websites, Wikipedia articles, calculator results, and unit conversions - through a unified `SearchService`, then presents results in a Jetpack Compose UI with configurable widgets, themes, gestures, and plugin-backed data sources. It ships a ContentProvider-based plugin SDK that lets third-party packages extend search, weather, calendar, contact, file, and location providers. Cloud integration includes Nextcloud/ownCloud file search, multiple weather providers (Met.no, BrightSky, OpenWeatherMap), OpenStreetMap/Overpass location lookup, and a Material You-style color engine for theming. Architecturally this is a large modular monorepo with 40+ Gradle modules layered into `app`, `core`, `data`, `services`, `libs`, and `plugins`. Dependencies are wired with Koin; persistence uses Room with 30+ schema versions and hand-written migrations plus DataStore; concurrency is Kotlin coroutines and Flow; the UI is Compose/Material3. Primary entry points are `LauncherActivity`, `AssistantActivity`, the settings activities, and the plugin SDK. The codebase demonstrates strong separation of concerns, repository-per-domain organization, and a substantial library of custom Compose components for settings, bottom sheets, drag-and-drop, widgets, and animations. Despite active maintenance and nightly CI, drift signals exist: reflection into hidden `StatusBarManager` for global actions, many deprecated compatibility fields and migrations, hardcoded web/feed blocklists, and several external API integrations that can change without notice. The strongest, most reusable pieces are isolated algorithms and parsers: fzf-style fuzzy matching, OSM opening-hours parsing, searchable string normalization, and map tile rendering. These are genuinely extractable and would transfer cleanly to other search or geodata projects.
react-native-config is a native module library that exposes environment variables from a .env file to React Native applications on iOS, Android, macOS, and Windows. At build time, platform-specific scripts (Ruby for iOS/macOS, Gradle for Android, Node.js for Windows) parse the .env file and inject the key-value pairs as generated constants — BuildConfig fields on Android, a #define'd NSDictionary on iOS, and C++ string constants on Windows. At runtime, a single JavaScript entry point (index.js) calls a synchronous TurboModule method (getConfig()) to retrieve the config object, which is then exported as the default 'Config' constant. The library supports per-environment configurations via ENVFILE or per-build-configuration settings, and includes thorough diagnostics: if the .env file is missing or empty, the runtime logs a detailed message naming exactly which paths were tried. The codebase is well-structured across all four platforms, with a strong test suite for the iOS codegen scripts (Ruby Minitest) and a clean separation between build-time codegen and runtime reading.
The repository implements Trime, a fully functional Android input method (IME) based on the Rime input engine. It provides a highly customizable keyboard with YAML-based themes, color schemes, key layouts, and gesture support. The core architecture is a Kotlin/JNI bridge to the native librime library, with a service-based IME lifecycle (`TrimeInputMethodService`), a daemon for Rime session management, and a rich UI layer for candidate display, clipboard, popups, and liquid keyboards. The application also includes a settings interface for schema management, user dictionaries, sync via Storage Access Framework, and clipboard history. The codebase is modular, with clear separation between Rime interaction, theme management, UI delegates, and data persistence, using modern Android patterns (Room, Paging, WorkManager, Coroutines, Kodein DI). It is actively maintained with frequent commits and extensive test coverage for core components. The YAML theme system is particularly sophisticated, featuring typed color resolution with fallback chains and a custom parser that handles anchors and aliases.
DexKit is a high-performance C++ library for runtime parsing and querying of Android DEX bytecode, primarily used by Xposed module developers to locate obfuscated classes, methods, and fields. It provides a rich DSL in Kotlin/Java for constructing structural queries based on annotations, opcodes, string usage, field/method references, and more. The core engine parses DEX files from APK archives, builds in-memory indexes, and uses algorithms like Aho-Corasick for substring matching and the Hungarian algorithm for unordered set matching. Communication between the native C++ layer and JVM is handled via FlatBuffers serialization. The library also includes an optional caching layer (`DexKitCacheBridge`) for persisting query results across app restarts. It is distributed as an Android AAR via Maven Central and includes a demo app and unit tests.