Avalonia is a mature, cross-platform UI framework for .NET, enabling developers to build desktop, mobile, and web applications with a single codebase. It provides a rich set of controls, a powerful styling system, data binding, animations, and platform-specific backends (Windows, Linux, macOS, Android, iOS, Browser). The architecture is modular: core libraries (Avalonia.Base, Avalonia.Controls) define the property system, layout, input, and rendering, while platform backends implement windowing, graphics (Skia, Vulkan, OpenGL), and accessibility. The framework includes a XAML compiler, source generators, and extensive testing infrastructure. It is actively maintained with a large community and is used in production applications.
ILSpy is a production-grade .NET assembly browser and decompiler, serving as the open-source successor to SharpDevelop's decompiler. It is architected as a hybrid monolith with a clear plugin system (MEF), separating the core decompilation engine (`ICSharpCode.Decompiler`) from the cross-platform GUI (`ILSpy`, built on Avalonia) and the command-line interface (`ICSharpCode.ILSpyCmd`). The core engine implements a full .NET type system, an intermediate language (IL) with a comprehensive transform pipeline, and a C#/VB syntax tree generator, enabling it to faithfully reconstruct high-level source code from compiled bytecode. The primary data flow begins with loading binary assemblies (PE, ELF, bundles) through a registry of file loaders. The `ILReader` parses bytecode into IL instructions, which undergo a series of transforms (control flow analysis, pattern matching, type inference) before being built into a C# AST. This AST is then processed by output visitors to produce formatted source code, debug information, or project files. The GUI provides a dockable workspace, syntax-highlighted editor, metadata table viewers, analyzers for code navigation (find usages, overrides), and a search engine. The codebase exhibits high craftsmanship, particularly in its utility libraries and AST pattern matching. Self-contained, extractable components include a generic Union-Find data structure (`UnionFind.cs`), an immutable interval-based map for 64-bit keys (`LongSet.cs`/`LongDict.cs`), a declarative AST pattern matching DSL (`Pattern.cs`), and thread-safe lazy initialization utilities (`LazyInit.cs`). These components solve non-trivial problems (efficient range queries, backtracking tree matching) and are isolated from the rest of the codebase. The project is actively maintained, with recent commits, extensive CI/CD pipelines (CodeQL, Scorecard, Dependabot), and a large test suite covering decompilation correctness and UI behavior. Technical drift is low; the codebase targets modern .NET versions and has successfully migrated from WPF to Avalonia. While the sheer size introduces complexity, the architecture is sound, making it a strong reference for decompiler design, .NET internals, and cross-platform desktop application architecture.
UniGetUI is a cross-platform package manager GUI that provides a unified interface for multiple package managers (WinGet, Chocolatey, Scoop, Homebrew, Snap, Flatpak, APT, DNF, Pacman, pip, npm, Bun, .NET Tool, etc.). The application follows a clean layered architecture with Avalonia-based MVVM UI, a domain package engine, and infrastructure services for settings, logging, telemetry, and IPC. It supports both GUI and headless/daemon modes for automation, includes operation history tracking, secure settings storage, package bundling, and scheduled maintenance tasks. The codebase demonstrates strong engineering practices with clear separation of concerns, extensive test coverage, and modern .NET patterns.
WheelWizard is a cross-platform desktop application (Windows, Linux, macOS) built with Avalonia and .NET that serves as a comprehensive mod manager, Mii editor, and game launcher for Mario Kart Wii. It integrates deeply with the Dolphin emulator and the WiiCompiled (Recomp) native PC port, providing a unified interface for managing game modifications, custom distributions (Retro Rewind), and online community features (room browser, leaderboard, player profiles). The application handles complex binary Wii data formats, including Mii character serialization, game save files (rksys.dat), and disc image parsing. The architecture is modular, employing dependency injection extensively to separate concerns between the UI (Avalonia views), business logic (feature modules), and data access (external APIs, local filesystem). It features a sophisticated real-time 3D Mii rendering engine using OpenGL and a custom native library (FFL), complete with a keyframe-based animation system for character expressions and idle behaviors. The codebase demonstrates high craftsmanship in its error handling (OperationResult pattern), caching strategies (MiiHeadStore), and cross-platform process management. While primarily an application, it contains significant data engineering components, such as binary format parsers for Wii archives (U8, Yaz0, BRSAR), patch conversion pipelines, and game baseline analysis. The project is actively maintained with a comprehensive test suite, modern dependency management, and a strong focus on code quality, making it a valuable reference for developers working on game tooling, cross-platform desktop applications, or complex UI systems.
ShareX is a comprehensive screenshot, image editing, and file sharing application for Windows. It features a modular architecture with separate libraries for screen capture, image editing, uploading, helpers, history, and tools. The application supports capturing screenshots/recordings, applying annotations and effects, uploading to over 50 services, and includes various productivity tools. Built with .NET/C# using a mix of Windows Forms and Avalonia UI frameworks, it employs MVVM patterns, plugin architectures for extensibility, and cross-cutting helper libraries. The system handles data flows from capture through editing to upload/storage, with history tracking for user convenience.
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.
NatTypeTester is a cross-platform NAT type testing tool that implements STUN protocols (RFC 3489 and RFC 5780) to determine network characteristics. The application provides desktop (Avalonia), Android, and command-line interfaces for testing NAT type, mapping behavior, filtering behavior, and public endpoint detection. It follows a clean layered architecture with MVVM pattern, dependency injection, and separation of concerns. The core STUN protocol implementation is packaged as a reusable NuGet library (Stun.Net) that supports UDP, TCP, TLS, and DTLS transports with SOCKS5 proxy capabilities.
Stability Matrix is a cross-platform desktop application (Windows, macOS, Linux) that serves as a unified package manager, model browser, and inference UI for AI image generation tools like Stable Diffusion, ComfyUI, Fooocus, and Forge. The codebase is built with .NET 9 using Avalonia UI (with legacy WPF remnants) and follows the MVVM pattern with CommunityToolkit.Mvvm and DI via Injectio. Key entry points include the MainWindow, PackageManagerPage, InferencePage (text-to-image, image-to-image, video, upscale), and CheckpointBrowserPage (CivitAI, HuggingFace, OpenModelDB). The system manages Python virtual environments, installs packages via pip/uv, and orchestrates inference through ComfyUI's API or built-in Gemini providers. External dependencies include Refit for API clients, LiteDB for local caching, and SkiaSharp for image processing. The architecture is a modular monolith with clear separation of concerns via service interfaces, view models, and custom controls.
SyncClipboard is a cross-platform clipboard synchronization tool that monitors local clipboard changes and syncs them across devices via multiple backends (official server, WebDAV, S3-compatible storage). It provides a full desktop GUI for Windows (WinUI3), macOS, and Linux (Avalonia), along with mobile scripts for Android. The architecture is modular: a core library (SyncClipboard.Core) contains all business logic, models, view models, and services, while platform-specific packages implement clipboard access, hotkeys, window management, and UI. A separate server component (SyncClipboard.Server) provides history sync, real-time updates via SignalR, and a REST API. The application also includes an updater framework with platform-specific installers (InnoSetup, DMG, AppImage) and rollback support. Key data flows involve clipboard content being captured, profiled (text, image, file, group), hashed for integrity, and uploaded/downloaded through adapter-based remote servers. History records are stored locally in SQLite and optionally synced to the server. Configuration is versioned with automatic migration and backup recovery.
Semi.Avalonia is a comprehensive Avalonia UI theme library inspired by Semi Design, delivered as multiple NuGet packages. It provides a complete set of styled controls (buttons, text boxes, data grids, color pickers, etc.) with Light, Dark, and High Contrast themes, plus localization in 16 languages. The architecture follows Avalonia's resource dictionary and control theme patterns: each control has shared, light, dark, and high contrast XAML files that define visual states, triggers, and animations. A central `SemiTheme` class orchestrates theme swapping and locale selection via merged resource dictionaries. The repository also includes a demo application for desktop, Web, Android, and Lixux DRM platforms. The theming system is built on a well-structured token system using `Variables.axaml` and color palette files (e.g., `Light.axaml`, `Dark.axaml`) that define design tokens like spacing, border radii, and semantic colors. Control themes extensively use `DynamicResource` references, enabling runtime theme switching. The color picker extension (`Semi.Avalonia.ColorPicker`) is a notable sub-system with spectrum, palette, and component tabs supporting RGBA and HSVA models. Animations (e.g., `SemiPopupAnimations`) and custom converters (e.g., `PositionToAngleConverter`) add polish. The demo application is an MVVM-based showcase that exercises all controls and provides installation instructions. The CI/CD pipeline builds and publishes NuGet packages and cross-platform demos. Overall, this is a production-quality theming library with good mainainability, though some duplication between variant themes and a large icon file present potential maintenance costs.
GPU-T is a Linux desktop utility for comprehensive GPU information and monitoring, positioned as a GPU-Z alternative for Linux. It provides real-time sensor data (clocks, temperatures, power, fan speeds), static hardware specifications from JSON databases and sysfs, and detection of API capabilities (Vulkan, OpenCL, CUDA, etc.) through a modular probe system. The application follows the MVVM pattern with Avalonia UI and features a sidecar process for NVIDIA-specific NVAPI/NVML interactions to ensure stability and isolate native interop. Hardware detection relies on sysfs paths, external tool execution, and vendor-specific databases, with user override capabilities for hardware specifications. The modular design separates concerns into probes for hardware polling, advanced providers for feature detection, and utilities for common tasks like settings management and shell command execution.
This repository is a comprehensive XAML Behaviors library for Avalonia UI, porting the Microsoft.Xaml.Behaviors pattern to the Avalonia framework. It provides a declarative, XAML-friendly way to attach interactive logic (behaviors, triggers, actions) to UI controls without code-behind, covering common patterns such as event handling, data-driven triggers, command invocation, property changes, drag-and-drop, animations, validation, focus management, and more. The library is split into multiple NuGet packages: core interactivity (base classes), interactions (ready-to-use triggers/actions), custom interactions (control-specific behaviors), drag-and-drop, draggable elements, events, animations, responsive layout, scripting, and ReactiveUI integration. A key innovation is the use of Roslyn source generators to produce strongly-typed, reflection-free versions of actions and triggers, improving AOT compatibility and compile-time safety. The architecture follows a layered design: the foundation is the `Avalonia.Xaml.Interactivity` namespace with `Behavior`, `Trigger`, `Action` base classes and the `Interaction` static class for attaching behaviors. On top of that, `Avalonia.Xaml.Interactions.Core` provides common triggers/actions like `EventTriggerBehavior`, `InvokeCommandAction`, `ChangePropertyAction`, and `DataTriggerBehavior`. The `Custom` package adds hundreds of specialized behaviors for controls (e.g., `AutoCompleteBoxOpenDropDownOnFocusBehavior`, `SplitViewStateBehavior`, `FocusTrapBehavior`). Drag-and-drop is handled by a dedicated framework with `DropHandlerBase`, `ManagedDragDropService`, and behaviors like `PanelDragBehavior`. Animations are built using Avalonia's composition API, with helpers like `AnimationFactory` and `FluidMoveAnimation`. The source generators in `Xaml.Behaviors.SourceGenerators` produce typed wrappers from attributes like `[GenerateTypedAction]` and `[GenerateTypedTrigger]`, reducing boilerplate and runtime reflection. Key entry points for consumers are the `Interaction.Behaviors` attached property in XAML, the `Interaction.ExecuteActions` method, and the various behavior/trigger/action classes. The library depends on Avalonia UI (StyledElement, Control, Visual, TopLevel, etc.) and optionally on ReactiveUI. It includes extensive documentation via DocFX, sample applications demonstrating all features, and unit tests using Avalonia's headless testing infrastructure. The codebase is well-structured with clean abstractions, though its large surface area and reliance on internal Avalonia APIs present some maintenance risks.
RetroMultiTools is a cross-platform desktop application built with Avalonia (.NET 8) that serves as a comprehensive utility suite for retro gaming enthusiasts. It provides a unified interface for ROM management, including browsing, inspection, patching (IPS/BPS/xDelta), format conversion (N64 byte order, CHD, archive extraction), verification (CRC, MD5, SHA, DAT file validation, dump quality checks), and emulator configuration for RetroArch, MAME, Mednafen, and Analogue consoles. The application also features a gamepad key mapper, disc burning and USB imaging tools, cheat code conversion across 23 systems, remote file transfer (FTP, SFTP, WebDAV, S3, cloud storage), and a self-updater. It supports 20 languages and runs on Windows, Linux, macOS, and FreeBSD, with Flatpak packaging available. The architecture is a monolithic desktop application with a sidebar navigation tree that loads over 40 distinct views, each backed by a code-behind file and often a static utility class. The core pattern is event-driven UI with async operations using IProgress<string> and CancellationToken for long-running tasks. Localization is handled via a singleton LocalizationManager that binds to XAML controls. Settings are persisted as JSON via AppSettings. The application integrates with external tools (chdman, DolphinTool, cdrecord, dd) and libraries (SDL2, SharpCompress, FluentFTP, SSH.NET, AWS SDK) for platform-specific functionality. Key strengths include a consistent async progress pattern across all tools, reusable utility classes for file operations, path validation, and drag-and-drop, and deep format knowledge for retro gaming file formats. The codebase demonstrates solid engineering practices for a desktop utility, though it suffers from some monolithic view files and hardcoded data that could benefit from modularization. No unit tests are visible, and the large feature surface introduces maintenance overhead.
Watt Toolkit (Steam++) is a cross-platform desktop application that serves as a multi-functional game toolbox primarily for Steam users. The system provides network acceleration via a local reverse proxy (YARP-based) with HTTPS interception, DNS analysis, and multiple proxy modes (Hosts, System, PAC, VPN, DNS intercept). It includes plugins for Steam account switching, two-factor authenticator management (import/export/recovery), game library management, ArchiSteamFarm integration for card farming, and game tools. The architecture is a modular plugin system built with Avalonia UI, .NET, and ReactiveUI, using a multi-process IPC model for privilege separation. External dependencies include WinDivert for Windows packet interception, XunYou SDK for game acceleration, and ArchiSteamFarm for automated Steam actions. The codebase demonstrates a complex but functional architecture with significant platform-specific code and some areas of technical debt.
SnapX is a cross-platform screenshot and screen recording tool, forked from ShareX, with extensive upload capabilities to dozens of services (image hosts, file storage, pastebins, URL shorteners). It features image effects (adjustments, filters, manipulations), OCR via PaddleOCR, QR code generation/scanning, hotkey automation, and clipboard monitoring. The application is built with Avalonia UI and .NET 10, targeting Linux, Windows, macOS, and FreeBSD. It includes a CLI, a native messaging host for browser integration, and a comprehensive settings system. The codebase is in early access with many features ported from ShareX but several stubs and incomplete implementations remain, particularly in screen recording, image annotation, and some uploaders. The architecture follows a core library (SnapX.Core) with separate UI (SnapX.Avalonia) and CLI projects, using MVVM pattern and dependency injection. While functional, the project exhibits significant technical debt and incomplete feature parity with its predecessor.
OplusEdlTool is a cross-platform desktop application (Avalonia UI / .NET) for flashing, backing up, and managing Oplus (Oppo/OnePlus) Android devices in Qualcomm EDL (Emergency Download) mode. The tool provides a graphical interface for reading partition tables, backing up individual partitions, merging super partition images from JSON definitions (super_def.json), applying firmware patch files, and verifying file integrity via SHA checksums. It integrates with Qualcomm's fh_loader.exe for low-level device communication and supports Oplus-specific ROM formats (.ofp, .ops). The application stores working data in LocalApplicationData, generates XML partition reports, and includes comprehensive logging. It is bilingual (English/Chinese) and explicitly warns users about dangerous operations like flashing the persist partition.