Humanizer is a .NET library that provides a comprehensive set of extension methods for converting raw data types (numbers, dates, times, byte sizes, strings, enums, collections) into human-readable, localized text. It supports over 90 locales with full pluralization, ordinalization, inflection, and parsing of number words back to numeric values. The library is designed as a reusable dependency for applications requiring user-friendly formatting. Architecturally, Humanizer follows a strategy/registry pattern: each formatting domain (number-to-words, date humanization, ordinalization, etc.) defines an interface and a default implementation, with locale-specific overrides resolved through a central Configurator. Locale data is defined in YAML files and compiled at build time by a Roslyn source generator into immutable profile classes, keeping runtime algorithms generic and data-driven. The library also includes Roslyn analyzers for API migration and a comprehensive test suite with cross-locale theory tests. Key entry points are extension methods on primitive types (e.g., `42.ToWords()`, `"hello_world".Humanize()`, `DateTime.Now.Humanize()`, `ByteSize.FromBytes(1024).Humanize()`) and the `Configurator` for advanced configuration. The primary data flow is: user calls an extension method → culture resolution → delegation to the appropriate converter/formatter → use of generated profile data to produce localized output. External dependencies are limited to the .NET standard library and CLDR plural rule data.
RestSharp is a mature .NET HTTP client library that wraps HttpClient into a fluent request/response API. It is not a standalone application; it ships as NuGet packages consumed by other projects. The core RestClient handles execution through an async pipeline: interceptors, authenticators, request content construction, cookie containers, redirect handling, and response deserialization. RestRequest models parameters (query, header, body, URL segments, cookies, files) and is built fluently through extension methods. Responses are RestResponse<T> with error aggregation and throw helpers, making failure handling explicit and consistent. The architecture is modular: a core library plus optional serializer packages for Newtonsoft.Json, System.Text.Json, XML, and CsvHelper, a DI integration package for Microsoft dependency injection, and a Roslyn source generator that produces immutable and clone variants of configuration types. Authentication is pluggable via IAuthenticator, with built-in Basic, JWT, OAuth1 signature generation, and OAuth2 client-credentials/refresh-token/token authenticators. Serialization is managed by a registry keyed by data format and content type, with automatic body sniffing between JSON and XML. The codebase multi-targets netstandard2.0, net471, net48, net8.0, net9.0, and net10.0, and includes extensive unit and WireMock-based integration tests, benchmarks, and versioned Docusaurus documentation. Code quality is strong: clean separation of concerns, extensive use of extension methods for ergonomics, custom source generation for option immutability, and a comprehensive test suite covering OAuth1 official vectors, redirect behavior, cookies, serializer edge cases, and interceptor ordering. Some legacy surface remains (obsolete hooks, polyfills for old TFMs), but the project tracks current .NET releases and is actively maintained. This is a well-crafted library that remains one of the standard HTTP client abstractions in the .NET ecosystem.
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.
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.
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.
A simple yet rigorously correct .NET library for validating email addresses according to RFC 5322 and Internationalized Email standards (RFC 653x). The core is a hand-written character-by-character parser that rejects invalid syntax while supporting quoted strings, IP literals, international characters, and length constraints per the spec. It provides a static `Validate`/`TryValidate` method and a DataAnnotations `EmailAttribute` for easy integration into ASP.NET or other validation frameworks. The library is well-tested with hundreds of valid and invalid examples, including edge cases like surrogate pairs and maximum-length addresses. It targets multiple .NET frameworks (net462, net8.0, net10.0, netstandard2.0/2.1) and is distributed as a NuGet package with signed assemblies. The code is clean, well-commented, and free of external dependencies for the core validation, making it a trustworthy component for any .NET application needing email input validation.
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.
Neo.VM is a lightweight, deterministic, stack-based virtual machine library for executing Neo smart contract bytecode, written in C# targeting .NET 10.0. It implements a complete instruction set (opcodes) for arithmetic, control flow, stack manipulation, type conversion, arrays/structs/maps, and interop (syscalls). The VM features a pluggable jump table dispatch pattern, integrated reference counting for garbage collection of cyclic object graphs, and a debugger API supporting step-into/over/out. Extensively tested with JSON-driven specification files covering edge cases, plus performance benchmarks. Published as a NuGet package, it serves as the execution engine for the Neo blockchain's smart contract runtime.
This repository contains the official Microsoft.Data.SqlClient library, the primary ADO.NET data provider for SQL Server and Azure SQL Database. It implements the full Tabular Data Stream (TDS) protocol, connection pooling (with both legacy WaitHandle-based and modern Channel-based implementations), Always Encrypted with enclave support, configurable retry logic, Azure Active Directory authentication, bulk copy operations, query notifications, and diagnostic instrumentation via ETW/EventSource. The codebase is highly engineered for production use, targeting .NET Framework, .NET Core, .NET 5+, and .NET Standard. It is accompanied by a rich ecosystem of companion packages for Azure Key Vault integration, authentication abstractions, and logging. The repository also includes extensive test suites (unit, functional, manual, stress, performance), simulated TDS server tools for protocol-level testing, and benchmarking infrastructure. The code is actively maintained with frequent dependency updates, security patches, and feature additions, reflecting a disciplined engineering process and strong backward-compatibility awareness.
Ink is a C#-based scripting language and engine for creating interactive narratives in games. It compiles ink script to a JSON-format runtime story that executes text output, choices, variables, and control flow (diverts, tunnels, function calls). The architecture cleanly separates compiler, runtime, and tooling layers, enabling integration with game engines like Unity and web platforms via a command-line compiler (inklecate) and runtime story class. The codebase demonstrates strong engineering practices with reusable components: a parser combinator library (StringParser), lightweight JSON serializer (SimpleJson), and shared INamedContent interface for hierarchical story elements. While parser and state management exhibit some complexity, the design is modular and maintainable, evidenced by recent activity and real-world adoption in games. Maintenance is active with very recent commits, and technical drift is low due to up-to-date .NET 6.0 usage and careful backward compatibility handling.
HarmonyX is a runtime method patching library for .NET, forked from Harmony 2 and maintained by BepInEx. It allows modifying existing methods at runtime by injecting prefixes, postfixes, transpilers, finalizers, and IL manipulators. The library is primarily used in game modding, especially for Unity games via BepInEx, but can be used in any .NET application requiring runtime code transformation. The architecture centers on the Harmony class as the public API, which delegates to PatchProcessor and PatchClassProcessor for applying patches. Patches are defined via attributes or programmatically. The core patching backends are ManagedMethodPatcher (for methods with IL bodies) and NativeDetourMethodPatcher (for native/external methods). IL manipulation is handled by HarmonyManipulator, which uses MonoMod.Cil and Mono.Cecil to rewrite method bodies. The library also provides utilities like AccessTools (reflection helpers), Traverse (field/property traversal), CodeMatcher (IL pattern matching), and MethodInvoker (fast delegate invocation). Key data flows: A patch request specifies a target method and patch methods. The PatchManager resolves the appropriate patcher, which creates a detour or IL rewrite. For IL-based patching, the original method body is read via Mono.Cecil, converted to CodeInstruction objects, processed by transpilers and manipulators, and then written back using a custom IL emitter. The patched method then calls the original (or a copy) with the injected code. The library supports complex ordering via priority and before/after attributes, and handles edge cases like generics, value types, ref returns, and async methods. External dependencies include MonoMod.RuntimeDetour, MonoMod.Utils, and Mono.Cecil for IL manipulation. The library targets multiple .NET frameworks (net35, net452, netstandard2.0) and is distributed as a NuGet package (HarmonyX).
Splat is a cross-platform .NET utility library that provides a lean abstraction layer for dependency injection (service location), logging, bitmap loading, color handling, and application performance monitoring. It is part of the ReactiveUI ecosystem and is designed to work across .NET Framework, .NET Core, Xamarin, and modern .NET (including NativeAOT). The library offers multiple DI container adapters (Autofac, DryIoc, Ninject, SimpleInjector, Microsoft.Extensions.DependencyInjection), logging backends (Serilog, NLog, Log4Net, Microsoft.Extensions.Logging, Exceptionless), and bitmap loaders (SkiaSharp, WPF, Android native, Cocoa). The core service location includes several resolver implementations with different performance characteristics, including a modern lock-free generic-first resolver optimized for AOT. The logging abstraction supports allocation-free typed arguments and composable wrappers. While the library is well-tested and actively maintained, some adapter packages are marked as alpha/prototype and a few components rely on reflection or platform-specific code that may drift.
This repository is a .NET library (Ical.Net) that implements the iCalendar specification (RFC 5545) for parsing, manipulating, and serializing calendar data in the ICS format. It provides core types such as Calendar, CalendarEvent, Todo, Journal, FreeBusy, VTimeZone, and Alarm, along with comprehensive support for recurrence rules (RRULE, RDATE, EXDATE), time zone handling via NodaTime, and free/busy computation. The architecture follows an object-oriented design with clear separation of concerns: data types (e.g., CalDateTime, Period, RecurrenceRule), calendar components, serializers (e.g., CalendarSerializer, PropertySerializer), and an evaluation engine for expanding recurring occurrences. The library is production-grade, with extensive test coverage (including a large corpus of ICS fixture files and regression tests for bug fixes), benchmarks for performance, and a logging abstraction. It is not a standalone application but a library designed to be consumed by .NET applications that need iCalendar functionality.
RESTCountries.NET is a .NET Standard 2.1 library providing offline access to comprehensive country data. It deserializes an embedded JSON dataset (sourced from restcountries.com) into strongly-typed C# models and exposes static query methods for searching by name, code, currency, language, and more. The library requires no network calls at runtime, making it suitable for disconnected or performance-sensitive applications. It includes a full test suite, a benchmark harness, and is distributed via NuGet with automated CI/CD. The architecture is straightforward: a static `RestCountriesService` class loads data on first access and uses LINQ to answer queries. Models cover Country, Currency, Language, Flags, Maps, Translations, and other attributes. The translation support includes 24 languages via ISO 639-3 codes. Overall, it's a well-crafted, single-purpose utility library with professional engineering practices.
DocX is a .NET library for creating, editing, and manipulating Word 2007/2013/2016 .docx files without requiring Microsoft Office. It provides a comprehensive API for document generation, including paragraphs, tables, charts, images, hyperlinks, headers/footers, bookmarks, footnotes/endnotes, mail merge, and password protection. The library operates by manipulating Open XML package parts using System.IO.Packaging and LINQ to XML, with a cross-platform drawing abstraction layer (SkiaSharp on .NET5, System.Drawing on .NET Framework). It is the free community edition of Xceed Words for .NET, with many advanced features (PDF conversion, SVG support, digital signatures) stubbed out in the examples and requiring a commercial license. The codebase is well-structured but shows signs of technical drift: it targets .NET Framework 4.0 and .NET 5.0 (both out of support), uses deprecated APIs, and contains large monolithic files (e.g., Document.cs ~3880 lines). Despite these issues, the library is actively maintained (last commit June 2026) and widely used, with a rich set of examples demonstrating real-world usage.
WebMarkupMin is a comprehensive .NET library for minifying HTML, XHTML, XML, CSS, and JavaScript markup to optimize web application performance. It provides a core minification engine with parsers and output writers, plus extensive integration with ASP.NET (both classic .NET Framework and .NET Core/5+) through middleware, HTTP modules, MVC action filters, and WebForms base page classes. The library supports multiple minifier backends: built-in Crockford JS and Kristensen CSS minifiers, plus wrappers for Microsoft Ajax Minifier, YUI Compressor, and NUglify. It also includes compression support for GZip, Deflate, and Brotli. The architecture is modular, with clear interfaces (IMarkupMinifier, ICssMinifier, IJsMinifier, ICompressor) and factory patterns, enabling pluggable backends and easy extension. Configuration is exposed via strongly-typed settings classes. The codebase is well-tested with hundreds of unit tests covering edge cases in markup parsing, whitespace handling, attribute optimization, and framework-specific features (Angular, Knockout, Blazor). The repository is primarily a library (not a standalone application), and its samples demonstrate integration with various ASP.NET versions.
OpenMod is a .NET-based plugin framework designed for extensibility across game servers and applications. It provides core services including dependency injection, event handling, command processing, permission systems, user management, and configuration management. The framework features a modular architecture with platform-specific adapters for games like Unturned and Rust, enabling developers to create plugins that extend functionality without modifying the core. The system uses an event-driven approach for loose coupling and supports self-updating via NuGet package management. While primarily focused on game server modding, the core abstractions are general enough to apply to other extensible application scenarios.
The CachingFramework.Redis library is a .NET caching abstraction built on top of StackExchange.Redis. It provides a rich set of features including cache-aside patterns, tag-based invalidation, support for Redis data structures (strings, hashes, sets, sorted sets, bitmaps, HyperLogLog, geospatial), pub/sub, and key space notifications. The architecture centers around RedisContext as the main entry point, which provides access to modular features like Cache, Collections, GeoSpatial, PubSub, and KeyEvents. The library employs a provider pattern for encapsulating Redis operations and offers extensible serialization via an ISerializer interface with multiple implementations (binary, JSON, MessagePack, MemoryPack). It is designed for dependency injection and follows .NET best practices with async/await support and proper configuration management.
RSSDP is a .NET library implementing the Simple Service Discovery Protocol (SSDP) for UPnP device discovery and advertisement. The library enables applications to discover network services and advertise their own services on local networks using UDP multicast communication. It provides a clean separation of concerns with distinct components for device discovery (SsdpDeviceLocator), device publication (SsdpDevicePublisher), and network communication handling (SsdpCommunicationsServer). The library follows .NET best practices with interface-based dependency injection, proper IDisposable implementation, and event-driven architecture for device lifecycle events. It supports multiple .NET platforms including .NET Framework 4.8+, .NET 6/8+, .NET Standard 2.0, and Xamarin platforms via MAUI. The repository includes comprehensive unit tests, sample applications (console, MAUI, UWP), and generated documentation via DocFX.
NCalc is a .NET library for parsing and evaluating mathematical expressions, written in C# and targeting .NET Framework 3.5. It uses ANTLR 3.3 to generate a lexer and parser from a custom grammar, producing an abstract syntax tree (AST) of logical expressions. The library supports arithmetic, logical, bitwise, comparison, and ternary operators, as well as built-in functions (Abs, Sin, Round, etc.) and user-defined functions and parameters via event handlers. It also includes expression caching, error detection, and serialization. The codebase is well-structured for its era, with a clear separation between grammar, domain model, and evaluation logic. However, it is explicitly unmaintained and superseded by a newer version (ncalc/ncalc). The project uses outdated dependencies (ANTLR 3.3, .NET 3.5) and includes binary DLLs, making it unsuitable for modern .NET projects without significant migration effort. The primary value is as a historical reference or for understanding expression evaluator design patterns.