The DuckDuckGo Android repository is a privacy-focused mobile browser application featuring tracker blocking, ad blocking, password management, VPN protection, and AI chat capabilities. It employs a modular architecture with feature-specific modules (app, browser, autofill, sync, privacy-*, network-protection, etc.) built using modern Android Jetpack components. The codebase utilizes Dependency Injection via Dagger/Hilt with Anvil annotations for code generation, follows MVVM patterns with ViewModels and LiveData/Flow, and implements a robust plugin system via @ContributesPluginPoint annotations for extensibility. Feature flags control gradual rollouts and A/B testing, while Room databases handle local persistence for settings, credentials, and usage statistics. The application emphasizes user privacy through encrypted storage, tracker detection networks, and transparent privacy dashboards.
Nodify is a production-grade WPF library for building node-based graph editors. It provides a comprehensive set of custom controls (NodifyEditor, ItemContainer, Connector, various connection types, Minimap, GroupingNode, StateNode, etc.) along with a sophisticated input processing system based on composable state machines. The library is designed for MVVM, exposes rich command and event hooks, and supports full theming with dark/light/Nodify themes. The codebase demonstrates high craftsmanship in its input state machine pattern (InputProcessor/InputElementStateStack), undo/redo framework (ActionsHistory), gesture customization system (EditorGestures), and performance optimizations (BoxValue, connector safe-zone hit-testing). It ships with five example applications (Calculator, Playground, Shapes, StateMachine, Workflow) that showcase real-world usage patterns including sub-workflows, real-time collaboration simulation, and undo/redo. The library targets a wide range of .NET frameworks from .NET Framework 4.7.2 through .NET 10 preview, with CI builds and NuGet publishing pipelines. Despite a large API surface and some mutable global settings, the code is well-organized, extensively documented, and actively maintained.
ReVanced Manager is an Android application that applies custom patches to Android APKs using the ReVanced Patcher engine. It provides a user interface for downloading patch bundles, selecting and configuring patches, patching applications (including a background patcher service), signing the resulting APKs, and installing them. The app is built with modern Android technologies: Jetpack Compose for UI, Room for local persistence, Koin for dependency injection, Ktor for networking, and WorkManager for background tasks. It follows an MVVM architecture with a repository pattern and supports root-based installation via Magisk modules. The application manages a complex state of patch selections, downloaded apps, installed apps, and options through a Room database with schema migrations. It includes a downloader plugin system for acquiring APK files from various sources, automatic update checks for the manager itself, patches, and downloaders, and extensive localization support via Crowdin.
This repository is the open-source iOS client for Kickstarter, a crowdfunding platform. It is a production-grade application built with Swift, UIKit, and SwiftUI, following an MVVM architecture with heavy use of ReactiveSwift and some Combine. The app supports project discovery, pledging, rewards, comments, video feeds, user settings, and authentication. The codebase is well-structured with a dedicated design system (KDS), GraphQL integration via Apollo, extensive snapshot and unit testing, and feature flag experimentation via Statsig. While the code quality is high with many reusable patterns (ValueCell, ShimmerLoading, PaginatingList), there is moderate technical drift due to the coexistence of two reactive frameworks, legacy color references, and some deprecated button styles.
San is a Baidu-developed, production-grade frontend component framework that enables building reactive UIs with a Vue/React-like model, but using custom template syntax and a standalone runtime. It provides a template parser (producing an ANode AST), a reactive data system (Data class, Proxy-based this.d), directives (s-if, s-for, s-bind, s-show, s-html, s-ref, s-transition), slots (named, scoped, dynamic), computed properties, filters, lifecycle hooks, two-way binding, and server-side rendering hydration. The library is monolithic but modularly organized, targeting browsers from IE8 upward with conditional compilation. It is actively maintained with frequent releases and extensive test coverage, but carries legacy complexity and a self-contained build toolchain (AMD module loading, custom feature blocks). The ecosystem includes companion libraries (san-router, san-store, san-cli) and TypeScript typings.
Anytype for iOS is a full-featured, offline-first knowledge management and collaboration application. It provides a block-based editor for notes, documents, and databases (sets/collections), along with chat, spaces, widgets, and membership management. The architecture follows MVVM with a coordinator pattern, heavily leveraging SwiftUI for modern UI and UIKit for legacy editor components. Communication with the backend (middleware) is via protobuf-defined commands and events, with real-time subscription-based data synchronization. Dependency injection is handled through the Factory library, and the codebase is modular with separate packages for services, design system, core utilities, and generated protobuf models. The app supports iOS 17+ and uses Swift 6 concurrency features extensively.
This is Microsoft's open-source Windows Calculator, the production calculator app shipped on Windows. The repository is a full UWP/XAML application with Standard, Scientific, Programmer, Date, Unit Converter, and Graphing modes. The core is split into `CalcManager` (a native C++ calculation engine implementing arbitrary-precision rational arithmetic via the Ratpack library), `CalcViewModel` (C++/CX view models handling history, memory, copy/paste, unit data, navigation, and state snapshots), `Calculator` (the C#/XAML UI shell), and `GraphControl` (a DirectX-based graphing control). The app is MVVM-structured, heavily localized in 25+ languages, and includes both C++ unit tests and WinAppDriver-based UI tests.
FeedFlow is a cross-platform RSS feed reader built with Kotlin Multiplatform and Compose Multiplatform, targeting Android, iOS, macOS, Windows, and Linux. It provides a rich reading experience with customizable layouts, reader mode with article extraction, offline content prefetching, and OPML/CSV import/export. The application emphasizes reliability through extensive unit testing, Maestro-based E2E tests for both mobile platforms, and a sophisticated cloud synchronization system supporting Dropbox, Google Drive, iCloud, FreshRSS, Miniflux, Feedbin, and BazQux. The architecture follows MVVM with clean separation of concerns (domain, data, presentation layers), uses Koin for dependency injection, SQLDelight for local persistence, and Ktor for networking. Platform-specific adaptations exist for background sync (Android WorkManager, iOS background tasks), widget support, and UI components (Compose Multiplatform for Android/Desktop, SwiftUI for iOS). The codebase demonstrates high craftsmanship with modular design, reusable abstractions (DataResult, content direction detection, image extraction, HTTP caching), and thorough test coverage including cloud sync conflict scenarios.
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.
GPU-T is a Linux desktop utility for comprehensive GPU information and monitoring, positioned as a GPU-Z alternative for Linux. It provides real-time sensor data (clocks, temperatures, power, fan speeds), static hardware specifications from JSON databases and sysfs, and detection of API capabilities (Vulkan, OpenCL, CUDA, etc.) through a modular probe system. The application follows the MVVM pattern with Avalonia UI and features a sidecar process for NVIDIA-specific NVAPI/NVML interactions to ensure stability and isolate native interop. Hardware detection relies on sysfs paths, external tool execution, and vendor-specific databases, with user override capabilities for hardware specifications. The modular design separates concerns into probes for hardware polling, advanced providers for feature detection, and utilities for common tasks like settings management and shell command execution.
This repository is a comprehensive XAML Behaviors library for Avalonia UI, porting the Microsoft.Xaml.Behaviors pattern to the Avalonia framework. It provides a declarative, XAML-friendly way to attach interactive logic (behaviors, triggers, actions) to UI controls without code-behind, covering common patterns such as event handling, data-driven triggers, command invocation, property changes, drag-and-drop, animations, validation, focus management, and more. The library is split into multiple NuGet packages: core interactivity (base classes), interactions (ready-to-use triggers/actions), custom interactions (control-specific behaviors), drag-and-drop, draggable elements, events, animations, responsive layout, scripting, and ReactiveUI integration. A key innovation is the use of Roslyn source generators to produce strongly-typed, reflection-free versions of actions and triggers, improving AOT compatibility and compile-time safety. The architecture follows a layered design: the foundation is the `Avalonia.Xaml.Interactivity` namespace with `Behavior`, `Trigger`, `Action` base classes and the `Interaction` static class for attaching behaviors. On top of that, `Avalonia.Xaml.Interactions.Core` provides common triggers/actions like `EventTriggerBehavior`, `InvokeCommandAction`, `ChangePropertyAction`, and `DataTriggerBehavior`. The `Custom` package adds hundreds of specialized behaviors for controls (e.g., `AutoCompleteBoxOpenDropDownOnFocusBehavior`, `SplitViewStateBehavior`, `FocusTrapBehavior`). Drag-and-drop is handled by a dedicated framework with `DropHandlerBase`, `ManagedDragDropService`, and behaviors like `PanelDragBehavior`. Animations are built using Avalonia's composition API, with helpers like `AnimationFactory` and `FluidMoveAnimation`. The source generators in `Xaml.Behaviors.SourceGenerators` produce typed wrappers from attributes like `[GenerateTypedAction]` and `[GenerateTypedTrigger]`, reducing boilerplate and runtime reflection. Key entry points for consumers are the `Interaction.Behaviors` attached property in XAML, the `Interaction.ExecuteActions` method, and the various behavior/trigger/action classes. The library depends on Avalonia UI (StyledElement, Control, Visual, TopLevel, etc.) and optionally on ReactiveUI. It includes extensive documentation via DocFX, sample applications demonstrating all features, and unit tests using Avalonia's headless testing infrastructure. The codebase is well-structured with clean abstractions, though its large surface area and reliance on internal Avalonia APIs present some maintenance risks.
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.
This is an Android TV application that serves as a client for media servers (primarily Jellyfin). It implements a Clean Architecture with clear separation between Data, Domain, and Presentation layers, using Jetpack Compose for the UI, Hilt for dependency injection, and Kotlin Coroutines/Flow for asynchronous operations. The application provides a TV-optimized interface for browsing media libraries, playing content with support for multiple players (ExoPlayer and MPV), handling subtitles/audio tracks/video quality, and managing user preferences. Key features include offline caching, background synchronization, advanced video format support (HDR, Dolby Vision), and a polished user experience with animations and focus handling for TV remotes.
Orchestra is a mature, composable WPF application framework for building line-of-business desktop applications on .NET (net8.0-windows through net10.0-windows). It provides a complete shell infrastructure including splash screens, about dialogs, crash recovery, keyboard shortcut customization, changelog viewers, status bars, busy indicators, and recently-used item management. The framework is built on top of Catel (MVVM, IoC, logging) and integrates with Orc.* libraries for theming, controls, and system information. It offers two shell variants: a Ribbon.Fluent shell using Fluent.Ribbon for rich ribbon UIs, and a TaskRunner shell for simpler task-oriented interfaces. The architecture is modular and service-oriented, with all major features exposed via interfaces (e.g., IShellService, IStatusService, IKeyboardMappingsService) and registered through Microsoft.Extensions.DependencyInjection. The core library (Orchestra.Core) contains the foundational services, while shell-specific packages (Orchestra.Shell.Ribbon.Fluent, Orchestra.Shell.TaskRunner) provide concrete implementations. The framework also includes a shared shell library with recovery services, progress bars, and configuration management. Key entry points include the ShellService for application lifecycle orchestration and the ApplicationInitializationServiceBase for custom startup logic. External dependencies include Catel (7.x), Fluent.Ribbon (11.x), ControlzEx, and several Orc.* packages (Orc.Theming, Orc.Controls, Orc.LogViewer, Orc.SystemInfo). The build system is powered by Cake scripts with support for multiple installer formats (InnoSetup, MSIX, Velopack), code signing, and CI/CD integration. The repository also includes example applications demonstrating both shell variants and a comprehensive test suite with public API verification. Data flows are primarily user-driven: application startup triggers splash screen, configuration loading, shell creation, and keyboard mapping initialization. User interactions (closing, keyboard shortcuts, status updates) are handled through service abstractions. The framework manages local user data (configuration backups, changelog snapshots, recently used items) but does not process external datasets or analytics.
SpanFinder is a fully-featured Windows file explorer replacement built with WinUI 3 and .NET 8, implementing the macOS Finder Miller Columns paradigm. The application supports multiple view modes (Miller Columns, Details, List, Icons), multi-tab with tear-off, split pane, Quick Look preview, batch rename, archive handling (ZIP, RAR, 7z via native OtterZip engine), remote file access (FTP/SFTP/SMB), Git integration, cloud sync badges, and a file shelf for drag-and-drop staging. The architecture follows MVVM with dependency injection, extensive use of Win32 P/Invoke and COM interop for shell integration, and a separate thumbnail worker process for crash isolation. The codebase is well-organized into Services, Models, ViewModels, and Helpers, with over 150 unit tests and 40+ UI automation tests. However, it exhibits some mixed abstraction layers and a few large partial classes (MainWindow, MainViewModel), and many comments reference specific bug fixes, indicating ongoing refinement. The repository is actively maintained with recent commits, a single open issue, and regular versioned releases (v2.0.7).
Animite is an unofficial Android client for AniList (with partial MyAnimeList support) for tracking anime and manga. The application is built with a modern Android stack: Kotlin, Jetpack Compose, Material3, Apollo Kotlin (GraphQL), Ktor (REST), DataStore, Hilt, and Coil. It features a multi-module architecture with clear separation of concerns: API layers, core UI components, navigation, and feature modules (explore, profile, media, settings, social, anime, manga, banner). The app supports browsing, searching, filtering, detailed media pages with dynamic theming (time-of-day based banner), user profile management, and list editing with drag-and-drop reordering. The codebase demonstrates strong modularity and reusable UI patterns, though it relies heavily on experimental Compose APIs and has a few code quality concerns (e.g., hardcoded credentials, large screen files, alpha version instability).
Bark is a native iOS application that turns APNs push notifications into a self-hostable, customizable notification delivery system. It is not a data or research project; it is a polished consumer iOS app with a companion widget, notification service extension, and App Intents. In production, the app maintains a device registration key per user, listens for remote notifications via Apple Push Notification service, and enriches incoming payloads through a chain of processors in the Notification Service Extension: decrypting AES-encrypted bodies (CBC/ECB/GCM with CryptoSwift), rendering Markdown, setting badges, auto-copying text, archiving to Realm, muting groups, triggering call interruptions, and attaching images/icons. The main app provides a history list with group/section rendering, server management (defaults to api.day.app but supports custom self-hosted servers), QR-code server import, encryption settings, archive retention controls, sound selection, and a modern home screen demonstrating usage via curl-like examples. A WidgetKit timeline widget shows recent messages from a shared JSON snapshot, and Siri/Shortcuts intents can trigger pushes to the current or another device. The architecture follows a reactive MVVM pattern using RxSwift/RxCocoa throughout, with Realm as the local persistence layer shared across app and extensions via an App Group container. The project targets iOS 15+ with five Xcode targets (main app, notification service extension, notification content extension, widget, tests) and is distributed via the App Store and TestFlight through fastlane and GitHub Actions.
Monitorian is a Windows desktop application for adjusting brightness and contrast of multiple monitors via DDC/CI and Windows power settings. It features a WPF-based MVVM architecture with system tray integration, per-monitor sliders, and support for unison/adjustment modes. The application includes automatic startup registration, multi-language support (30+ languages), and a hidden diagnostic menu for probe/rescan/logging operations. Key components include custom slider controls (EnhancedSlider, CompoundSlider), window theming utilities (WindowPainter), and a robust settings persistence system using XML serialization. The codebase demonstrates solid engineering practices with clear separation of concerns, though it relies heavily on Windows-specific APIs which may require ongoing maintenance for OS compatibility.
This repository provides a WPF custom control library, Sdl.MultiSelectComboBox, which is a fully-featured multi-select combo box with support for item selection, grouping, sorting, filtering, autocomplete, and suggestion providers. The library includes a set of well-defined interfaces (IFilterService, IAutoCompleteService, ISuggestionProvider, IItemGroup, IItemEnabledAware) that allow developers to plug in custom logic. The main control class (MultiSelectComboBox) is a large, self-contained WPF custom control that handles all UI interactions, including keyboard and mouse input, popup management, and visual state management. The codebase also includes a reusable event behaviour factory for attaching commands to routed events, visual tree helper utilities, and a theme manager for dynamic resource switching. The example project demonstrates a realistic usage scenario with a language selection UI, flag icons, and multiple configuration options. The code is well-structured and follows MVVM patterns, though the core control is monolithic due to the nature of WPF custom control development. The library is published as a NuGet package and targets .NET 4.8 and .NET 6.0 (Windows).
ScreenToGif is a Windows desktop application for screen, webcam, and sketchboard recording, with a built-in editor and export to animated images (GIF, APNG, WebP, AVIF), video (MP4, AVI, MKV, MOV, WebM), image sequences (BMP, JPEG, PNG), PSD, and its own project format (STG). The architecture follows MVVM with multiple projects: ScreenToGif (WPF UI), ScreenToGif.Model (domain/enums/interfaces), ScreenToGif.ViewModel (presets/tasks), ScreenToGif.Util (helpers, codification, converters, settings), ScreenToGif.Native (P/Invoke wrappers), and ScreenToGif.Test (unit tests). The application uses .NET 9 and relies on FFmpeg, Gifski, KGySoft.Drawing, and SharpDX (for DirectX capture). It features a rich set of custom WPF controls, global keyboard/mouse hooks, undo/redo with file-based state, color quantization algorithms, and cloud upload integration (Imgur, Yandex Disk). The codebase is well-structured but shows signs of technical debt: large monolithic files, legacy encoder implementations, deprecated SharpDX dependency, and minimal test coverage.