An animated Windows system monitor that combines native OS counters, hardware sensor APIs, and a custom kernel telemetry channel in one polished Avalonia desktop interface.
Built with C# / .NET 10, Avalonia UI, LibreHardwareMonitor, WMI, SQLite, and the bundled ExteraMonitorDriver source.
"System telemetry should be accurate enough to trust and clear enough to understand at a glance."
The overview keeps the important signals visible without turning the desktop into a wall of numbers. CPU load and temperature share one system-pulse card, GPU data comes from the hardware stack with an NVIDIA driver fallback, and disk activity is kept separate from occupied capacity.
Light theme
The application does not reveal the dashboard after an arbitrary delay. Its animated boot sequence waits for two consecutive complete samples and verifies:
- the
ExteraMonitorDrivertelemetry channel; - CPU temperature plus GPU load and temperature sensors;
- CPU core, memory, storage, and process counters.
If a source is still initializing, the boot screen stays visible and reports the exact stage instead of presenting empty dashboard values.
- Live CPU telemetry — total and per-core load, package temperature, effective clocks, power, voltage, limits, and frequency distribution
- GPU monitoring — load and temperature through LibreHardwareMonitor with
nvidia-smifallback - Honest storage metrics — capacity usage, active time, and current read/write throughput are displayed as separate measurements
- Two complete themes — a calm original light palette and a purpose-built dark palette
- Animated interface — direction-aware vertical navigation, responsive card hover states, and an animated code-native Extera mark
- Modular CPU workspace — draggable, resizable, styled telemetry cards with persisted layouts
- Local history — lightweight SQLite persistence for samples, themes, accents, and widget configuration
- Desktop overlay — compact always-on-top telemetry for use outside the main window
- Built-in visual capture mode — deterministic UI screenshots for design verification
┌─────────────────────────────────────────────────────────────┐
│ Avalonia Presentation │
│ Command Center · CPU Workspace · Sensors · Overlay · Theme │
└───────────────────────────┬─────────────────────────────────┘
│ SystemSnapshot
┌───────────────────────────┴─────────────────────────────────┐
│ Metrics Aggregation │
│ CPU cores · RAM · disks · network · processes · uptime │
└───────────────┬───────────────────┬─────────────────────────┘
│ │
┌───────────────┴────────────┐ ┌───┴─────────────────────────┐
│ Windows Native Sources │ │ Hardware Sources │
│ NT counters · WMI · IP │ │ Extera driver · LHM · NVAPI │
└────────────────────────────┘ └─────────────────────────────┘
│ │
└──────────┬────────┘
▼
SQLite history and settings
AvaloniaPanel/
├── Driver/ # ExteraMonitorDriver C source and local runtime bundle
├── Models/ # Immutable snapshots and saved configuration models
├── Services/ # Native counters, sensors, driver loader, SQLite history
├── ViewModels/ # Dashboard state and module logic
├── Views/
│ ├── Controls/ # Gauges, graphs, color picker, animated Extera logo
│ └── Modules/ # Overview, CPU, memory, storage, network, sensors…
├── App.axaml # Semantic light/dark palette and shared motion styles
└── ExteraMonitor.csproj
Each release contains two Windows x64 packages:
- Installer — installs into Program Files and creates Start menu and optional desktop shortcuts.
- Portable ZIP — extract the complete folder anywhere and run
ExteraMonitor.exe; no installation or separate .NET runtime is required.
The installer adds Extera Monitor to the Windows Start menu and enables a desktop shortcut by default. While running, closing the main window keeps monitoring active in the system tray; use the tray menu to reopen the dashboard, pause/resume sampling, or exit completely.
Both variants request administrator access when launched because the hardware telemetry driver must be loaded.
| Component | Current support |
|---|---|
| Operating system | Windows 11 x64; Windows 10 x64 builds capable of running .NET 10, with LTSC/Enterprise being the currently supported Microsoft configurations |
| CPU architecture | x64 only |
| Full kernel CPU telemetry | AMD Family 19h processors (Zen 3 / Zen 4) |
| Extended SMU power, voltage and clock telemetry | AMD Raphael, Family 19h Model 61h; verified on Ryzen 5 7500F |
| GPU telemetry | NVIDIA and AMD GPUs exposed through LibreHardwareMonitor; NVIDIA also has an nvidia-smi fallback |
| Windows 7 / 8.1 | Not supported by .NET 10 |
| ARM64 / x86 | No release package or compatible bundled driver yet |
The interface and standard Windows counters can support more hardware, but this release intentionally waits for its driver and required CPU/GPU sensor channels during startup. Systems outside the full-kernel matrix are therefore not claimed as fully supported yet.
- Windows 10 or Windows 11
- .NET 10 SDK
- Administrator access when loading the kernel driver
- A compatible
ExteraMonitorDriver.sysruntime build for driver telemetry
git clone https://github.com/DeFexNN/extera_system_monitor.git
cd extera_system_monitor
dotnet restore
dotnet runThe UI and standard Windows/LibreHardwareMonitor sources build without checked-in driver binaries. For the complete driver path, place the locally built ExteraMonitorDriver.sys and its loader runtime in Driver/; the project copies available runtime files into the output directory automatically.
.\Packaging\Build-Release.ps1 -Version 0.2.7The packaging script creates a compact installer, a self-contained portable ZIP, and a SHA-256 checksum file in artifacts/. If .NET 10 is not already installed, the installer shows download progress while fetching its runtime from Microsoft, then displays the runtime installer. Inno Setup 6 is required when building locally.
Every push and pull request also runs the Build Windows installer workflow. Download its installer, portable ZIP, and checksums from the workflow run's Artifacts section. Each push to master also updates the latest master prerelease. The installer removes the previous installed copy and its leftover files before writing the complete new package into the selected install directory. It downloads the Microsoft .NET 10 runtime during setup only when it is missing, with visible progress; an internet connection is needed in that case. The portable ZIP stays self-contained and works offline. Both packages include kvc.exe, kvc.dat, and ExteraMonitorDriver.sys together in the Driver/ folder so the loader can access them.
On Windows, enable local automatic builds for each commit and merge with git config core.hooksPath .githooks. The hooks run the same release script and place the installer, portable ZIP, and checksums in artifacts/.
Driver startup diagnostics are written to %LOCALAPPDATA%\Extera Monitor\Logs\driver-startup.log (the current log rotates at 2 MB). The log records the Windows/elevation context, bundled file presence and SHA-256 hashes, KVC exit code and output, service state, device open result, and sensor IOCTL status. If KVC does not start the service, the failure report also captures HVCI/Memory Integrity, VBS, hypervisor presence, Hyper-V optional-feature state, vulnerable-driver blocklist configuration, and WDAC/Kernel Code Integrity enforcement and active policy files. Short stage updates are sent to Telegram chat 1424672248 when a bot token is configured on that computer; the full log is attached after a failed startup or the first successful sensor read.
Before any KVC driver load or reload, Extera Monitor checks Windows Device Guard. If HVCI / Memory Integrity is reported as running, it skips KVC entirely, displays instructions to disable HVCI and restart the PC, and saves/sends the security diagnostics.
During normal startup, if KVC does not bring the service to RUNNING within 10 seconds, Extera Monitor displays a diagnostic window, writes KVC stdout/stderr and the security snapshot to the log files, and exits with code 1 when the window is closed.
If the driver fails to start, a normal launch from the Start menu displays the security snapshot and KVC output in a diagnostic window. The report is also saved under %LOCALAPPDATA%\Extera Monitor\Logs; use Open logs folder to view or share it.
To enable Telegram updates, create a bot with Telegram's @BotFather and send /start in its private chat. Local development reads .env or the EXTERA_TELEGRAM_BOT_TOKEN environment variable. Local release builds embed the token found in .env, and trusted GitHub builds embed the repository Actions secret named EXTERA_TELEGRAM_BOT_TOKEN; fork pull-request builds intentionally do not receive it. As a result, a release installer or portable ZIP can send diagnostics from another computer without configuring a token there.
The app sends driver status updates directly to Telegram while it is running; it does not need a separate publicly hosted bot server. An embedded token can be extracted from a distributed executable, so anyone who receives that build may be able to use the bot token. Only embed a bot token in builds shared with people you trust, and rotate it through @BotFather if a build is shared more widely than intended. Never commit the raw token to the repository.
The application includes a RenderTargetBitmap capture path used to verify the real running Avalonia UI:
ExteraMonitor.exe --capture overview.png --capture-section Overview --capture-dark
ExteraMonitor.exe --capture startup.png --capture-section Overview --capture-dark --capture-loadingThe startup capture waits for verified telemetry, while the regular capture waits until the boot overlay has completed.
| Layer | Technology |
|---|---|
| Desktop UI | Avalonia 12, XAML, custom-drawn controls |
| Runtime | .NET 10 / C# |
| CPU and GPU sensors | ExteraMonitorDriver, LibreHardwareMonitor, NVIDIA SMI |
| Windows telemetry | NT system calls, WMI performance classes, .NET diagnostics |
| Persistence | Microsoft.Data.Sqlite |
| Motion | Avalonia page transitions, brush/transform transitions, 60 FPS logo control |
| Packaging | Self-contained win-x64 publish, Inno Setup installer, portable ZIP |
Extera Monitor is a Windows systems-programming and telemetry project. The driver source and low-level monitoring code are intended for development, hardware research, and controlled lab environments.
"See the signal. Trust the source." creds to: https://github.com/wesmar/kvc