This is the official ASP.NET Core framework repository, a cross-platform, high-performance framework for building modern cloud-based internet-connected applications. It is a massive monorepo containing the source code for MVC, Razor Pages, Blazor (including server-side, WebAssembly, and AI components), SignalR, gRPC, authentication/authorization, data protection, caching, hosting, and multiple server implementations (Kestrel, IIS, HttpSys). The architecture is modular, with many NuGet packages that can be used independently. Key entry points include WebApplication.CreateBuilder, UseStartup, MapControllers, MapBlazorHub, and MapHub. The framework relies on the .NET runtime and the ASP.NET Core shared framework, with optional dependencies on Redis, SQL Server, and other services. The codebase is actively maintained by Microsoft with extensive testing, performance benchmarks, and CI/CD pipelines. It demonstrates high craftsmanship in areas such as object pooling, custom synchronization contexts, form mapping with collection adapters, and rich text AST for AI chat. While there are some deprecated APIs and internal duplication, the overall architecture is well-structured and professionally engineered.
FluentValidation is a .NET library for building strongly-typed validation rules using a fluent interface. It supports both synchronous and asynchronous validation, localization, conditional validation, rulesets, and cascade modes. The architecture centers around AbstractValidator<T> and IValidator<T>, with extension methods for common validation scenarios. The library is designed for use in various .NET applications, including ASP.NET Core, and provides dependency injection integration. Key components include a high-performance accessor cache, message formatter for templating, condition builder for reusable predicates, property chain utility for object graph navigation, and validation strategy for configuring validation scope.
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.
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.
OrchardCore is a mature, open-source modular and multi-tenant application framework and CMS built on ASP.NET Core. The codebase reveals a production-grade system with a rich extensibility model: content parts and fields with display drivers, workflow engine with activities, deployment/recipe system, multi-tenant shell contexts, and multiple search backends (Lucene, Elasticsearch, Azure AI). The frontend admin UI is implemented in Vue 3 with TypeScript (the 'Bloom' framework), providing reusable UI components and a data pipeline designer. Under the hood, it uses YesSql as a document ORM, SignalR for real-time notifications, and supports various authentication providers, localization, and media management. Despite its large surface, the architecture is cleanly separated into modules with consistent patterns (display drivers, handlers, permission providers), though some legacy deprecations and duplicate search provider code indicate manageable technical debt.
Jellyfin is a free software media system that manages, organizes, and streams personal media libraries (movies, TV shows, music, photos, books, live TV). The backend server is written in C# using ASP.NET Core and provides a REST API, WebSocket support, and a plugin system. It handles media metadata aggregation from multiple external providers (TMDB, MusicBrainz, AudioDB, etc.), transcoding via FFmpeg, user authentication and authorization, and real-time session synchronization (SyncPlay). The architecture is modular with separate packages for API controllers, database persistence (EF Core with SQLite), media file naming/parsing, metadata providers, and background scheduled tasks. Key entry points include the main server startup (Jellyfin.Server), API controllers (Jellyfin.Api), and the plugin system (MediaBrowser.Providers.Plugins). External dependencies include FFmpeg for transcoding, SQLite for the database, and various third-party metadata APIs. The codebase demonstrates strong engineering practices with extensive unit and integration tests, a custom event-driven architecture, and a well-defined authorization handler pattern for fine-grained access control. While there are some legacy namespaces and a large number of database migrations indicating schema evolution, the overall structure is clean and maintainable.
This repository is a .NET library for JWT (JSON Web Token) key management that provides automatic generation and rotation of cryptographic keys for JWT signing (JWS) and encryption (JWE). It features a modular architecture with a core library handling key generation/storage, multiple storage providers (in-memory, file system, Entity Framework Core), and framework-specific integrations for ASP.NET Core and IdentityServer4. The library exposes a JWKS endpoint for sharing public keys and integrates with ASP.NET Core authentication systems to validate tokens using the managed keys. Key entry points include the AddJwksManager() service registration method, UseJwksDiscovery() middleware for the JWKS endpoint, and the IJwtService interface for token generation and validation. The primary data flow involves generating cryptographic keys, storing them via pluggable storage providers, retrieving current keys for token operations, and exposing public keys through the JWKS endpoint. The library depends on System.IdentityModel.Tokens.Jwt for JWT handling, Microsoft.AspNetCore.DataProtection for key protection in the default storage implementation, and various Microsoft.Extensions packages for caching, options, and logging.
Mail-Archiver is a production-grade ASP.NET Core 10 web application for archiving emails from IMAP, Microsoft 365 (Graph), and local imports (MBOX, EML). It provides a full MVC UI for searching, viewing, exporting, restoring, and managing archived emails, alongside a read-only REST API (v1) and a Model Context Protocol (MCP) server for AI agent integration. The system features background job processing for sync, batch operations, deduplication, retention policies, and audit exports, all backed by PostgreSQL with full-text search. Authentication supports local password (PBKDF2), OpenID Connect, and API keys, with two-factor authentication and role-based access control. The codebase is well-structured with clear separation of concerns: provider-specific services (IMAP, Graph, Mbox), shared utilities, and a core service layer. Extensive unit and integration tests (xUnit) cover critical paths, and Docker Compose provides a reproducible test environment. While some technical debt exists (raw SQL in core services, in-memory job tracking, German comments in places), the overall architecture is solid and the reusable components (static helpers, deduplication strategies, background job patterns) demonstrate high craftsmanship.
RiotSharp is a C# wrapper for the Riot Games API, providing access to League of Legends data including summoner information, match history, champion stats, leagues, and static game data. The library implements automatic rate limiting to comply with Riot's API constraints and includes caching for static data to minimize API calls. It features a layered architecture with separate projects for the core library, ASP.NET Core integration, and tests. The main entry point is the `RiotApi` class, which aggregates all endpoint interfaces via dependency injection. Key reusable components include a sophisticated rate limiter, a pluggable caching abstraction, a base class for static data endpoints, and custom JSON converters for enum serialization.
This repository is a comprehensive educational course titled '.NET Web API Zero to Hero' by codewithmukesh. It contains over 50 independent ASP.NET Core Web API sample projects organized into modules covering fundamentals (minimal APIs, exception handling, logging), database management with EF Core (CRUD, migrations, interceptors, soft deletes, bulk operations, pagination), advanced API patterns (CQRS with MediatR, custom dispatcher, Result pattern, mapping benchmarks), performance and caching (in-memory, Redis, HybridCache, EF second-level cache), API security (JWT, refresh tokens, role/claims/policy/permission-based authorization, API keys, CORS, rate limiting), file handling (PDF invoice generation), architecture (Clean Architecture vs Vertical Slice), observability (health checks, structured logging), and background processing. Each sample is a self-contained, runnable project with minimal setup (often using in-memory databases) and includes extensive BenchmarkDotNet performance comparisons. The code is well-structured, follows modern .NET 10 patterns, and demonstrates production-quality implementations of cross-cutting concerns like global exception handling, validation pipelines, and caching strategies. While the repo is primarily a teaching resource, many components (custom CQRS dispatcher, Result pattern, EF Core interceptors, permission-based authorization) are genuinely reusable in other projects.
The system is a Home Assistant addon that enables backup creation and synchronization with OneDrive. Built with ASP.NET Core and Blazor Server, it provides a web UI for configuration and monitoring, scheduled backups with retention policies, file synchronization, and exposes Home Assistant sensor entities for status monitoring. The architecture follows a layered design with separate services for backup management, file synchronization, and external API integrations (Home Assistant and Microsoft Graph). Key entry points include Program.cs for application startup and the Orchestrator for coordinating scheduled tasks. Data flows involve creating backups via the Home Assistant API, uploading to OneDrive via GraphHelper, and synchronizing file changes bidirectionally.
This repository implements an OCPP (Open Charge Point Protocol) server for electric vehicle charging stations, supporting versions 1.6, 2.0, and 2.1. It consists of two main applications: OCPP.Core.Server handles WebSocket-based communication with charging stations and provides a REST API for management operations, while OCPP.Core.Management offers an ASP.NET Core MVC web interface for configuring charge points, managing RFID tags, viewing transactions, and sending remote commands. The system uses Entity Framework Core for data persistence with SQL Server and SQLite providers, featuring a plugin architecture for extensions like custom authorization and Azure Service Bus integration. The codebase demonstrates clean separation of concerns with version-specific controllers, middleware patterns, and dependency injection, though it contains some duplication across OCPP version handlers.
This repository implements a banking system built with ASP.NET Core that enables users to create bank accounts, manage cards, transfer funds internally and between banks via a central API, and process payments. The system features a modular architecture with separate projects for the main bank web application, central API for inter-bank communication, and a demo shop showcasing payment integrations. Key capabilities include user authentication with 2FA, email notifications via SendGrid, security measures like reCAPTCHA and request encryption, and role-based administration. The solution follows layered architecture patterns with separation of concerns between presentation, service, and data access layers, utilizing Entity Framework Core for ORM and AutoMapper for DTO mapping.
AIBotPublic is a full-stack ASP.NET Core MVC web application that provides a comprehensive AI chatbot platform. It integrates multiple AI providers (OpenAI, Baidu, custom endpoints) and offers features such as real-time chat, role-playing, AI assistants, knowledge base with vector search (Milvus), plugin marketplace, workflow automation, AI book generation, deep research, and a community forum. The system includes user management, payment processing (WeChat/Alipay), VIP tiers, and an admin panel for configuration and monitoring. The frontend is built with jQuery and Bootstrap, with a bundled Monaco Editor for code editing capabilities. The architecture follows a service layer pattern with dependency injection, Entity Framework Core for data access, Redis for caching, and SignalR for real-time communication. The repository also contains a custom OpenAI SDK wrapper (Betalgo.Ranul.OpenAI) that covers completions, embeddings, assistants, fine-tuning, and vector stores. While the codebase is feature-rich and functional, it exhibits signs of technical debt such as duplicated frontend pagination logic, hardcoded API URLs in JavaScript, and a large vendored third-party dependency (Monaco Editor v0.45.0). The project is actively maintained with recent commits and no open issues, but the reliance on .NET 6 and an older version of Monaco Editor indicates moderate technical drift.
AntMgr is an ASP.NET Core MVC admin management framework designed for rapid development of backend systems. It provides built-in user, role, menu, and permission management with button-level authorization, along with a CRUD code generator and a SQL query tool. The architecture follows a layered pattern: Web (mgr.core) -> ServicesModel -> ViewModels -> Repository -> Infrastructure, using Autofac for DI, AutoMapper for object mapping, and a custom ORM (AntData.ORM) supporting MySQL and SQL Server. The frontend relies on jQuery, Bootstrap 3, and Vue.js 1.0 with numerous third-party plugins for UI components. Key features include role-based access control with hierarchical roles and god-mode bypass, a code generation engine using DotLiquid templates that produces full CRUD modules (Controller, Repository, ViewModel, ServiceModel, View), Excel import/export via Npoi.Mapper, and an integrated SQL editor with field hints. The system emphasizes convention over configuration, allowing developers to quickly scaffold admin pages with minimal setup. While functionally complete and actively maintained (last commit 2026-03-16), the codebase carries significant technical debt from outdated frontend libraries (Vue 1.0, Bootstrap 3, numerous jQuery plugins from 2014-2016) and a custom ORM that may lack community support. The hardcoded god-mode users and direct SQL execution tool also pose security risks. The code generation engine and Excel helper are the most reusable components, demonstrating practical patterns for meta-programming and data I/O.
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.