How winsiderss/systeminformer works
Main components
• Core Application (SystemInformer): This is the main user-mode executable that provides the graphical user interface, monitors system resources (CPU, memory, network, etc.), and interacts with various system subsystems.
• Kernel Driver (KSystemInformer): A kernel-mode component (with its own Visual Studio solution and source files) that likely facilitates low-level system monitoring, access to protected resources, and debugging information (stack traces, file locks, etc.).
• Libraries and Helper Modules: There are multiple libraries such as phlib, kphlib, and parts under “phnt” that provide core functionality (e.g., APIs for memory handling, network interfaces, and system calls). These encapsulate reusable routines that are used by both the core application and plugins.
• Plugins Framework: This project includes a large number of plugins (under the “plugins” directory) that extend and enhance functionality. Examples include ExtendedTools, ExtendedServices, OnlineChecks, NetworkTools, and more. These plugins interface with the core application to provide specialized capabilities (e.g., detailed disk/network info, advanced debug operations, etc.).
• Build and Tooling Infrastructure: There is an extensive build system based on CMake scripts, Visual Studio solutions, custom build tools (in the “tools” directory), and third-party libraries. Although not necessarily part of the runtime architecture, this infrastructure informs how the application is structured and maintained.
Relationships and interactions
• The Core Application (SystemInformer) acts as the central hub. It interacts with the Kernel Driver (KSystemInformer) to gain low-level system details.
• The core uses shared libraries (phlib/kphlib and others) to abstract system-level calls and to provide consistent functionality across modules.
• The Plugins interact with the Core Application and subscribe to specific events or extend particular diagnostics (e.g., file system monitoring or network related).
• There is a clear separation between “user mode” (the GUI application) and “kernel mode” (the driver) to safely handle monitoring and debugging tasks.
• The build system (including CMake, MSBuild solutions, and other tooling) integrates all these components during compilation and packaging.
Architectural patterns and design principles
• Modularity: The system is clearly modular. The core functionalities are decoupled from the extended plugins, which enables independent development and feature extensions.
• Separation of concerns: The UI, kernel interactions, helper libraries, and plugins have clearly demarcated responsibilities.
• Plug-in Extensibility: The design makes use of a plugin architecture, allowing features to be extended without altering the core.
• Abstraction Layers: The use of shared libraries (phlib, kphlib, etc.) reflects a layered architecture that abstracts system-level interactions from business logic.
Relevant technologies, frameworks, and libraries
• Development is in C/C++ using Visual Studio (solutions such as SystemInformer.sln and Plugins.sln).
• Build system is managed using CMake scripts and custom command-line tools located in the “build” and “tools” directories.
• The project includes third-party libraries such as Capstone for disassembly, Detours for hooking, JSON-C for JSON processing, and others – mainly used within the tool’s plugins or analysis routines.
• Windows-specific libraries and header files (especially in the “phnt” directory) are used for low-level system access.
• A group labeled “Plugins” with sub-components (ExtendedTools, ExtendedServices, NetworkTools, etc.) that interact with the core.
• From the Core Application to the Kernel Driver, illustrating the request for low-level system information.
• From the Core Application to the Shared Libraries, indicating dependency and data flow.
• From the Plugins to the Core Application to denote the plugin-based extension mechanism.