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.
NodeNetwork is a .NET C# WPF library that provides a fully interactive node graph editor component, following the Model-View-ViewModel (MVVM) pattern with ReactiveUI and DynamicData for reactive data flows. The core library (NodeNetwork) offers view models and custom WPF controls for managing networks of nodes, connections, endpoints, port rendering, pan/zoom, and validation. The NodeNetworkToolkit extends this with higher-level abstractions including typed value nodes, node grouping into sub‑networks, a searchable context menu, breadcrumb navigation, and a force‑directed layout engine for automatic graph arrangement. Three example applications demonstrate practical usage: a simple arithmetic calculator, a Lua code generator, and a GLSL shader editor with a 3D OpenGL preview. The architecture is modular: the core library is decoupled from the toolkit and examples via view registration (NNViewRegistrar) and dependency injection via Splat. All viewmodels are ReactiveObjects, and views implement IViewFor<T>, allowing clean separation and testability. The repository is well‑tested with unit tests covering network validation, value propagation, and UI interactions. Despite its solid design, the codebase shows signs of technical drift: it targets .NET Framework 4.7.2 and .NET Core 3.1 (not the latest .NET), uses the deprecated OpenTK library for the shader editor, and has inconsistent NuGet reference formats (packages.config vs. project‑file references). Some view logic remains in code‑behind files, and nullable reference types are not enabled. The library is nonetheless actively maintained (last commit April 2026) and has a strong user base (962 stars). It is not a data research repository; it is a UI library with example applications.
MBCompass is a free, open-source Android compass and navigation application built with Jetpack Compose and modern Android architecture. It provides a digital compass with true/magnetic north support, declination correction, and sensor fusion for accuracy. The app integrates online and offline maps (via OSMDroid and MapsForge), GPS location tracking, and full track recording capabilities including start/pause/resume, GPX export/import, and detailed statistics (distance, speed, elevation, ascent/descent). The UI follows Material Design 3 with support for dynamic theming, AMOLED dark mode, and multiple languages. The architecture follows a feature-based package structure with MVVM pattern, using Hilt for dependency injection, DataStore for user preferences, and Kotlin Serialization for track persistence. Key modules include a foreground service for GPS tracking, a sensor event listener with lifecycle-aware registration, and a repository pattern for track CRUD operations. The app is lightweight (~2 MB), privacy-focused (no ads, no analytics), and supports Android 6+ with target SDK 33+. While the codebase demonstrates solid engineering practices with clean abstractions and reusable UI components, there are signs of technical drift including deprecated LocationListener APIs, scoped storage concerns, and potential library version lag. The project appears actively maintained with recent changelogs, extensive translations, and community engagement via Weblate and GitHub issues.
Hearthstone Deck Tracker is a Windows desktop companion application for the digital card game Hearthstone. It reads the game's log files and memory (via HearthMirror) to reconstruct real-time game state, providing an in-game overlay that displays the player's deck, opponent's known cards, draw probabilities, card generation predictions, and various counters for in-game effects. It also offers deck management (import/export, editing, versioning), match history and statistics, and integration with HSReplay.net for cloud sync, replays, and premium features like mulligan guides and arena drafting assistance. The application follows a custom MVVM (Model-View-ViewModel) architecture using .NET Framework and XAML for the UI. The core game state engine is driven by log watchers and handlers that parse Hearthstone's power log, while memory reading provides additional data like the player's collection and current deck. The overlay system consists of multiple transparent windows that can be configured per game mode (Constructed, Arena, Battlegrounds, Mercenaries). A plugin system allows third-party extensions, and an auto-updater (Squirrel) handles distribution. Key entry points include the main application window (App.xaml.cs), the log watcher manager (LogWatcherManager), the scene handler that transitions between game modes, and the various overlay view models. Data flows from log files and memory into a shared game state object, which is then consumed by counters, effect trackers, and UI components. External dependencies include HearthDb (card database), HearthMirror (memory reading library), HSReplay.net APIs, and the Hearthstone game client itself. The codebase is large and actively maintained, with frequent updates to support new Hearthstone expansions and game modes. However, it carries significant technical debt: heavy use of hardcoded card IDs, brittle regex-based log parsing, a custom UI framework that diverges from standard .NET patterns, and deep coupling to game-specific mechanics. While functional and feature-rich, the architecture shows signs of organic growth rather than deliberate design, making isolated reuse of components challenging without adaptation.
Repository is a production Android application for Mixin Network, combining a cryptocurrency wallet with a messenger. It integrates with Mixin API (api.mixin.one) and Blaze messaging, supports transfers, swaps, web3 trades, perps, fiat money, and market analytics. The app is built with Kotlin, uses MVVM with ViewModels and Flows, Room for persistence, and a mix of Jetpack Compose and legacy View-based UI. A separate query-codegen Gradle module generates type-safe query code, and release automation includes Fastlane, Docker build box, and APK signature verification.
Watt Toolkit (Steam++) is a cross-platform desktop application that serves as a multi-functional game toolbox primarily for Steam users. The system provides network acceleration via a local reverse proxy (YARP-based) with HTTPS interception, DNS analysis, and multiple proxy modes (Hosts, System, PAC, VPN, DNS intercept). It includes plugins for Steam account switching, two-factor authenticator management (import/export/recovery), game library management, ArchiSteamFarm integration for card farming, and game tools. The architecture is a modular plugin system built with Avalonia UI, .NET, and ReactiveUI, using a multi-process IPC model for privilege separation. External dependencies include WinDivert for Windows packet interception, XunYou SDK for game acceleration, and ArchiSteamFarm for automated Steam actions. The codebase demonstrates a complex but functional architecture with significant platform-specific code and some areas of technical debt.
This repository contains a cross-platform mobile application (iOS and Android) that functions as an AI assistant for Ray-Ban Meta smart glasses. The app connects to the glasses via the Meta Wearables DAT SDK to access camera and microphone streams, then provides various AI-powered features including real-time conversations (Live AI), image recognition (Quick Vision), food nutrition analysis (LeanEat), real-time translation, and experimental RTMP streaming. The architecture follows MVVM patterns on both platforms, with SwiftUI/Jetpack Compose for UI, ViewModels for state management, and service layers handling API communications with multiple AI providers (Alibaba Cloud, Google Gemini, OpenRouter). Key features include secure API key storage, Bluetooth audio routing for glasses microphones, and integration with external systems like OpenClaw. The application is actively maintained with recent commits and demonstrates solid engineering practices, though the multi-platform nature and reliance on external AI services introduce some complexity.
This repository is a comprehensive collection of iOS interview questions and answers (both Objective-C and Swift), accompanied by numerous standalone demo Xcode projects that illustrate specific concepts, architectures, and coding patterns. The dominant character is application because most demos are runnable iOS apps (MVVM, Redux, SwiftUI, Core Data, etc.), but the repo is hybrid as its primary purpose is educational reference rather than a single production system. The codebase is fragmented across many independent projects with varying quality, some using older toolchains. Key reusable assets include a protocol-oriented networking package, an async image caching component, an observable binding helper, a mock URL protocol for tests, and Clean Swift Xcode templates.
This is an Android application designed as a learning resource for Kotlin Coroutines. It provides a series of hands-on examples demonstrating common coroutine patterns in Android development, including single/parallel/series network calls with Retrofit, Room database operations, long-running tasks, timeout handling, and error handling strategies (try-catch, CoroutineExceptionHandler, supervisorScope). The architecture follows a simple MVVM pattern with ViewModel, LiveData, and a sealed UiState class. The code is straightforward and intended for educational purposes, with a clear separation of layers (API, database, UI). While it does not exhibit advanced or production-grade architecture, it serves as a practical reference for developers learning coroutines.
Diffusion Toolkit is a WPF desktop application for organizing, searching, and browsing AI-generated images. It scans folders for images, extracts generation parameters (prompt, seed, model, CFG, workflow, etc.) from multiple formats (AUTOMATIC1111, ComfyUI, NovelAI, etc.), and stores them in a SQLite database for fast metadata search, filtering, and album management. The application provides a rich thumbnail grid, preview pane, folder/album/tag navigation, and supports videos, external applications integration, and auto‑updating via GitHub releases. Although it demonstrates a depth of domain knowledge and addresses a real need for AI artists, the codebase has notable architectural anti‑patterns (global static service locator, monolithic classes, raw SQL in migrations, large XAML files), is tied to Windows/WPF with no headless component, and uses a forked version of sqlite‑net. The code is actively maintained with frequent commits, but its reusability is limited by tight coupling and lack of an inversion of control container.
This repository contains a Windows 10 UWP application for Kanban-style task management, accompanied by an ASP.NET Core Web API for remote data storage. The application follows the MVVM pattern with dependency injection via Autofac, supporting multiple database backends (SQLite, MySQL, MSSQL, WebAPI) through an adapter architecture. Features include drag-and-drop task organization, due dates, reminders, OneDrive synchronization via Microsoft Graph, and a compact overlay mode. The project is explicitly marked as unmaintained in the README, with ongoing work on a WinUI3 .NET10 replacement.