UniGetUI is a cross-platform package manager GUI that provides a unified interface for multiple package managers (WinGet, Chocolatey, Scoop, Homebrew, Snap, Flatpak, APT, DNF, Pacman, pip, npm, Bun, .NET Tool, etc.). The application follows a clean layered architecture with Avalonia-based MVVM UI, a domain package engine, and infrastructure services for settings, logging, telemetry, and IPC. It supports both GUI and headless/daemon modes for automation, includes operation history tracking, secure settings storage, package bundling, and scheduled maintenance tasks. The codebase demonstrates strong engineering practices with clear separation of concerns, extensive test coverage, and modern .NET patterns.
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.
Auto Dark Mode is a Windows desktop utility that automatically switches between dark and light system themes. In production it operates as a multi-process system: a WinUI 3 settings app (AutoDarkModeApp), a background service with system tray icon (AutoDarkModeSvc running under Windows Forms Application.Run), a lightweight CLI shell for IPC commands (AutoDarkModeShell), and self-update tooling split between a legacy C# updater and two Rust components (adm-updater-rs, adm-downloader-rs). The service evaluates multiple triggers — custom time schedules, sunrise/sunset from geolocation or manual coordinates, Windows Night Light state, ambient light sensor lux readings, battery/energy saver state, GPU load, process blocklists, and system idle — then applies theme changes across Windows components: system/app theme, per-monitor wallpapers, accent color, taskbar color, cursors, touch keyboard, color filters, and user-defined scripts. UI and service communicate over named-pipe IPC with a command/response protocol; configuration persists in YAML files watched via FileSystemWatcher and WMI events. This is purely an application repository; bundled GeoJSON assets and geolocation features serve the scheduling feature, not data research. Architecturally the codebase shows genuine craftsmanship: a governors pattern (TimeSwitchGovernor, NightLightGovernor, AmbientLightGovernor) separates switch-decision logic from switch-execution, switch components (ISwitchComponent/BaseComponent) isolate individual theme pieces, a postpone manager coordinates blocking conditions (GPU, idle, processes, notifications) with expiry callbacks, and a config-update event system decouples YAML changes from feature reactions. The UI follows MVVM with CommunityToolkit, dependency injection, and 25+ localized locales. Maintenance is active with recent commits and an issue-triage workflow, but technical drift is medium: commented-out ZeroMQ code and legacy updater logic remain, updater behavior is triplicated across C# and Rust, localization coverage has drifted (many locales contain untranslated English strings), and core features depend on undocumented Windows COM interfaces (IThemeManager2) and build-version checks that may break with future Windows updates.
Win11Debloat is a PowerShell-based Windows 10/11 debloating and configuration utility. It provides both a WPF graphical interface and a command-line interface, allowing users to remove pre-installed bloatware, disable telemetry and AI features, customize the taskbar, Start menu, File Explorer, and apply numerous registry tweaks. The tool is data-driven: feature definitions, app catalogs, and localization strings are stored in JSON files, while registry modifications are applied via `.reg` files. It supports undo operations, registry backup/restore, system restore points, and multi-user or Sysprep deployment scenarios. The architecture is modular, with dot-sourced PowerShell scripts organized into functional directories (Features, Helpers, GUI, AppRemoval, FileIO, Threading) and a comprehensive Pester test suite. External dependencies include PowerShell 5.1, winget, and standard Windows command-line tools. The codebase demonstrates high craftsmanship with reusable patterns for registry file parsing, non-blocking execution, user profile resolution, and localization.
wsldl is an advanced WSL (Windows Subsystem for Linux) distribution launcher and installer. It provides a CLI tool that manages WSL instances: installing, configuring, running commands, backing up, and cleaning up Linux distributions on Windows. The architecture is a single binary with a command dispatcher pattern, where each subcommand (install, run, config, backup, clean, etc.) is implemented as a separate package with its own 'command.go' and 'help.go' files. The system depends on Windows-specific WSL APIs via the `wsllib-go` and `wslreglib-go` libraries, with platform-conditional stubs for non-Windows builds. The codebase demonstrates strong engineering practices: dependency injection for testability, clear separation of concerns, comprehensive unit tests (over 2000 lines of tests), and a mock-based testing strategy for the WSL API. The CLI supports interactive and non-interactive usage, path translation between Windows and WSL paths, and integration with Windows Terminal and Fluent Terminal.
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.
This repository contains the ReviOS Playbook, a collection of configuration files and executable scripts designed for the AME Wizard tool to customize Windows 10 and 11 installations. Its primary function is to debloat the operating system by removing pre-installed bloatware (Microsoft Edge, OneDrive, Teams, UWP apps like Xbox, Photos, etc.), disabling telemetry, privacy-invasive features, and unnecessary services, and applying a set of registry tweaks for performance and privacy. The playbook also offers optional software installation (Brave or Firefox), wallpaper and theme configuration, and integration with the Revision Tool for further customization. The architecture is a declarative task pipeline defined in YAML files, orchestrated by AME Wizard, with supporting PowerShell and CMD scripts for specific actions like app removal, registry modifications, and service changes. It is not a standalone application but a payload for AME Wizard.
Microsoft PowerToys is a modular suite of Windows productivity utilities designed to enhance the user experience for power users. The codebase is a large, multi-language monolith (C++, C#, WinUI 3, WPF) organized around a central runner process that loads modules (e.g., FancyZones, PowerToys Run, Image Resizer, Advanced Paste, Peek, Workspaces) as dynamic libraries or COM objects. Each module has its own settings, telemetry, UI, and IPC pipeline. The architecture relies heavily on Win32 APIs, COM interop, named pipes, and ETW tracing. Key entry points include the runner executable, the Settings UI (WinUI 3), and per-module interfaces like `AdvancedPaste` or `PowerRename`. The repository is actively maintained by Microsoft with frequent commits and a large community, but the sheer number of modules introduces code duplication, mixed UI frameworks, and some technical drift.
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.
WinDynamicDesktop is a Windows desktop application that replicates the macOS Mojave Dynamic Desktop feature, automatically changing the desktop wallpaper based on the time of day. Built with WinForms and .NET, it determines sunrise/sunset times using the device's location (via Windows location service or a geocoding API) and supports multiple monitors, lock screen synchronization, theme importing (from ZIP, JSON, or .ddw files), and localized translations across 50+ languages. The architecture includes a platform abstraction layer (DesktopHelper/UwpHelper for standard and UWP deployments), COM wrappers for wallpaper and power settings, SkiaSharp-based theme preview rendering, and an event-driven scheduler that responds to system events. It also features a PowerShell scripting interface for advanced customization, automatic updates via GitHub releases, and a config migration system for backward compatibility. The codebase is well-structured with clear separation of concerns, though it relies on external APIs (LocationIQ, POEditor) and Windows-specific COM interfaces, which introduce maintenance risk. The repository includes unit tests (sunrise calculations, system integration), CI/CD pipelines, and packaging scripts for installer and store distribution.
Twinkle Tray is a Windows desktop application for managing monitor brightness and display settings. It uses Electron for the main process and React for the UI, communicating with monitors via DDC/CI, WMI, and software gamma ramps. The application features a system tray icon, brightness panel, settings window, and supports automatic adjustments based on time of day or ambient light. It relies on numerous Windows-specific native addons for low-level hardware access, which introduces maintenance risks but provides deep hardware integration.
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.
Sophia Script for Windows is a PowerShell-based system administration utility for fine-tuning Windows 10 and 11 installations. It provides over 150 configuration functions covering privacy, telemetry, UI personalization, security hardening, debloating, and system optimization. The tool is distributed as a PowerShell module with per-edition variants (Windows 10/11, LTSC, ARM, PowerShell 5.1/7) and includes a closed-source GUI wrapper (SophiaScriptWrapper.exe) for visual configuration. Architecture: The core is a PowerShell module (Sophia.psm1) with a preset file (Sophia.ps1) that users edit to select tweaks. The module loads private helper functions (Add-Policy, Get-Hash, WinAPI, etc.) and localization files. Execution flow: Import-TabCompletion.ps1 → InitialActions.ps1 (preflight checks) → user-selected tweaks → PostActions.ps1 (system refresh, toasts, restore points). The tool modifies Windows via registry keys, group policy (LGPO.exe), service management, scheduled tasks, and file association hashes. Key entry points: Sophia.ps1 (per edition) is the main preset; Import-TabCompletion.ps1 provides tab-completion; the Wrapper/ directory contains GUI config JSONs and the wrapper executable. External dependencies include LGPO.exe (Microsoft), WinRAR for packaging, and runtime downloads for HEVC codecs and cursor packs. The project is distributed via Chocolatey, WinGet, Scoop, and direct GitHub releases. Data flows: The script reads Windows build/version info, checks remote JSON manifests for updates, and applies changes based on user preset. It exports/imports file associations as JSON and creates restore points. Localization is handled via ConvertFrom-StringData .psd1 files in 12 languages. The tool is not a data pipeline or research project; it is a pure system configuration utility.
This repository is a comprehensive, curated collection of step-by-step privacy configuration guides for a wide range of software, services, and operating systems (e.g., browsers, messaging apps, social media, Windows, Android, macOS). It is purely documentation—no executable code, APIs, or data pipelines. The content is organized into Markdown files under 'Privacy Settings' and 'Extensions Settings', with a central README serving as an index. The guides are consistently formatted, include notes and tips, and are actively maintained with regular updates reflecting the latest stable versions. While not a software application, it serves as a high-quality reference for users seeking to harden privacy settings across their digital footprint.
FastCopy (published as RoboCopyEx, v1.2.1.0) is a Windows desktop utility that replaces Explorer's default copy/move/paste/delete with a robocopy-backed engine. In production it is three cooperating native components: a WinUI 3 (C++/WinRT, Windows App SDK 1.8) application that renders copy progress, a speed graph, pause/resume, duplicate-file conflict resolution and delete confirmations; a COM shell-extension DLL that adds copy/move/paste/delete items to both the new Windows 11 and legacy Explorer context menus; and a global keyboard-hook executable that intercepts Ctrl+V inside Explorer to route pastes through FastCopy. A fastcopy:// URI handler (CommandLineHandler) is the transport by which components pass operations to the main app. The solution is an MSIX package of six projects: FastCopy (UI), FastCopyShellExtension (Explorer COM DLL), FastCopyKeyboardHook (global hook EXE), RobocopyInjection (DLL injected into robocopy.exe to expose per-file progress), UnitTest, and SpeedTest — a TUI benchmark that empirically compares robocopy, xcopy, std::filesystem, IFileOperation and SHFileOperation. The central data flow: RobocopyViewModel builds robocopy arguments; RobocopyProcess launches robocopy.exe suspended inside a JobObject, injects a DLL to force English locale output, then streams the child's stdout through a regex-driven template parser (OutputRegexParseBase) while ProcessIOUpdater samples GetProcessIoCounters/GetSystemTimes to animate the Win2D speed graph, taskbar progress and Windows toasts. Settings are persisted via a WinRT IPropertySet-backed Settings class and MVVM runtime classes declared in IDL. Engineering quality is mixed and should be read from the code rather than the README's speed claims. The repo knowingly ships a crash after the window is closed; RobocopyInjectDll.h and CreateSuspend.h contain null-byte encoding corruption; numerous features are disabled ('Under development!') or commented out; and the app depends on a third-party WinUI3Package (essential:) control library plus dual vcpkg/NuGet dependency chains, making rebuilds fragile outside the author's machine. The DLL-injection and global-hook design is also the likely reason the Store rejected the package, per drama.md. The last commit (2026-09-19) indicates the project is still actively developed. Despite containing a benchmark harness and careful README performance tables, this is an application, not a data/research repository: there are no datasets, notebooks, or pipelines, and the SpeedTest project is an empirically driven engineering tool, not analysis. Its most durable artifacts are the independently extractable OS-interop helpers and parsing templates described below.
XToolBox is a Flutter-based desktop utility application designed for Windows 10/11 system optimization and debloating. It provides a dashboard for system information, a browser for downloading/installing utilities (debloat tools, browsers, apps, etc.), playbook setup for running Windows optimization configurations, system cleanup tools, and settings management. The application follows a standard Flutter architecture with Provider for state management, featuring separate layers for services (download, installation, network checking, etc.), models, and UI components. The project has reached end-of-life as the developer switched to Linux and no longer maintains Windows software, though the source code remains available.
A collection of monolithic batch scripts (.cmd) that activate Microsoft Windows and Office using multiple methods: HWID (digital license generation), Ohook (DLL injection for Office), Online KMS (volume license with renewal), and TSforge (low-level licensing data manipulation). Each script is self-contained, containing extensive embedded PowerShell and, in one case, embedded C# code that is compiled and executed at runtime. The scripts demonstrate deep knowledge of Windows licensing internals, service management, and API calls via P/Invoke. However, the architecture is fragile: common setup logic is duplicated across all scripts, code is split between batch and PowerShell sections via fragile label splitting, and product keys/IDs are hardcoded. The repository is highly popular (192k+ stars) and functional but not well-engineered, with significant technical debt and maintenance complexity.
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.