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.
This is a Windows Forms desktop application for tracking and displaying statistics for the game Fall Guys. It reads game log files to monitor player performance, provides real-time statistics via an in-game overlay, and offers detailed views for win stats, level statistics, and player profiles. The application features a layered architecture with presentation (Windows Forms with MetroFramework), business logic (entity classes handling data processing and API interactions), and data storage (LiteDB) layers. Key features include profile management, external service integration (Fallalytics for leaderboards), customizable overlay with position controls, multi-language support, theme switching, and automatic updates. The application demonstrates good engineering practices in several reusable components, particularly its toast notification system with builder pattern, enhanced DataGridView control with export capabilities, custom transparent label control, and specialized WebClient for proxy authentication.
This is a WPF desktop application (.NET Framework 4.8) that provides a graphical user interface for the rimage image compression command-line tool. The application allows users to batch convert images with various codecs (MozJPEG, WebP, AVIF, PNG, JPEG XL, etc.), control quality, quantization, dithering, output suffixes, resize options, and output directory policies. It features a dual-pane layout with a file list on the left and conversion settings on the right, live progress tracking, light/dark theme following the Windows system setting, and bilingual Chinese/English UI. The rimage backend executable is embedded and verified by SHA-256 hash and version probe before use. The codebase demonstrates solid engineering: clean separation between core logic (command building, validation, job execution) and UI (view models, converters, custom controls), comprehensive unit tests covering both logic and integration with the backend, and attention to edge cases (trailing backslash quoting, metadata-driven output paths, chunked job execution for progress reporting). The repository is actively maintained with a clear MIT license.
GrasscutterCommandGenerator is a Windows Forms (.NET Framework 4.8) desktop application that serves as a comprehensive administration and command-generation tool for Grasscutter, a Genshin Impact private server emulator. It provides a GUI to generate and execute server commands (e.g., give items, teleport, spawn entities, set weather), edit server configuration files (gacha banners, drops, shops, activities), manage player accounts and permissions, and run a MITM proxy to intercept game traffic. The application is heavily data-driven, relying on embedded localized text files for game entity IDs and names, and uses Newtonsoft.Json for serialization. It supports multi-language UI (Chinese, English, Russian, Traditional Chinese) and integrates with a remote command plugin (gc-opencommand-plugin) for direct server interaction. The architecture is a monolith WinForms application with a tabbed page interface. The main entry point is Program.cs, which initializes the main form (FormMain) that hosts multiple pages (e.g., PageGiveItem, PageAvatar, PageQuest, PageProxy) and modal editors (FormGachaBannerEditor, FormShopEditor). A base class (BasePage) provides common lifecycle and command execution methods. The application communicates with the Grasscutter server via HTTP (OpenCommandAPI) and can also modify system proxy settings to redirect game traffic. External dependencies include the .NET Framework, Newtonsoft.Json (embedded), and Windows API calls for proxy and hotkey management. Key data flows involve loading game data from embedded resource files at startup, constructing command strings from user input, and optionally sending them to the server. The proxy module (Eavesdrop) captures and forwards HTTP/HTTPS traffic between the game client and server. The tool also supports importing/exporting player data in the GOOD (Genshin Open Object Description) format. While the codebase is functional and well-organized for its domain, it is tightly coupled to the Grasscutter server API and game data, requiring manual updates with each game patch. No automated tests are present, and the reliance on hardcoded data and Windows-specific features limits portability.
Shutdown Timer Classic is a mature Windows desktop utility, implemented as a .NET Framework 4.8 WinForms application, that lets users schedule a timed system power action such as shutdown, restart, hibernate, sleep, or lock. The primary entry point is Program.cs, which parses command-line arguments, installs global exception handling, and launches the main Menu form. The architecture is a classic single-process WinForms monolith: Menu.cs configures the timer, Countdown.cs renders the live countdown and manages the tray icon, Timer.cs owns the countdown state machine, and helper classes wrap Windows APIs for shutdown (ExitWindows.cs), sleep prevention (ExecutionState.cs), and single-instance enforcement (ApplicationInstanceManager.cs). User settings are persisted as JSON in %AppData%\Shutdown Timer Classic\settings.json, with version migration logic to handle upgrades. External dependencies are minimal: the .NET Framework, Newtonsoft.Json for deserialization, and direct P/Invoke calls into Windows system DLLs. There is no data pipeline, telemetry, or research component; this is purely an application. The codebase is reasonably well-structured for a desktop utility of this scope. It demonstrates craftsmanship in several isolated helper classes, particularly argument parsing, Windows API wrappers, and single-instance handling, which could be extracted into other Windows system-tool projects with little modification. However, the project carries legacy-platform drag: it depends on .NET Framework 4.8 and WinForms, has no automated test suite visible, and stores UI resources as large base64 blobs in .resx files, making icon changes noisy. The application is actively maintained, with packaging support for both MSIX (Microsoft Store) and legacy MSI, and uses GitHub Actions for CI. Overall, it is a solid, functional utility with a few genuinely reusable low-level components, but not an exemplary architecture to study.
This is the Katana project: Microsoft's implementation of the OWIN (Open Web Interface for .NET) specification for .NET Framework. It provides a middleware pipeline, hosting infrastructure (self-host via HttpListener and IIS integration via System.Web), and a rich set of middleware including static files, diagnostics, CORS, and an extensive authentication/authorization suite covering cookies, OAuth 2.0, OpenID Connect, WS-Federation, JWT, and social providers (Google, Facebook, Twitter, Microsoft Account). The architecture is built around the OWIN environment dictionary flowing through composable middleware. Key entry points include `WebApp.Start()` for programmatic hosting, `OwinHttpHandler`/`OwinHttpModule` for IIS integration, and the `OwinHost.exe` command-line tool. The codebase is well-architected with patterns like `AuthenticationHandler<T>` base class, `IAppBuilder` extensions, and service abstraction interfaces, but it is deprecated in favor of ASP.NET Core. It targets .NET Framework 4.5 exclusively and uses legacy package management (`packages.config`). While the core patterns remain instructive, the library is not directly reusable for modern .NET development without significant porting.
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.