HardwareMon is a system monitoring tool designed to provide real-time insights into hardware information and performance metrics on both Linux and Windows operating systems. It offers a user-friendly interface for tracking essential components such as CPU usage, memory consumption, disk activity, GPU performance, network statistics, and overall system health.
Key Features:
Real-time monitoring of hardware metrics with an intuitive graphical interface.
Support for multiple platforms, including Linux (via APT and DNF repositories) and Windows (via winget).
Detailed insights into CPU load, memory usage, disk I/O, GPU temperature and utilization, and network traffic.
Command-line interface for advanced users seeking deeper system inspection.
Audience & Benefit:
Ideal for IT professionals, system administrators, developers, and hardware enthusiasts who need a lightweight yet powerful tool to monitor system performance and diagnose issues efficiently. HardwareMon provides clarity and simplicity without compromising on functionality, making it an essential tool for maintaining optimal system operation.
README
HardwareMon
Modern system monitoring for Android, Linux, macOS and Windows.
Real-time hardware analytics, a native Android dashboard, historical analytics via SQLite, cinematic desktop UI,
native Linux packaging, Windows installers, automated repositories, and bundled desktop telemetry architecture.
HardwareMon is a modern system monitor for Android, Linux, macOS and Windows. The desktop application uses Flutter and FastAPI, while Android has a native Kotlin and Jetpack Compose application that monitors the phone or tablet directly.
HardwareMon processes monitoring and benchmark information locally. See the
Privacy Policy for details.
Telemetry-derived health scoring with performance, memory, thermal, power,
battery, and storage signals where each platform exposes them
Balanced, Performance, Quiet, Efficiency, and Reliability monitoring lenses
Local session journals for capturing useful baselines and workload snapshots
Bottleneck detection, trend observations, and explicit unavailable states
Shareable or copyable session reports with no automatic upload
Configurable watch thresholds and de-duplicated event history
Benchmark Mode
HardwareMon includes a lightweight local benchmark for CPU single-thread and
multi-thread performance, memory throughput, and temporary-file disk read/write
performance. Runs happen in the background, can be cancelled, require no
administrator or root privileges, and save comparison-ready results locally.
Scores are HardwareMon benchmark scores and are not comparable with Geekbench,
Cinebench, or other benchmark suites. Compare runs using the same benchmark
version and similar conditions; thermals, power mode, battery state, and
background activity can all affect results.
Completed runs include an offline comparison view with percentile, matching
hardware averages, ranking statistics, performance insights, and score charts.
Comparisons can be filtered by identical CPU, CPU + GPU, CPU family, platform,
or all version-compatible results stored locally.
Online comparison is designed as an optional provider and is not connected in
this release. HardwareMon never uploads a result automatically; after a run it
asks for explicit anonymous-submission consent, and the application continues
to work fully offline. The future cloud request/response and privacy contract is
documented in docs/benchmark-cloud-api.md.
Gaming Mode
Gaming Mode automatically watches the local process list for known game
executables, starts a session when a game launches, samples existing
HardwareMon telemetry while the game is running, and finishes the session when
all detected game processes exit.
Completed sessions are stored locally in SQLite with duration, platform,
HardwareMon version, average CPU/GPU/RAM usage, CPU/GPU temperatures, peak
temperatures, peak RAM/GPU/CPU usage, CPU clock, CPU/GPU power, and sample
counts. The desktop Gaming page includes a live recording view, session
history, full session details, and aggregate statistics such as most played
game, longest session, total gaming hours, average session length, hottest
recorded session, games played, and largest CPU/GPU usage.
The game catalog lives in hardwaremon_app/backend_fastapi/gaming/games.json
so new games can be added without changing detector code. Game artwork is an
intentional placeholder in this release and is ready for future asset
integration.
Plugin Studio
HardwareMon includes an out-of-process plugin platform with explicit capability
approval, authenticated IPC, lifecycle supervision, crash recovery, health and
logs, portable-aware persistence, and staged .hmp installation. Official
Prometheus Exporter and Developer Tools plugins ship disabled and require the
same review as third-party extensions.
Plugin authors can use the dependency-free Python SDK and package builder under
hardwaremon_app/plugin_sdk. The manifest, protocol, security boundary and
development workflow are documented in docs/PLUGIN_SYSTEM.md.
Card Workspaces
Card-based analytics can be reordered, resized or hidden independently on each
page. Named layouts capture the entire app configuration and can be switched
from any workspace toolbar or Ctrl+K. See
docs/CARD_WORKSPACES.md for the interaction and
persistence model.
Gaming overlay
Gaming includes global overlay hotkeys, click-through desktop telemetry, a
substantially larger executable catalogue, official Steam artwork when
available, and a real external frame-statistics bridge. See
docs/GAMING_OVERLAY.md for platform capabilities and
collector integration.
Distribution & Packaging
Native Linux DEB packages
Native Linux RPM packages
APT repository support
DNF repository support
Windows installer support
WinGet support
Signed Android APKs with SHA-256 checksums
GitHub Releases automation
Every release workflow publishes SHA-256 checksums, human-readable release
metadata, and GitHub artifact attestations. Desktop releases also publish a
CycloneDX SBOM for the Flutter and Python dependency sets they ship. See
Verifying a HardwareMon release
for beginner-friendly checksum, provenance, SBOM, and platform-signing guidance.
Why HardwareMon?
Most system monitoring tools either focus on raw data or dated interfaces.
HardwareMon aims to combine real-time telemetry, historical analytics, modern desktop design, and native Linux/Windows distribution into a single application.
Feature
HardwareMon
Task Manager
Htop
CPU Monitoring
✅
✅
✅
Historical Analytics
✅
❌
❌
Process Management
✅
✅
✅
Modern UI
✅
⚠️
❌
Linux Package Repositories
✅
❌
❌
Windows Installer
✅
Built-in
❌
HardwareMon Evolution
HardwareMon originally began as a small Python/Tkinter hardware monitor created during early experimentation with Linux system telemetry.
The project has since been completely rebuilt into a modern cross-platform monitoring platform using:
Flutter Desktop
FastAPI
LibreHardwareMonitor
Real-time telemetry APIs
Automated CI/CD pipelines
Native Linux packaging
Windows installer infrastructure
The legacy Tkinter interface and older Python GUI implementations have now been fully removed from the project and are no longer maintained.
HardwareMon now uses a unified Flutter frontend architecture across Linux and Windows with a bundled backend system for telemetry collection and process analytics.
Platform Support
Platform
Status
Distribution
Windows
✅ Supported
Installer / WinGet
Ubuntu / Debian
✅ Supported
APT
Fedora
✅ Supported
DNF
Flatpak
⚠️ Experimental
Flatpak
Arch Linux
🚧 Planned
AUR
macOS
✅ Apple Silicon only
DMG from Github Releases
Android
✅ Supported
Signed APK from GitHub Releases
Installation
Windows
WinGet
winget install LouisHinchliffe.HardwareMon
When launching HardwareMon, be sure to click 'Yes' to any UAC prompts for LibreHardwareMonitor.exe, to ensure full functionality like process management and temperature monitoring.
The app will still function if you choose 'No', as the app will then fall back to psutil for analytics, but choosing 'No' is not recommended due to LHM being required for some features.
As mentioned above in the Winget install method, when launching HardwareMon be sure to click 'Yes' to any UAC prompts for LibreHardwareMonitor.exe, to ensure full functionality like process management and temperature monitoring.
The app will still function if you choose 'No', as the app will then fall back to psutil for analytics, but choosing 'No' is not recommended due to LHM being required for some features.
sudo tee /etc/yum.repos.d/hardwaremon.repo > /dev/null < Current macOS CI builds are consistently ad-hoc signed and are not yet
> Developer ID signed or notarized. After downloading, macOS may require
> **Right-click → Open** and confirmation on first launch.
| Area | Current macOS support |
|------|-----------------------|
| Dashboard | Working with capability-aware cards; unavailable sensors are omitted |
| CPU usage and name | Supported, including Apple M1/M2/M3/M4 names when reported |
| RAM used/available/total | Supported |
| Disk and network | Supported through the existing cross-platform collectors |
| MacBook battery | Supported when macOS reports a system battery |
| Temperatures, fans, and power | May be unavailable; never estimated or replaced with fake zero values |
| Processes | Viewing is experimental; termination is disabled on macOS |
| Historical monitoring | Supported for metrics macOS reports |
| Notifications | Supported subject to macOS notification permission |
| DMG launch | Supported on real Apple Silicon Mac hardware |
| Virtual machines | Not recommended unless the VM exposes a working Metal device |
Apple Silicon identifies hardware differently from Windows and Linux, process
control is more restricted, and several sensors need privileged/native
integrations that HardwareMon intentionally does not request today. Flutter
also requires Metal on macOS: a VM may boot macOS successfully yet show a blank
Flutter window when no Metal device is available. A real Mac is recommended for
release testing.
| Architecture | Support |
|--------------|---------|
| Apple Silicon (M1) | ✅ |
| Apple Silicon (M2) | ✅ |
| Apple Silicon (M3) | ✅ |
| Apple Silicon (M4) | ✅ |
| Intel (x86_64) | ❌ |
> Tested on Apple Silicon hardware. Intel Mac support is planned for a future release.
# Android
HardwareMon for Android is a native, standalone monitor for the phone or tablet it runs on. It starts collecting local telemetry as soon as it opens and does not require an account, server, or root access.
The dark Jetpack Compose dashboard provides:
* Live CPU usage when the device exposes it
* RAM usage with used, available, and total memory
* Internal storage usage with used, available, and total capacity
* Battery percentage, charging state, temperature, voltage, and health
* Wi-Fi or mobile connection state, local IP, and Wi-Fi link speed when available
* Android thermal-pressure status on supported versions
* Model, manufacturer, Android version, SDK level, device name, ABIs, and uptime
* Foreground-only live refreshes with clear unavailable states for restricted metrics
* Overview, Insights, and Watches areas with a persistent bottom navigation surface
* Five monitoring lenses that change health-score weighting without changing OS settings
* A rolling 60-sample session, session-drift analysis, and local snapshot journal
* Configurable CPU, memory, storage, battery, and thermal-pressure watches
* Native share-sheet export for live and saved session reports
Android limits access to some low-level hardware information. HardwareMon reports only values exposed by public platform APIs or readable system interfaces; it does not estimate hidden sensor values. CPU utilization, thermal details, Wi-Fi information, and some battery fields can therefore be unavailable on particular Android versions or manufacturer builds.
See [android/README.md](android/README.md) for architecture, build instructions, and a detailed API-limitations guide.
# Updating
## Windows
```powershell
winget upgrade LouisHinchliffe.HardwareMon
Ubuntu / Debian
sudo apt update
sudo apt upgrade hardwaremon
Fedora
sudo dnf makecache --refresh # refreshes repository data, needed for updating on DNF
sudo dnf upgrade hardwaremon
Modern Architecture
HardwareMon now uses a fully modular frontend/backend architecture.
Frontend Layer
Built entirely with Flutter Desktop:
Windows support
Linux support
Shared UI codebase
Animated workstation-style interface
Realtime telemetry rendering
Expandable analytics views
Multi-page navigation system
Cross-platform desktop framework
Backend Layer
Built using FastAPI and Python telemetry services:
Hardware telemetry APIs
Process monitoring
System analytics
Temperature monitoring
Live metric streaming
Process security scanning
JSON-based telemetry endpoints
The backend is bundled directly with release builds and automatically launched by the Flutter application.
Android Layer
Built with modern Android technologies:
Kotlin and Jetpack Compose
Material 3-inspired HardwareMon dashboard
State-driven ViewModel architecture
Dedicated CPU, memory, storage, battery, network, thermal, and device collectors
Foreground-aware refresh scheduling
Permission-light, root-free local monitoring
Responsive phone and tablet layouts
Legacy Components
The following legacy components have been removed:
Tkinter GUI
Older Python desktop interfaces
Legacy launcher systems
Previous monolithic UI architecture
Any remaining issues, references, or deprecated code related to these legacy systems are considered unsupported and may be ignored during development moving forward.
CI/CD Infrastructure
HardwareMon uses a dedicated GitHub Actions workflow for macOS release builds.
Tags matching v*.*.* build the Flutter app and bundled FastAPI helper on a
GitHub-hosted Mac, apply a final deep ad-hoc signature to the completed app,
validate all embedded frameworks, create and verify the DMG, and upload it to
the matching GitHub Release. Developer ID signing and notarization are deferred
until a real Apple Developer certificate is available. See the
macOS release guide for current behavior.
The existing GitHub Actions pipelines continue to handle:
Linux DEB packaging
Linux RPM packaging
Windows installer generation
WinGet publishing
Signed Android APK packaging and verification
Non-macOS GitHub Release assets
Cloudflare Pages deployment
Repository metadata generation
Technologies used include:
Flutter Desktop
FastAPI
PyInstaller
GitHub Actions
nfpm
Cloudflare Pages
Development
Clone Repository
git clone https://github.com/louisboii747/HardwareMon.git
cd HardwareMon
Flutter Development
cd hardwaremon_app
flutter pub get
uvicorn main:app --reload
flutter run -d windows
Linux:
flutter run -d linux
Backend Development
cd backend_fastapi
pip install fastapi uvicorn psutil
uvicorn main:app --reload
Android Development
Open the android/ directory as a standalone project in Android Studio, or use JDK 17 and an Android SDK from the command line:
cd android
.\gradlew.bat testDebugUnitTest lintDebug assembleDebug
The APK is produced at android/app/build/outputs/apk/debug/app-debug.apk from the repository root. Full Android architecture and API-limit documentation lives in android/README.md.
Roadmap
Planned future improvements include:
System tray integration
Custom dashboard layouts
Plugin architecture
Detachable analytics windows
Native macOS exploration
Android
Planned improvements include:
Home screen widgets
Material You theming
Optional notification delivery for foreground watch events
Longer-term historical analytics beyond the current foreground session
Wear OS support
Quick Settings tile
Battery-conscious background sampling
Project Status
HardwareMon is under active development.
The project is evolving into a modern cross-platform monitoring platform focused on:
performance
desktop experience
native Android monitoring
packaging automation
scalable architecture
cinematic UI design
real-time telemetry systems
Contributing
Contributions will always be welcome to HardwareMon. Feel free to create a feature request in Issues, or submit a PR! I'd love to see your changes, fixes or ideas!
