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.
Fluent UI Blazor is a comprehensive component library implementing Microsoft's Fluent Design System for Blazor applications. It provides reusable UI components (buttons, menus, grids, dialogs, etc.) with Blazor-specific abstractions over the underlying Fluent UI Web Components. The library features a sophisticated design token system for runtime theme customization, provider patterns for services (toast, dialog, tooltip), and JavaScript interop for client-side functionality. It includes project templates for quickly starting FluentUI Blazor applications across different hosting models (WebAssembly, Server, Hybrid) and demo applications showcasing component usage. The architecture follows .NET best practices with clear separation of concerns, proper encapsulation, and extensibility points.
Stl.Fusion is a high-performance .NET framework for building real-time, distributed, and stateful applications. It implements a Distributed REAactive Memoization (DREAM) pattern, where computed values automatically track their dependencies and invalidate when those dependencies change. This enables transparent caching, automatic UI updates, and efficient client-server state synchronization without manual cache management. The framework is architected as a layered set of libraries: Stl (base utilities), Stl.Interception (AOP proxy generation), Stl.CommandR (CQRS command pipeline), Stl.Rpc (full-duplex RPC with WebSocket transport), Stl.Fusion (core compute engine with states and operations), Stl.Fusion.Server (ASP.NET Core integration), Stl.Fusion.Blazor (Blazor components), and Stl.Fusion.EntityFramework (EF Core integration with operation log change tracking). It also includes Redis integration for pub/sub and caching, and a Roslyn source generator for proxy types. The framework is designed for Blazor Server and WebAssembly, microservices, and any .NET application requiring real-time reactivity. It provides extensive test coverage, performance benchmarks showing orders-of-magnitude improvements over traditional caching, and sample applications (TodoApp, HelloCart) demonstrating end-to-end usage.
BootstrapBlazor is a comprehensive, enterprise-class Blazor UI component library built on Bootstrap 5. It provides over 100 reusable components including tables, dialogs, forms, charts, navigation, and media elements, all with extensive localization support (Chinese/English) and JavaScript interop for rich client-side behavior. The library follows a consistent architecture: each component inherits from BootstrapComponentBase, uses a CssBuilder for CSS class construction, and optionally loads a dedicated JS module via the JSModuleAutoLoader attribute. Services like DialogService, ToastService, and DrawerService follow a callback-based pattern (BootstrapServiceBase) for decoupled UI interactions. The repository also includes a full demo server (BootstrapBlazor.Server) that showcases every component with live examples, sample data services, and API controllers for authentication, file upload, and real-time communication (SignalR, TCP sockets). External dependencies include Bootstrap CSS, FontAwesome/Material Design icons, Floating UI for dropdown positioning, and several third-party JS libraries (Chart.js, Plyr, etc.). The codebase is well-tested with bUnit and xUnit, and is actively maintained with frequent releases and a large contributor community.
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.
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.
OpenBudgeteer is a personal budgeting application built with .NET 9.0 featuring a Blazor WebAssembly frontend and ASP.NET Core Web API backend. It implements the bucket budgeting methodology, allowing users to manage financial accounts, transactions, budget categories (buckets), automated transaction rules, recurring transactions, and financial reporting. The application supports multiple database providers (MySQL, PostgreSQL) and uses Redis for session storage and application settings. The architecture follows a layered approach with distinct data, service, presentation, and API layers. The data layer uses Entity Framework Core with a repository pattern for data access. The service layer provides business logic through generic and EF Core-specific services. The presentation layer employs the MVVM pattern with Blazor components and ViewModels handling UI state and logic. The API layer exposes RESTful endpoints for the frontend to interact with the backend. Key reusable components include a generic repository pattern, a generic service pattern, a ViewModel base class for Blazor, a fluent CSV bank transaction mapper, and a MudBlazor theme persistence service. These components demonstrate craftsmanship in abstraction and separation of concerns, making them suitable for extraction and reuse in other projects. The application is actively maintained with recent updates to .NET 9.0, MudBlazor, and ApexCharts, indicating low technical drift.
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.
BlazorBlueprint is a comprehensive Blazor UI component library inspired by shadcn/ui, providing over 112 styled components and 28 headless primitives. It targets .NET 8 across Server, WebAssembly, and Auto render modes, with full accessibility (ARIA, keyboard navigation), theming via CSS custom properties (compatible with shadcn CSS variables), and zero Tailwind/Node setup. The library is split into two layers: Primitives (headless, behavioral components with focus management, positioning, and portal services) and Components (styled, ready-to-use widgets like DataGrid, charts, forms, dialogs, and navigation). It ships with four icon libraries (5,200+ icons) and 11 chart types via Apache ECharts. The architecture emphasizes composability through cascading contexts, a consistent form-field pattern, and a utility-first approach with the ClassNames.cn helper for Tailwind class merging. The codebase demonstrates strong engineering practices: extensive use of generics, expression trees for filtering, JS interop with guarded disposal, and a localization system with 200+ string keys. However, the large API surface, heavy JS interop, and limited test coverage (only a few unit tests for DataGrid and hierarchy utilities) present maintenance risks.
Elsa Studio is a modular, extensible Blazor application that serves as the frontend for managing Elsa Workflows. It provides a visual workflow designer (supporting BPMN, flowcharts, state machines, and sequences via both X6 and React Flow rendering engines), workflow definition/instance management, real-time diagnostics (structured logs, console logs, OpenTelemetry traces/metrics), authentication (ElsaIdentity, OpenID Connect, external brokers), role-based security, user tasks, and platform integration. The application is built on a plugin architecture using features, widgets, and menus registered via dependency injection. It communicates with the Elsa Core backend through Refit-generated API clients and SignalR for live updates. The codebase demonstrates strong engineering practices with extensive unit and integration tests, but shows some technical drift due to dual designer engines, outdated Docker targets (.NET 7), and multiple authentication stacks that increase maintenance surface.
This repository is a curated, community-maintained 'awesome list' for the Blazor framework (a Microsoft .NET web UI framework). It aggregates and categorizes hundreds of external resources including sample projects, tutorials, libraries, videos, articles, podcasts, tooling, books, and community links. The main entry point is the README.md, which provides a structured table of contents with shields.io badges (GitHub stars, last commit, license) for each listed resource. The repository also contains yearly archives (2017–2024) tracking historical resources, a Component-Bundle-Comparison.md that compares 16+ Blazor UI component libraries, and a CONTRIBUTING.md with contribution guidelines. The repository itself contains no executable application code or data pipelines; it is purely a documentation/curation project that serves as a discovery and reference hub for the Blazor ecosystem. The curation methodology follows a consistent pattern of categorization, metadata badges, and archival, making it a reusable template for other awesome lists. The repository is actively maintained with recent commits referencing .NET 11 previews in 2026, though the sheer volume of external links introduces inherent risk of link rot and staleness for less popular entries.
Elib2Ebook is a .NET 10 application that downloads books from 60+ online libraries (Litres, MyBook, BookRiver, etc.) and converts them into standard ebook formats (EPUB, FB2, CBZ, JSON, TXT). It is a dual-deployment solution: a CLI tool and a Blazor web UI, both sharing a core domain and service layer. The architecture is a layered .NET solution with Domain, DomainServices, and per-site ExternalServices projects, using a reflection-based GetterFactory to auto-discover site adapters. The system handles site-specific anti-bot measures, authentication, and pagination, then normalizes content into a common domain model before passing it to format-specific builders.
This is a large collection of over 1000 sample projects and templates for developing Microsoft Office Add-ins (Excel, Word, Outlook, PowerPoint, OneNote). The repository demonstrates a wide range of features: task panes, custom functions, authentication/SSO (MSAL, nested app auth, OAuth), Microsoft Graph integration, Blazor WebAssembly add-ins, shared runtime, event-based activation for Outlook, ribbon customization, keyboard shortcuts, offline storage, and legacy VSTO/COM samples. The codebase spans multiple technology stacks including JavaScript/TypeScript with webpack, ASP.NET Core MVC, Node.js, and Blazor. While many samples are functional and serve as good learning resources, the repository suffers from massive duplication of localization files (outlook_strings.js in dozens of languages) and outdated dependencies (jQuery 1.9.1, AngularJS, VSTO). The overall code quality is typical of sample collections – functional but not production-grade – with isolated reusable patterns for authentication and Graph API interaction.