MahApps.Metro is a mature WPF UI library that provides a comprehensive set of custom controls, styles, themes, and helpers for building modern desktop applications with a Metro/Windows 10/WinUI aesthetic. The library offers over 30 custom controls including HamburgerMenu, ContentDialog, InfoBar, RangeSlider, NumericUpDown, ColorPicker, AutoSuggestBox, SplitView, and a full dialog system with login, input, message, and progress dialogs. It ships with three visual style sets (Metro, Win10, WinUI) and integrates deeply with the ControlzEx theming framework for runtime theme switching. The architecture is a standard .NET library with a large public API surface exposed via dependency properties, attached properties, custom behaviors, converters, and automation peers. The codebase is heavily tested (350+ NUnit tests) with a custom WindowTestFixture for UI integration tests. Sample applications (MahApps.Metro.Gallery, MahApps.Metro.Demo) demonstrate real-world usage, and project templates (dotnet new) provide scaffolding for new apps. The library also includes project templates (MahAppsMetroApp, MahAppsMetroMvvmApp, MahAppsMetroNavApp) and a Visual Studio manifest. Despite its age and large API surface, the library remains actively maintained with recent commits, issue triage, and support for .NET 6-10. Technical drift is moderate: some obsolete code (ClipBorder) and Win32 P/Invoke are present, and the three style sets must be kept in sync. The test suite is comprehensive but pixel-level and resource-key-dependent, making it somewhat brittle. Overall, this is a high-quality, production-tested UI library with strong architectural patterns and reusable components.
This repository is a WPF control library that ports Microsoft's WinUI3 (Fluent) design language to the Windows Presentation Foundation (WPF) framework. It provides a comprehensive set of modern UI controls—such as NavigationView, CommandBar, InfoBar, TabView, SplitView, NumberBox, ColorPicker, TeachingTip, and many more—each with full theming support (light, dark, high-contrast), accessibility automation peers, and virtualized layout engines for high performance. The library is distributed as a NuGet package (ModernWpfUI) and is accompanied by a gallery demo application (ModernWpf.Gallery) that showcases all controls with live code samples. Architecture: The codebase is organized into two main assemblies: ModernWpf (base infrastructure: theme management, helpers, icon sources, animations, window chrome) and ModernWpf.Controls (all ported controls with their XAML templates, property definitions, and automation peers). Controls follow a declarative property system using DependencyProperty registration, and many leverage a recycling element factory (RecyclePool) for efficient item rendering in repeaters and lists. The library integrates with WPF's native theming via ResourceDictionaryEx and FluentControlsResources, merging platform Fluent dictionaries with custom theme resources. Key entry points: For consumers, the library is used by adding the ModernWpf.Controls assembly and referencing the namespace http://schemas.modernwpf.com/2019 in XAML. The gallery application entry point is ModernWpf.Gallery/App.xaml.cs. Test infrastructure includes ModernWpfTestApp and dedicated unit tests under test/ that use a custom WpfTestHost. External dependencies: WPF (System.Windows), .NET runtime, and Win32 native methods for window management (NativeMethods.cs). The build system supports multiple .NET targets (net462, net8.0-windows7.0, net10.0-windows7.0) with conditional compilation. The project maintains strict parity with upstream WinUI3 through source-audit tests that pin specific commit hashes and verify code patterns. This ensures the WPF port remains faithful to the original Fluent design, but also creates maintenance overhead when upstream changes. The library is in preview status (1.x release candidate) with a frozen 0.9.x line; API is not yet frozen.
OpenClaw Windows Node is a native Windows system-tray companion application for the OpenClaw AI agent ecosystem. It provides a full desktop experience for managing gateway connections, executing AI agent workflows with local and remote models, and controlling Windows capabilities (camera, screen, location, browser proxy, speech I/O) under granular permission and sandbox policies. The application is built with WinUI 3 and .NET 10, and features a complex multi-process architecture including a WSL-based gateway installer, a native MSIX gateway runtime, a Reactor chat surface with markdown rendering, a local AI inference subsystem (CUDA, Whisper STT, Piper TTS, Ollama), and an extensive exec approval pipeline with allowlist/deny/prompt modes and confusable command detection. The codebase exhibits strong engineering discipline with high test coverage (unit, integration, UI, accessibility, and source-contract tests), clean separation of concerns via dependency injection, and reusable patterns for concurrency control, file-based leasing, URL safety, and telemetry. It is actively maintained with regular CI, code review automation, and GitHub triage workflows.
Starward is a third-party Windows desktop companion and launcher for HoYoverse games (Genshin Impact, Honkai: Star Rail, Honkai Impact 3rd, Zenless Zone Zero). It replaces the official HoYoPlay with enhanced features: game installation and update management (including pre-download and delta patching), gacha (wish) history tracking with UIGF import/export, real-time game record display (Spiral Abyss, Simulated Universe, etc.), HDR screenshot capture and batch conversion, playtime statistics, game account switching, and cloud game launching. The application is built with .NET 10 (C#), WinUI 3, and MVVM (CommunityToolkit.Mvvm), with a separate gRPC-based background service (Starward.RPC) for privileged game installation tasks. It uses SQLite via Dapper for local data storage, WebView2 for miHoYo login and game notices, and integrates with miHoYo/HoYoverse APIs via reverse-engineered clients. The codebase is well-structured into Core, RPC, Setup, and UI projects, with strong localization support (10+ languages via Crowdin). It demonstrates advanced Windows development skills including Win32 interop, Win2D image processing, and custom XAML controls. However, it is Windows-only, tightly coupled to miHoYo's volatile APIs, and contains some code duplication (e.g., DriveHelper) and hardcoded registry paths.
DevToys is a cross-platform desktop application that bundles over 30 developer utilities (JSON formatter, Base64 encoder/decoder, hash generator, regex tester, etc.) into a single interface. The application uses an embedded Blazor WebView for its UI, enabling a modern web-like component model with rich editors (Monaco Editor), responsive layouts, and platform-specific theming. It follows an MVVM architecture with MEF (Managed Extensibility Framework) for dependency injection and plugin discovery, allowing third-party extensions to add new tools. The project also includes a CLI variant and an SDK (DevToys.Api) for extension development. Architecturally, the codebase is organized into platform-specific host projects (Windows WPF, macOS AppKit, Linux GTK) that all share a common Blazor UI layer (DevToys.Blazor) and business logic (DevToys.Business, DevToys.Core). Key entry points are the native window classes (e.g., MainWindow.xaml on Windows) which initialize the Blazor WebView and MEF composition. Data flows begin with clipboard or file input, which passes through smart detection services to suggest relevant tools, then renders the tool's UI via a fluent builder API. The settings system uses typed definitions and platform-agnostic storage. External dependencies include .NET 8, Blazor, SixLabors.ImageSharp, Monaco Editor (downloaded and vendored), and several community libraries (FuzzySharp, OneOf, System.CommandLine). The codebase demonstrates strong engineering practices: extensive localization (40+ languages), accessibility features, theme support (dark/light/compact), and a comprehensive Blazor component library. While the MEF-based plugin system is functional, it relies on the legacy System.ComponentModel.Composition package, and the platform-specific implementations (e.g., file storage, clipboard) are duplicated across Windows, macOS, and Linux, posing a moderate maintenance burden.
The Windows App SDK (formerly Project Reunion) is a Microsoft platform SDK for building modern Windows desktop applications. It provides a unified set of WinRT APIs and runtime components that bridge Win32 and UWP development, enabling features like app lifecycle management (single-instance, file/protocol activation), dynamic package dependencies (resolving framework packages at runtime), rich notifications (toast, push, badge), resource management via MRT Core (PRI files with qualifier-based selection), deployment APIs (package sets, validation), environment variable management, OAuth 2.0 authentication, and interop wrappers for storage pickers and camera capture. The architecture is modular: each feature area is implemented as a separate C++/WinRT component (DLL) that can be consumed individually via NuGet packages. The SDK supports both packaged (MSIX) and unpackaged (self-contained) apps, with a bootstrap DLL that initializes the runtime and hooks into the Windows package graph via Detours. Key entry points include MddBootstrapInitialize2 for runtime initialization, the WindowsAppRuntime DLL for COM class factories, and individual component APIs like AppNotificationManager, PushNotificationManager, and PackageDependency. External dependencies include the Windows SDK, C++/WinRT projections, the Windows Implementation Libraries (WIL), and Microsoft Detours for API interception. Data flows involve inter-process communication through shared memory (for activation redirection), named pipes (for OAuth callbacks), and COM out-of-process servers (for push notification long-running tasks). The codebase is heavily instrumented with TraceLogging telemetry and uses feature flags (TerminalVelocity) to gate experimental APIs.
Files is a modern, open-source Windows file manager built with WinUI 3 and .NET 10, featuring multitabbing, dual-pane navigation, file tags, cloud drive integration, FTP support, Git version control, and a widget-based home page. The architecture is a modular monolith with separate projects for the main app (Files.App), a server component (Files.App.Server), storage abstractions (Files.App.Storage, Files.Core.Storage), a source generator for CsWinRT interop (Files.Core.SourceGenerator), and custom UI controls (Files.App.Controls). The codebase makes heavy use of source-generated P/Invoke via CsWin32, Roslyn source generators for VTable functions and command managers, and the CommunityToolkit.Mvvm pattern with ObservableObject and dependency property source generation. The app supports MSIX packaging, sideload and Store distribution channels, and includes C++/COM components for custom open/save dialogs and a launcher. The last commit was on 2026-06-30, and the project has 44k stars with active CI/CD workflows.
The microsoft/WindowsAppSDK-Samples repository is a comprehensive suite of reference applications demonstrating the Windows App SDK (WinAppSDK) ecosystem. It is not a single monolithic application but a collection of independent projects categorized by feature domain, including App Lifecycle, Composition, Input, Notifications, AI/ML, and Islands. The codebase serves as the primary learning resource for developers building Windows desktop applications using WinUI 3, WPF, WinForms, and native C++. It explicitly covers both packaged (MSIX) and unpackaged deployment models, with distinct initialization logic for each (e.g., Bootstrap initialization for unpackaged apps). The repository also includes Visual Studio project templates to scaffold new applications. Architecturally, the repository is organized as a gallery of samples where each project is self-contained but shares common utilities in the SamplesCommon directory. The code demonstrates high craftsmanship in complex areas like Composition animations, Direct2D interop, and ONNX Runtime integration. However, the codebase exhibits significant duplication of boilerplate logic (e.g., MainWindow initialization, Navigation patterns) across dozens of sample projects. Additionally, many C++ samples rely on legacy NuGet management (packages.config) rather than modern PackageReference, indicating a technical debt in the C++ tooling alignment. The repository is actively maintained with recent commits and CI pipelines for various sample categories. It relies heavily on specific Windows App SDK versions and preview APIs (e.g., ElementCompositionPreview), which introduces a risk of drift as the SDK evolves. The presence of both C++/WinRT and raw Win32/C++ samples highlights a transition period in the Windows development stack, requiring developers to navigate mixed paradigms.