PowerShell 7 (pwsh) is a production-grade cross-platform automation and configuration shell: a scripting language runtime, command engine, and host application. The repository contains the core engine assembly (System.Management.Automation), console host, global tool shim, hundreds of built-in cmdlets, provider infrastructure, remoting, formatting/serialization, and a meta-package SDK for embedding PowerShell in .NET applications. In production it executes scripts and commands, pipelines objects through cmdlets and providers, formats results for console or serialized transport, and supports both local runspaces and remote sessions over WinRM/WSMan and SSH. The primary entry points are ConsoleShell.Start() for the interactive host, the GlobalToolShim for the dotnet tool distribution, and the PowerShell.Create() hosting API used by embedded scenarios.
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 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.
BootstrapBlazor is a comprehensive, enterprise-grade Blazor UI component library built on Bootstrap 5. It provides over 50 reusable components (Table, Dialog, Button, Tree, Calendar, Upload, etc.), a rich service layer (Toast, Dialog, Speech, Bluetooth, Serial Port, OPC UA), and extensive JavaScript interop. The library follows a consistent architecture with component base classes, dependency injection, localization, theming, and a CSS builder pattern. A demo server and unit test suite accompany the core library. The codebase is well-structured and actively maintained, though some deprecated APIs and a large surface area indicate ongoing evolution. It is primarily an application framework for building Blazor web applications with minimal data processing.
MemoryPack is a high-performance binary serialization library for .NET (C#) that achieves extreme speed through 'zero encoding'—direct memory copies for blittable types rather than varint/tag-based encodings. It is primarily a library, distributed as multiple NuGet packages, including a Roslyn source generator that compiles serialization code for types marked with [MemoryPackable]. The core library (MemoryPack.Core) provides writer/reader ref structs, a customizable formatter architecture, and support for compression (Brotli), streaming (PipeWriter/PipeReader), version-tolerant and circular-reference serialization, and polymorphism via union types. It integrates with ASP.NET Core via input/output formatters, generates TypeScript/JavaScript serializers for web clients, and ships a Unity package with shims for common Unity types. The codebase is extensively benchmarked and tested, focusing on allocation-free, high-throughput serialization. While not a data research project, it may be used in data pipelines requiring fast, compact binary data exchange.
MinVer is a minimalist versioning tool for .NET projects that derives version numbers from Git tags according to SemVer 2.0. It operates as both an MSBuild package (MinVer) and a standalone CLI tool (minver-cli). The core logic in MinVer.Lib walks the Git commit history from the current HEAD backward to find the latest version tag. If the current commit is tagged, that version is used as-is; otherwise, it optionally increments the version (patch by default) and appends a height (number of commits since the last tag) as pre-release identifiers. The library handles tag prefixes, custom auto-increment strategies, minimum major/minor overrides, build metadata, and height suppression. The CLI tool wraps this logic with System.CommandLine argument parsing and environment variable support, while the MSBuild package integrates directly into the .NET build pipeline, setting standard version properties (AssemblyVersion, FileVersion, PackageVersion, etc.). The repository is well-organized with a clear separation between library, CLI, and build package, and includes extensive unit and integration tests that actually create Git repositories to verify behaviour. The code demonstrates high craftsmanship with async Git operations, clean error handling, and a modular design that makes the core versioning algorithm reusable.
Briefing Room for DCS World is a mission generator for the Digital Combat Simulator flight simulator. It provides web, desktop, and command-line interfaces for creating customizable military missions with objectives, units, weather, and briefing materials. The application processes mission templates (.brt/.cbrt files) combined with DCS World unit and theater data to generate executable .miz mission files. It features a modular architecture with a core mission generation library, shared utilities, and extensive Lua scripting integration for in-mission functionality like CTLD, CSAR, and IADS systems.
OfficeCLI is a cross-platform CLI application written in C#/.NET that creates, reads, and mutates OOXML Office documents (Word .docx, Excel .xlsx, PowerPoint .pptx) without requiring Microsoft Office. It is explicitly engineered as an agent-facing tool: every document element is addressable through a uniform path syntax (e.g. /slide[1]/shape[2]), all commands emit structured JSON with error codes and suggestions, and it ships AI-skill files for Claude/Copilot/Cursor/Codex, an MCP server, plus Python and Node SDKs. The core operation model is a batch command language: documents are mutated by replayable JSON items (add/set/remove/get) executed atomically through the CLI or over a named pipe to a resident process. Architecturally the repo is a single .NET binary (embedded runtime) with a CommandBuilder layer, a DocumentHandlerFactory dispatching to three large partial-class handlers (WordHandler, ExcelHandler, PowerPointHandler), and a shared Core layer containing chart-to-SVG rendering, a formula evaluator implementing 350+ Excel functions with statistical distributions, pivot table construction, Mermaid diagram parsing, OOXML theme/table-style resolution, HTML/PNG/SVG preview rendering, and a plugin protocol for foreign-format dump-readers and exporters. Security is taken seriously: SsrfGuard validates remote fetch targets, HyperlinkUriValidator allowlists URI schemes, XmlTextValidator and DocumentLimits guard against decompression bombs and DOM sprawl, and AtomicPackageWriter prevents torn file writes. Quality is strong but carries real maintenance debt. The code demonstrates deep OOXML craftsmanship - schema-order-correct XML insertion, exact EMU unit round-trips, Lanczos-based gamma functions, and curated chart-style galleries. However, handlers are split across dozens of partial-class files that evolved from former god methods, the property API is stringly-typed (props dictionaries parsed per key), examples must be maintained in parallel shell and Python twins, and the tool deliberately tolerates 'UNSUPPORTED props' warnings (exit code 2), which can mask incomplete feature coverage. The best reuse targets are the self-contained Core utilities rather than the format handlers. The project is actively maintained with multi-platform CI publishing to npm and PyPI.
YARP (Yet Another Reverse Proxy) is a high-performance, extensible reverse proxy toolkit for .NET, built on ASP.NET Core. It provides a library and samples for creating custom proxy servers with features including request forwarding, load balancing (random, round-robin, least-requests, power-of-two-choices), active and passive health checks, session affinity (cookie, hash, ARR, custom header), request/response transforms, and telemetry consumption. The architecture is middleware-based, with a pipeline that includes routing, load balancing, session affinity, health checks, and delegation (Http.sys). Configuration is driven by immutable records and supports dynamic reload via change tokens. YARP also includes a Kubernetes Ingress Controller module that watches Ingress, Service, Endpoint, and Secret resources to dynamically configure the proxy. The codebase demonstrates strong engineering practices: extensive unit and functional tests, pluggable policy interfaces, efficient stream copying with telemetry, and a transform builder pattern for declarative request/response modifications. It is actively maintained by Microsoft and used in production scenarios.
DotNext is a suite of high-performance .NET libraries providing low-level infrastructure for building distributed systems and high-load microservices. It includes advanced async synchronization primitives (e.g., AsyncLock, AsyncReaderWriterLock, ManualResetCompletionSource), zero-allocation buffer management (SparseBufferWriter, SpanOwner, MemoryOwner), metaprogramming via expression tree builders (async lambda, await, while, lock), and a full Raft consensus implementation with a persistent write-ahead log, leader election, log replication, snapshotting, and HyParView gossip-based peer discovery. The codebase demonstrates deep expertise in .NET runtime internals, lock-free algorithms, unsafe memory access, and IL weaving, with extensive unit tests and benchmarks. It is actively maintained and targets the latest .NET versions, though some components rely on preview language features and runtime internals that may require careful version alignment.
FsHttp is a .NET HTTP client library for F# (and C#) that provides a fluent, composable DSL for constructing and sending HTTP requests. It offers both a computation expression (CE) syntax for F# and extension methods for C#, supporting all standard HTTP methods, headers, cookies, multipart form data, file uploads, and various body content types (text, JSON, binary, streams, form-urlencoded). The library wraps System.Net.Http and provides rich response handling including streaming, JSON parsing (System.Text.Json by default, with optional FSharp.Data and Newtonsoft.Json integrations), XML parsing, file saving, and status code assertions. It features a configurable pipeline with transformers for headers, URLs, HttpClient, and HttpRequestMessage, as well as per-request and global configuration. The library is designed for both interactive use (F# Interactive / notebooks) and production applications, with built-in FSI printing and debug logging. The codebase is well-structured with clean domain models, a modular DSL implementation, and comprehensive test coverage using Suave for local test servers.
dotenv.net is a lightweight .NET library for loading environment variables from .env files. It provides both a static API (DotEnv.Load, DotEnv.Read) and a fluent builder (DotEnv.Fluent) for configuring options such as file paths, encoding, trimming, overwrite behavior, directory probing, export syntax support, inline comment stripping, and variable expansion/interpolation. The library supports hierarchical environment cascade loading (e.g., .env, .env.local, .env.{Environment}) and integrates with Microsoft.Extensions.Configuration via a separate package (dotenv.net.Configuration). Internally, it consists of a parser that handles single/double quoted values, multi-line values, and escape sequences; a variable expander that resolves ${VAR}, $VAR, and default fallback syntax with circular dependency detection; and a reader that reads from files or streams, probes parent directories, and merges key-value pairs. The codebase is well-structured with comprehensive unit tests covering edge cases, and targets netstandard2.0/2.1 for broad compatibility.
This is the Microsoft Open XML SDK, a production-grade .NET library for reading, writing, creating, and validating Office Open XML documents (Word, Excel, PowerPoint). It provides a strongly-typed DOM (OpenXmlElement hierarchy), LINQ-to-XML integration via generated XName constants, Flat OPC serialization, and a comprehensive validation framework based on the OOXML standard. The architecture combines hand-crafted foundations (OpenXmlElement, OpenXmlPart, OpenXmlPackage, FeatureCollection pattern) with schema-driven source generators that produce hundreds of typed classes, part definitions, and namespace constants from bundled JSON metadata. Key entry points are WordprocessingDocument, SpreadsheetDocument, and PresentationDocument, each with static factory methods (Open, Create, FromFlatOpc). The library is actively maintained by Microsoft, supports Office versions from 2007 through Microsoft365, and includes numerous samples, extensive xUnit tests, and performance benchmarks.
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.
PropertyChanged.Fody is a Fody add-in (weaver) and Roslyn source generator that automates the implementation of INotifyPropertyChanged (and optionally INotifyPropertyChanging) for .NET classes. The weaver operates on compiled IL using Mono.Cecil, injecting property change notification code into property setters, while the optional source generator emits boilerplate for partial classes at compile time. The tool supports multiple invocation patterns (event, OnPropertyChanged methods, before/after callbacks), attribute-driven dependency detection ([DependsOn], [AlsoNotifyFor]), equality checks before notifications, and extensible interceptors. Configuration is done via FodyWeavers.xml attributes or custom attributes on classes/properties. The project is mature, well-tested, and widely used (nearly 2000 stars), with extensive test coverage across inheritance, generics, nullable types, F#, and integration with MVVM frameworks like Caliburn.Micro and ReactiveUI.
This repository is a .NET library (distributed as NuGet packages) that adds a second-level query cache to Entity Framework Core applications. In production, it registers a DbCommandInterceptor that intercepts every EF Core database command: SELECT queries are converted into a cache key by hashing the SQL text, parameters, and connection string; on a cache hit, the stored result set is replayed through a custom DbDataReader implementation so EF Core never touches the database; on a miss, the query executes normally and the result is serialized into a row/column format for storage. Cache invalidation is automatic — when SaveChanges/SaveChangesAsync runs, the interceptor parses the SQL to identify affected tables and evicts all cache entries that depend on them. The architecture is a clean provider pattern. The core package (EFCoreSecondLevelCacheInterceptor) defines the interceptor, cache-key generation, SQL table extraction, and the IEFCacheServiceProvider abstraction, while separate companion packages implement backends: MemoryCache, StackExchange.Redis (with custom MessagePack serialization), FusionCache, .NET HybridCache, EasyCaching.Core, and CacheManager.Core. Public entry points are the AddEFSecondLevelCache() DI extension and the Cacheable()/NotCacheable() query extensions, with fluent configuration for expiration modes (absolute/sliding/never), per-query or global policies, and lock modes for concurrency. The codebase is actively maintained (last commit 2026-09-19, zero open issues, dependabot-clean), multi-targets .NET from net462/netstandard2.0 through net10.0, and enforces strict quality gates: TreatWarningsAsErrors, SonarAnalyzer, Meziantou analyzers, and heap-allocation analyzers. Test coverage is extensive — unit tests for key generation, SQL parsing, and data-reader reconstruction, plus integration tests across providers and issue-specific repro projects. Notable craftsmanship includes a hand-written XxHash64 unsafe implementation for fast key hashing, a DbDataReader reconstruction layer that transparently replays cached rows to EF Core, and a SQL table-name extraction processor driving invalidation. Primary risks are the heavy conditional compilation across 10+ target frameworks, SQL parsing heuristics that can miss edge cases (CTEs, subqueries, quoted identifiers), and reliance on third-party cache libraries — CacheManager.Core is explicitly unmaintained upstream. Bulk operations (ExecuteUpdate/ExecuteDelete) bypass the interceptor and require manual invalidation.
dotnet-claude-kit is an opinionated Claude Code plugin that transforms the AI assistant into an expert .NET 10 developer. It provides 47 skills (knowledge + workflow orchestrators), 10 specialist agents (e.g., dotnet-architect, ef-core-specialist), 10 always-loaded rules, 5 project templates, automation hooks, and a Roslyn-based MCP server (CWM.RoslynNavigator) offering 22 read-only code analysis tools. The MCP server delivers token-efficient semantic queries (symbol resolution, anti-pattern detection, dead code analysis, dependency graphs) via stdio, replacing expensive file reads. The architecture is modular: skills are markdown files loaded on demand, agents route requests to specialists, and the MCP server provides a robust program analysis backend. The system supports multiple AI coding tools (Claude Code, Cursor, Codex CLI, OpenCode) with cross-tool rule parity validation. Its core philosophy emphasizes guided over prescriptive development, modern .NET only (.NET 10/C# 14), and token-conscious interactions. The codebase demonstrates strong engineering with clean abstractions, extensive unit tests (200+ tests), CI/CD for NuGet publishing, and well-documented ADRs. The MCP server components (WorkspaceManager, SymbolResolver, anti-pattern detectors, pagination) are highly reusable and exhibit non-obvious craftsmanship. While the large skill surface requires synchronization, the overall quality is excellent for a developer tooling project.
This is a feature-rich companion application for the online action RPG Path of Exile (both PoE1 and PoE2). It provides real-time item price checking, trade search, wealth tracking, currency exchange rates, dangerous map modifier detection, wiki integration, and various tools (chromatic calculator, regex hotkeys, chat macros). The application runs as a cross-platform desktop app (Avalonia, legacy WPF) or as a web app, with a Blazor Server UI embedded in a WebView for desktop, or directly hosted for web. It integrates with multiple external APIs (poe.ninja, poeprices.info, poe2scout.com, poewiki.net, official Path of Exile trade API) and uses OAuth2 PKCE for account authentication. The codebase is modular, with clear separation between core common libraries, game data parsing, API clients, UI modules, and platform abstractions. It supports 10+ game languages and maintains accurate item text parsing via regex-based parsers. The architecture is a modular monolith with dependency injection, a centralized settings system (SQLite via EF Core), and an auto-update mechanism using Velopack.
The AdvancedSharpAdbClient is a .NET library that provides a managed implementation of the Android Debug Bridge (ADB) protocol, enabling developers to interact with Android devices without relying on the external `adb.exe` executable. It offers a comprehensive suite of features including device connection management, shell command execution, application installation and uninstallation, file transfer via ADB sync service, screen capture, and device state monitoring. The library is designed with a strong emphasis on testability and loose coupling, utilizing interfaces and a factory pattern for dependency injection. Architecturally, the library is structured as a set of cohesive, loosely coupled components. Core communication is handled by `AdbSocket` (low-level TCP) and higher-level operations are exposed through `AdbClient`, `DeviceClient`, `PackageManager`, and `SyncService`. The library makes extensive use of interfaces to allow for easy mocking in unit tests and provides asynchronous counterparts for most operations to support non-blocking programming models. It targets a wide range of .NET frameworks (from .NET Framework 3.5 to .NET 10+) using conditional compilation and polyfills to maintain compatibility. The library demonstrates solid engineering practices through its use of the factory pattern for object creation, extension methods to enhance interface usability, and careful handling of binary data structures for statistics and framebuffer headers. Its comprehensive test suite, which includes mock implementations for various components, ensures reliability and facilitates safe evolution. While the broad target range introduces some complexity via conditional compilation symbols, the code remains well-organized and maintainable, reflecting a commitment to serving a diverse set of .NET applications requiring Android device interaction.
PrettyPrompt is a cross-platform .NET library that replaces `Console.ReadLine()` with a feature-rich terminal input experience. It provides syntax highlighting, autocompletion (with documentation and overload panes), persistent history, multi-line editing with word wrapping, text selection and clipboard operations, and undo/redo. The library is fully extensible via `PromptCallbacks` and `PromptConfiguration`, allowing consumers to define custom completions, highlighting rules, formatting, and key bindings. It targets .NET 10 and uses ANSI escape codes for rendering, making it compatible with any modern terminal. Architecturally, the system is composed of several decoupled layers: a document model (`Document`, `StringBuilderWithCaret`) with grapheme-aware operations; an input system based on `KeyPress` and `KeyPressPattern` for flexible key binding; a rendering pipeline that computes minimal ANSI diffs via `IncrementalRendering` and `Screen`/`Cell` abstractions; and UI panes (`CodePane`, `CompletionPane`, `OverloadPane`) that handle specific interactions. The library employs object pooling (`Pools`) and caching (`StringCache`) to minimize allocations in the per-keystroke hot path. The library is extensively tested with unit tests, integration tests (using recorded keystroke logs), and benchmarks that measure per-keystroke and steady-state rendering costs. It is actively maintained, with regular releases on NuGet and continuous integration across Windows and Ubuntu. Notable external dependencies are `Wcwidth.Sources` (for Unicode display width) and `TextCopy` (for clipboard access); both are wrapped with resilience and fallback behavior.