This repository is a comprehensive WPF UI library (WPF-UI) that implements Microsoft's Fluent Design System for Windows Presentation Foundation. It provides over 70 custom controls (NavigationView, ContentDialog, Snackbar, TitleBar, NumberBox, ToggleSwitch, etc.), a full theme management system with dynamic light/dark/high-contrast switching, Win32 interop for modern window chrome and taskbar integration, and a navigation framework with DI support. The library is distributed via NuGet and includes Visual Studio project templates. The codebase is well-structured with a folder-per-control pattern, partial classes for separation of concerns, and extensive use of dependency properties, routed events, and attached behaviors. The core library targets .NET 10/9/8 and .NET Framework 4.6.2–4.8.1, with abstractions targeting .NET Standard 2.0/2.1 for maximum compatibility. The repository also contains a comprehensive demo application (Wpf.Ui.Gallery) that showcases all controls with MVVM (CommunityToolkit.Mvvm), localization, and an embedded Monaco Editor for live code samples. Integration tests using FlaUI and unit tests for animations and symbol extensions are present. The architecture is documented with C4 diagrams and ADRs. The library is actively maintained with frequent commits, CI/CD via GitHub Actions, and responsive issue triage. While the codebase is generally high-quality, there are some work-in-progress controls (TreeGrid), deprecated APIs in ContentDialog, and vendored third-party assets (Monaco Editor) that introduce minor maintenance risks. Overall, this is a strong, production-ready UI library with clean abstractions and several reusable patterns.
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.
This repository is a comprehensive native UI component library that implements Microsoft's Fluent Design System for Apple platforms (iOS, macOS, and visionOS). It provides over 30 reusable controls—such as buttons, avatars, tables, navigation bars, date pickers, tooltips, and notifications—each backed by a sophisticated token-based theming system. The architecture is modular: a common core (`FluentUI_common`) defines design tokens, themes, and utilities, while platform-specific modules (`FluentUI_iOS`, `FluentUI_macOS`) contain UIKit and AppKit implementations. Both SwiftUI and UIKit are supported, with bridging components like `ControlHostingView` and `MSF*` wrapper classes. The library is distributed via CocoaPods and Swift Package Manager, and includes extensive demo apps and UI tests. The codebase is actively maintained, with CI pipelines, localization automation, and regular commits. The standout feature is the token system (`ControlTokenSet`, `TokenSet`, `DynamicColor`), which provides a clean, extensible abstraction for theming that could be extracted and reused in other projects.
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.
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.
FluentYTDL is a Windows desktop application built with PySide6 and qfluentwidgets that provides a modern Fluent Design GUI for downloading videos and audio from YouTube and X (Twitter). It wraps yt-dlp as the core download engine and adds a rich layer of task management, error diagnostics, cookie-based authentication, subtitle handling, metadata embedding, and VR/360 video support. The application features a persistent SQLite task database, structured observability with JSONL event tracing, rule-based error classification, and a self-update mechanism with component version management. It is heavily internationalized (English and Simplified Chinese) and includes a comprehensive test suite covering UI, download pipeline, diagnostics, and observability contracts. Architecturally, the codebase is organized into distinct modules: core (config, dependency, update), auth (cookie sentinel, WebView2 provider), download (executor, workers, staging, quality guard), processing (metadata, subtitles, sponsorblock), diagnostics (rule engine, line collector), observability (events, traces, artifacts), and UI (pages, dialogs, delegates, components). The download pipeline is transactional with staging areas and manifests, ensuring atomicity and recovery. The observability layer is best-effort and never blocks business logic, emitting structured events for debugging and bug bundle export. The code demonstrates strong engineering practices: immutable dataclasses for plans, singleton managers with explicit initialization guards, strategy patterns for subtitle selection, and extensive use of signals for async UI updates. Key reusable components include the container compatibility resolver (deterministic output container decision), BCP-47 language matching with tiered resolution, the quality guard pattern for pre/post-download verification, the transactional staging pattern for file management, and the cookie runfile isolation pattern to prevent yt-dlp from corrupting truth-source cookies. The diagnostics rule engine and observability event system are also well-isolated and could be extracted for other yt-dlp wrapper projects.
BetterLyrics is a feature-rich WinUI3 desktop application for Windows that displays and customizes synchronized song lyrics. The application serves as both a lyrics visualizer and a music player, supporting multiple display modes (standard, fullscreen, desktop wallpaper, docked, taskbar) with GPU-accelerated rendering via Win2D and ComputeSharp pixel shaders. It integrates with the Windows Global System Media Transport Controls (GSMTC) to work with external players like Spotify, Apple Music, and NetEase, and provides its own local media playback engine with a music library browser and playlist management. The architecture follows MVVM (CommunityToolkit.Mvvm) with a service layer and dependency injection, separating platform-agnostic logic in 'BetterLyrics.Core', UI in 'BetterLyrics.WinUI3', and a plugin SDK in 'BetterLyrics.Sdk'. Core data flows include lyrics retrieval from multiple providers (QQ, Netease, Kugou, Apple Music, LrcLib) with caching, metadata extraction via TagLib, and analytics tracking stored in LiteDB. The plugin SDK allows third-party developers to extend lyrics sources, translations, transliterations, and AI services via isolated AssemblyLoadContext. Reusable components include generic helpers (Debouncer, ValueTransition, FullyObservableCollection), a comprehensive lyrics format parser (LRC, TTML, QRC/KRC), and a plugin framework with auto-generated settings UI.