ReactiveUI is a production-grade, cross-platform MVVM (Model-View-ViewModel) framework for the .NET ecosystem. Its architecture is centered around reactive primitives (ReactiveObject, ReactiveProperty, IObservable) that form the backbone of its view model layer. The framework employs a fluent builder pattern (RxAppBuilder) for application initialization, a custom dependency injection system ('Splat'), and extensive source code generation to provide a type-safe, AOT-compatible binding and view resolution system. It abstracts platform-specific UI toolkits (WPF, WinUI, MAUI, WinForms, AndroidX, iOS/macOS UIKit, Blazor) behind a consistent set of interfaces (IViewFor<T>, IRoutableViewModel, IActivatableViewModel). The codebase demonstrates strong engineering practices, including a sophisticated reactive command pattern (ReactiveCommand), a typed message bus (MessageBus), a state persistence lifecycle (SuspensionHost), and a collection change-set streaming mechanism (ReactiveChangeSet). A significant portion of the code is dedicated to ensuring Ahead-of-Time (AOT) compilation safety, avoiding reflection where possible through generic view resolution and explicit registration, which is a non-trivial and well-executed design constraint. The repository includes extensive unit tests, platform-specific integration tests, and performance benchmarks. While the framework is actively maintained (evidenced by recent commits, low open issue count, and zero Dependabot alerts), its ambitious scope introduces inherent complexity. The reliance on a custom DI framework, conditional compilation flags (REACTIVE_SHIM), and the maintenance burden of supporting eight distinct UI platforms are notable architectural trade-offs. Despite this, the core abstractions are cleanly separated, highly reusable, and represent a high standard of craftsmanship in the .NET reactive programming space.
MahApps.Metro is a mature WPF UI library that provides a comprehensive set of custom controls, styles, themes, and helpers for building modern desktop applications with a Metro/Windows 10/WinUI aesthetic. The library offers over 30 custom controls including HamburgerMenu, ContentDialog, InfoBar, RangeSlider, NumericUpDown, ColorPicker, AutoSuggestBox, SplitView, and a full dialog system with login, input, message, and progress dialogs. It ships with three visual style sets (Metro, Win10, WinUI) and integrates deeply with the ControlzEx theming framework for runtime theme switching. The architecture is a standard .NET library with a large public API surface exposed via dependency properties, attached properties, custom behaviors, converters, and automation peers. The codebase is heavily tested (350+ NUnit tests) with a custom WindowTestFixture for UI integration tests. Sample applications (MahApps.Metro.Gallery, MahApps.Metro.Demo) demonstrate real-world usage, and project templates (dotnet new) provide scaffolding for new apps. The library also includes project templates (MahAppsMetroApp, MahAppsMetroMvvmApp, MahAppsMetroNavApp) and a Visual Studio manifest. Despite its age and large API surface, the library remains actively maintained with recent commits, issue triage, and support for .NET 6-10. Technical drift is moderate: some obsolete code (ClipBorder) and Win32 P/Invoke are present, and the three style sets must be kept in sync. The test suite is comprehensive but pixel-level and resource-key-dependent, making it somewhat brittle. Overall, this is a high-quality, production-tested UI library with strong architectural patterns and reusable components.
This repository is a comprehensive WPF UI library (WPF-UI) that implements Microsoft's Fluent Design System for Windows Presentation Foundation. It provides over 70 custom controls (NavigationView, ContentDialog, Snackbar, TitleBar, NumberBox, ToggleSwitch, etc.), a full theme management system with dynamic light/dark/high-contrast switching, Win32 interop for modern window chrome and taskbar integration, and a navigation framework with DI support. The library is distributed via NuGet and includes Visual Studio project templates. The codebase is well-structured with a folder-per-control pattern, partial classes for separation of concerns, and extensive use of dependency properties, routed events, and attached behaviors. The core library targets .NET 10/9/8 and .NET Framework 4.6.2–4.8.1, with abstractions targeting .NET Standard 2.0/2.1 for maximum compatibility. The repository also contains a comprehensive demo application (Wpf.Ui.Gallery) that showcases all controls with MVVM (CommunityToolkit.Mvvm), localization, and an embedded Monaco Editor for live code samples. Integration tests using FlaUI and unit tests for animations and symbol extensions are present. The architecture is documented with C4 diagrams and ADRs. The library is actively maintained with frequent commits, CI/CD via GitHub Actions, and responsive issue triage. While the codebase is generally high-quality, there are some work-in-progress controls (TreeGrid), deprecated APIs in ContentDialog, and vendored third-party assets (Monaco Editor) that introduce minor maintenance risks. Overall, this is a strong, production-ready UI library with clean abstractions and several reusable patterns.
This repository is a WPF control library that ports Microsoft's WinUI3 (Fluent) design language to the Windows Presentation Foundation (WPF) framework. It provides a comprehensive set of modern UI controls—such as NavigationView, CommandBar, InfoBar, TabView, SplitView, NumberBox, ColorPicker, TeachingTip, and many more—each with full theming support (light, dark, high-contrast), accessibility automation peers, and virtualized layout engines for high performance. The library is distributed as a NuGet package (ModernWpfUI) and is accompanied by a gallery demo application (ModernWpf.Gallery) that showcases all controls with live code samples. Architecture: The codebase is organized into two main assemblies: ModernWpf (base infrastructure: theme management, helpers, icon sources, animations, window chrome) and ModernWpf.Controls (all ported controls with their XAML templates, property definitions, and automation peers). Controls follow a declarative property system using DependencyProperty registration, and many leverage a recycling element factory (RecyclePool) for efficient item rendering in repeaters and lists. The library integrates with WPF's native theming via ResourceDictionaryEx and FluentControlsResources, merging platform Fluent dictionaries with custom theme resources. Key entry points: For consumers, the library is used by adding the ModernWpf.Controls assembly and referencing the namespace http://schemas.modernwpf.com/2019 in XAML. The gallery application entry point is ModernWpf.Gallery/App.xaml.cs. Test infrastructure includes ModernWpfTestApp and dedicated unit tests under test/ that use a custom WpfTestHost. External dependencies: WPF (System.Windows), .NET runtime, and Win32 native methods for window management (NativeMethods.cs). The build system supports multiple .NET targets (net462, net8.0-windows7.0, net10.0-windows7.0) with conditional compilation. The project maintains strict parity with upstream WinUI3 through source-audit tests that pin specific commit hashes and verify code patterns. This ensures the WPF port remains faithful to the original Fluent design, but also creates maintenance overhead when upstream changes. The library is in preview status (1.x release candidate) with a frozen 0.9.x line; API is not yet frozen.
WinUtil is a comprehensive Windows system administration utility delivered as a single compiled PowerShell script (winutil.ps1). It provides a WPF graphical interface for installing applications via WinGet and Chocolatey, applying registry and service tweaks, managing Windows features and AppX packages, changing DNS settings, enabling SSH, creating custom Windows 11 ISOs with driver injection, and controlling Windows Update profiles. The architecture is monolithic but modular in source: a build script (Compile.ps1) assembles the final artifact from separate function files, JSON configuration catalogs, and XAML UI definitions. Background work is handled by a job layer built on a runspace pool, with centralized progress reporting, logging, and error handling. The tool supports both interactive GUI mode and headless automation via preset/config files, making it suitable for both manual system optimization and automated deployment scenarios. While primarily an application, it includes data-driven components such as curated application catalogs and registry research encoded in JSON configuration files.
Auto Dark Mode is a Windows desktop utility that automatically switches between dark and light system themes. In production it operates as a multi-process system: a WinUI 3 settings app (AutoDarkModeApp), a background service with system tray icon (AutoDarkModeSvc running under Windows Forms Application.Run), a lightweight CLI shell for IPC commands (AutoDarkModeShell), and self-update tooling split between a legacy C# updater and two Rust components (adm-updater-rs, adm-downloader-rs). The service evaluates multiple triggers — custom time schedules, sunrise/sunset from geolocation or manual coordinates, Windows Night Light state, ambient light sensor lux readings, battery/energy saver state, GPU load, process blocklists, and system idle — then applies theme changes across Windows components: system/app theme, per-monitor wallpapers, accent color, taskbar color, cursors, touch keyboard, color filters, and user-defined scripts. UI and service communicate over named-pipe IPC with a command/response protocol; configuration persists in YAML files watched via FileSystemWatcher and WMI events. This is purely an application repository; bundled GeoJSON assets and geolocation features serve the scheduling feature, not data research. Architecturally the codebase shows genuine craftsmanship: a governors pattern (TimeSwitchGovernor, NightLightGovernor, AmbientLightGovernor) separates switch-decision logic from switch-execution, switch components (ISwitchComponent/BaseComponent) isolate individual theme pieces, a postpone manager coordinates blocking conditions (GPU, idle, processes, notifications) with expiry callbacks, and a config-update event system decouples YAML changes from feature reactions. The UI follows MVVM with CommunityToolkit, dependency injection, and 25+ localized locales. Maintenance is active with recent commits and an issue-triage workflow, but technical drift is medium: commented-out ZeroMQ code and legacy updater logic remain, updater behavior is triplicated across C# and Rust, localization coverage has drifted (many locales contain untranslated English strings), and core features depend on undocumented Windows COM interfaces (IThemeManager2) and build-version checks that may break with future Windows updates.
NETworkManager is a comprehensive Windows-based network administration and troubleshooting tool built with WPF and the MVVM pattern. It provides an integrated suite of network utilities including remote access (RDP, PowerShell, PuTTY, TigerVNC, WebConsole), network diagnostics (WiFi scanner, IP/port scanners, ping monitor, traceroute, DNS lookup), configuration tools (firewall, hosts file editor), and various network utilities (subnet calculator, bit calculator, OUI/port lookup, RDAP/Whois, IP geolocation). The application features a tabbed interface where each tool operates as a separate tab, profile-based configuration management for saving host/group settings, settings persistence with system-wide policy support, localization for 16+ languages, and data export capabilities (CSV, XML, JSON). The architecture follows clean separation of concerns with dedicated projects for Controls, Converters, Models, Profiles, Settings, Utilities, and ViewModels/View pairs.
The Windows App SDK (formerly Project Reunion) is a Microsoft platform SDK for building modern Windows desktop applications. It provides a unified set of WinRT APIs and runtime components that bridge Win32 and UWP development, enabling features like app lifecycle management (single-instance, file/protocol activation), dynamic package dependencies (resolving framework packages at runtime), rich notifications (toast, push, badge), resource management via MRT Core (PRI files with qualifier-based selection), deployment APIs (package sets, validation), environment variable management, OAuth 2.0 authentication, and interop wrappers for storage pickers and camera capture. The architecture is modular: each feature area is implemented as a separate C++/WinRT component (DLL) that can be consumed individually via NuGet packages. The SDK supports both packaged (MSIX) and unpackaged (self-contained) apps, with a bootstrap DLL that initializes the runtime and hooks into the Windows package graph via Detours. Key entry points include MddBootstrapInitialize2 for runtime initialization, the WindowsAppRuntime DLL for COM class factories, and individual component APIs like AppNotificationManager, PushNotificationManager, and PackageDependency. External dependencies include the Windows SDK, C++/WinRT projections, the Windows Implementation Libraries (WIL), and Microsoft Detours for API interception. Data flows involve inter-process communication through shared memory (for activation redirection), named pipes (for OAuth callbacks), and COM out-of-process servers (for push notification long-running tasks). The codebase is heavily instrumented with TraceLogging telemetry and uses feature flags (TerminalVelocity) to gate experimental APIs.
Nodify is a production-grade WPF library for building node-based graph editors. It provides a comprehensive set of custom controls (NodifyEditor, ItemContainer, Connector, various connection types, Minimap, GroupingNode, StateNode, etc.) along with a sophisticated input processing system based on composable state machines. The library is designed for MVVM, exposes rich command and event hooks, and supports full theming with dark/light/Nodify themes. The codebase demonstrates high craftsmanship in its input state machine pattern (InputProcessor/InputElementStateStack), undo/redo framework (ActionsHistory), gesture customization system (EditorGestures), and performance optimizations (BoxValue, connector safe-zone hit-testing). It ships with five example applications (Calculator, Playground, Shapes, StateMachine, Workflow) that showcase real-world usage patterns including sub-workflows, real-time collaboration simulation, and undo/redo. The library targets a wide range of .NET frameworks from .NET Framework 4.7.2 through .NET 10 preview, with CI builds and NuGet publishing pipelines. Despite a large API surface and some mutable global settings, the code is well-organized, extensively documented, and actively maintained.
Wabbajack is a mature .NET application for compiling and installing modlists for PC games, primarily Bethesda titles. It automates the entire modlist lifecycle: a compiler indexes a modded game folder, applies a stack of compilation steps (ignore rules, BSA decomposition, texture matching, patching), and produces a .wabbajack file containing only metadata and download instructions. An installer then runs preflight checks, downloads archives from Nexus Mods, Steam depots, Bethesda Creations, HTTP mirrors, and manual sources, verifies hashes, extracts files, and applies binary patches to reproduce the original mod setup without redistributing any assets. This is an application, not a data/research repository; the data-like components (VFS, hashing, caches) serve the application's file integrity and reproducibility needs. Architecturally it is a modular multi-project solution: a WPF desktop client (Wabbajack.App.Wpf), a System.CommandLine-based CLI (Wabbajack.CLI), and an Avalonia launcher. Core libraries provide a custom path abstraction, xxHash64 hashing, a SQLite-backed virtual file system for archive indexing, a rate limiter, a download dispatcher with pluggable downloaders, a preflight check framework, and Bethesda archive (BSA/BA2) readers/writers. Dependency injection is used throughout via per-module ServiceExtensions, and the codebase includes substantial test coverage across installer, compiler, downloader, VFS, and networking projects. External dependencies include the Nexus Mods API (OAuth2), Steam CDN/depot APIs, Bethesda's Creations API, GitHub releases for self-update, and bundled native tools (7-Zip, innoextract, texconv). The codebase is heavily Windows-oriented (WPF, P/Invoke, WMI, registry protocol handler), though some libraries are cross-platform. Maintenance is active with frequent releases, but technical drift is medium: several hardcoded API constants, reverse-engineered Steam/Bethesda endpoints, and legacy WPF UI patterns require ongoing upkeep.
PerfView is a comprehensive performance analysis and diagnostics toolkit primarily for Windows, with growing Linux support. It collects, parses, and visualizes Event Tracing for Windows (ETW), .NET EventPipe, Linux perf, and CTF traces. The repository contains a WPF desktop application (PerfView.exe) for interactive stack, memory, and heap analysis, along with command-line tools (HeapDump, TraceParserGen, perfcollect) and a reusable library (Microsoft.Diagnostics.Tracing.TraceEvent) for programmatic trace processing. The architecture is modular, with core libraries for fast serialization, stack analysis, symbol resolution, and automated analysis. While the codebase is well-maintained and extensively tested, it contains some legacy components (custom compression, duplicated utilities) and conditional compilation that indicate moderate technical drift. The library components are the most reusable assets, offering patterns for binary serialization, caching, recursion safety, and event filtering.
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.
Greenshot is a mature, feature-rich Windows screenshot tool that goes far beyond basic capture. The codebase reveals a desktop application with a hybrid WinForms/WPF UI, a comprehensive plugin architecture for integrations (Jira, Confluence, Office, cloud storage, PDF, barcode), and an advanced recipe pipeline that automates capture workflows through a DAG of conditional steps. It includes a browser extension, native messaging proxy (C++), an MCP server for AI tool integration, and video recording via Windows Graphics Capture. The architecture is modular: a base library (Greenshot.Base) provides core services (capturing, threading, configuration, effects, file format handling, recipes, OAuth), while plugins register destinations, steps, and settings views. The test suite covers core flows, recipes, IPC, and threading, but UI and plugin integration tests are limited. Despite being a .NET Framework 4.8 codebase with some older dependencies (log4net, Dapplo), the engineering is solid—clean abstractions, async patterns, and a strong emphasis on thread safety and security (deserialization whitelist, IPC validation). The recipe pipeline and plugin system are particularly well-designed, though their complexity may present a learning curve.
Text-Grab is a Windows desktop application for capturing and extracting text from screen regions, images, PDFs, and barcodes using on-device OCR (Windows OCR, Tesseract, Windows AI) and UI Automation. It provides multiple capture modes (fullscreen grab, grab frame, edit text window, quick lookup) and offers post-capture features like text editing, table analysis, unit conversion, expression evaluation, template-based extraction, text-to-speech, and clipboard integration. The application is privacy-focused as all processing runs locally. It is built as a monolithic WPF application using .NET 10 and WindowsAppSDK, with extensive unit and UI automation test coverage. The codebase is well-structured with reusable utility classes and custom controls, though some files (e.g., EditTextWindow) are very large and tightly coupled. The repository is actively maintained with recent commits, CI/CD pipelines, and dependabot integration.
UndertaleModTool is a comprehensive, open-source modding and reverse-engineering tool for GameMaker games, specifically Undertale and Deltarune. It provides a full suite of functionality: reading/writing GameMaker data files (.win, .unx, etc.) with byte-for-byte accuracy, decompiling GML VM bytecode back into human-readable GameMaker Language (GML), compiling modified GML back into bytecode, and editing all game assets (sprites, sounds, rooms, code, textures, shaders, fonts, etc.) through a Windows-only WPF GUI or a cross-platform CLI. The tool also includes a project system for exporting/importing assets as JSON and PNG, a built-in C# scripting engine for automation, and game-specific definitions that tailor decompilation and modding to Undertale and Deltarune. The architecture is a classic library-plus-front-end pattern: the core library `UndertaleModLib` handles all binary serialization, decompilation, compilation, and project management. The GUI application `UndertaleModTool` and CLI `UndertaleModCli` are thin layers that use this library. The library itself is heavily version-aware, supporting multiple GameMaker versions (GMS1, GMS2, 2022-2024) with hundreds of conditional checks. The decompiler integrates with the external `Underanalyzer` submodule for advanced GML compilation and decompilation. A large collection of built-in C# scripts covers common modding tasks (resource export/import, technical utilities, game-specific modifications). While primarily an application, the repository also serves as a living document of GameMaker's internal data format—a significant reverse-engineering effort. The code is rich with comments explaining undocumented structures, version differences, and workarounds for engine bugs. This hybrid nature makes it both a practical modding tool and a valuable research resource for understanding GameMaker internals.
BililiveRecorder is a multi-platform application for recording Bilibili (mikufans) live streams. It provides a desktop GUI (WPF), a cross-platform CLI, and a web interface (ASP.NET Core) with REST and GraphQL APIs. The core system manages room monitoring, stream capture via HTTP, danmaku (live chat) recording, and FLV file processing with a pipeline-based repair engine that fixes timestamp jumps, duplicate headers, and other stream corruption. It supports hierarchical configuration, user scripting (via embedded Jint JavaScript runtime), and webhook notifications. The application is modular: separate libraries for FLV parsing/writing (BililiveRecorder.Flv), core recording logic, toolbox utilities (fix, analyze, merge danmaku), and a web frontend with an embedded ArtPlayer-based video player. The codebase is well-structured with dependency injection, unit tests, and code generation for configuration models.
Orchestra is a mature, composable WPF application framework for building line-of-business desktop applications on .NET (net8.0-windows through net10.0-windows). It provides a complete shell infrastructure including splash screens, about dialogs, crash recovery, keyboard shortcut customization, changelog viewers, status bars, busy indicators, and recently-used item management. The framework is built on top of Catel (MVVM, IoC, logging) and integrates with Orc.* libraries for theming, controls, and system information. It offers two shell variants: a Ribbon.Fluent shell using Fluent.Ribbon for rich ribbon UIs, and a TaskRunner shell for simpler task-oriented interfaces. The architecture is modular and service-oriented, with all major features exposed via interfaces (e.g., IShellService, IStatusService, IKeyboardMappingsService) and registered through Microsoft.Extensions.DependencyInjection. The core library (Orchestra.Core) contains the foundational services, while shell-specific packages (Orchestra.Shell.Ribbon.Fluent, Orchestra.Shell.TaskRunner) provide concrete implementations. The framework also includes a shared shell library with recovery services, progress bars, and configuration management. Key entry points include the ShellService for application lifecycle orchestration and the ApplicationInitializationServiceBase for custom startup logic. External dependencies include Catel (7.x), Fluent.Ribbon (11.x), ControlzEx, and several Orc.* packages (Orc.Theming, Orc.Controls, Orc.LogViewer, Orc.SystemInfo). The build system is powered by Cake scripts with support for multiple installer formats (InnoSetup, MSIX, Velopack), code signing, and CI/CD integration. The repository also includes example applications demonstrating both shell variants and a comprehensive test suite with public API verification. Data flows are primarily user-driven: application startup triggers splash screen, configuration loading, shell creation, and keyboard mapping initialization. User interactions (closing, keyboard shortcuts, status updates) are handled through service abstractions. The framework manages local user data (configuration backups, changelog snapshots, recently used items) but does not process external datasets or analytics.
QL-Win/QuickLook is a Windows desktop application that replicates the macOS Quick Look feature: pressing the Space bar instantly previews the currently selected file in a floating overlay window, without opening a separate application. The system is built with a plugin architecture, where each file format is handled by a dedicated viewer plugin (e.g., images, PDFs, archives, code, 3D models, executable metadata). The main WPF application provides the preview window, keyboard hooks, system tray integration, and dynamic discovery of plugins. It also includes a native C++ component to retrieve the current file selection from Windows Explorer, Open/Save dialogs, and third-party file managers like Everything and Director Opus. The architecture is modular: the core library (QuickLook.Common) defines the plugin interface (IViewer, ContextObject, IMoreMenu) and shared utilities (translation, settings, helper methods). Over 30 built-in plugins each implement this interface and produce WPF UI or WebView2-based content for file preview. The system handles over 150 file formats, including compound archives, binary formats, certificate chains, minidumps, font files, Markdown/AsciiDoc, animated images (GIF, SVG, SVGA, Lottie), and even Google Chrome PAK files. Plugins can also add context menu items to invoke alternative viewers, such as viewing a PDF as text or opening a package file as an archive. Data flows: the user selects a file in Explorer, the native hook detects the focused window and retrieves the file path, the main app loads the appropriate plugin via PluginManager, passes a ContextObject to set size and title, and the plugin populates a content control (could be an ImagePanel, TextViewer panel, WebPagePanel, etc.). The preview window is displayed with acrylic/blur effects and supports fullscreen, pinning, zoom, and rotation. The user closes the preview by pressing Space again or clicking outside. The system is single-instance and communicates via named pipes for toggling and switching.
This is a cross-platform software development kit (SDK) for rendering Adaptive Cards—a JSON-based card format used by Microsoft products like Teams, Outlook, and Cortana. The repository provides a shared C++ object model for parsing and serializing card definitions, along with platform-specific renderers for Android, iOS, UWP (WinUI), .NET (WPF), and Node.js. It also includes a templating engine for dynamic data binding, a visual designer tool, and multiple test applications. The architecture is a library/framework model: each platform has its own rendering layer that converts the parsed card model into native UI components. The codebase is large and well-organized, with clear separation between the shared model and platform implementations. However, feature parity across platforms is incomplete (e.g., v1.5 features are missing in .NET renderer), and there is significant duplication of logic across platforms, which introduces maintenance risk.
OsEngine is a comprehensive, multi-exchange algorithmic trading platform for desktop (WPF/WinForms hybrid). It provides data downloading (OsData), backtesting (OsTester), walk-forward optimization (OsOptimizer), and live trading (OsTrader) with support for 30+ exchange connectors (MOEX, Binance, Bybit, OKX, Interactive Brokers, etc.). The platform includes a built-in technical indicator library (100+ indicators), a trading robot framework with attribute-based registration, and an MCP (Model Context Protocol) API for external AI/automation control. The architecture is modular: separate executables for different modes, a common server abstraction layer, and a consistent parameter system for bots and indicators. While the codebase is large and well-organized, it suffers from significant duplication across exchange connector entity classes and some copy-paste logic in trading robots. The UI mixes WPF and Windows Forms, and some patterns are legacy. Overall, it is a production-grade algorithmic trading platform with strong engineering practices and a rich feature set.