I recently open-sourced Vitals, a native system monitor for macOS focused on Apple Silicon.
The project started because I wanted one place where I could inspect much more of what the Mac is actually doing than Activity Monitor exposes — CPU clusters, GPU, Neural Engine, SMC sensors, disks, power usage, network interfaces and processes.
I also wanted to keep it fully native.
No Electron, no web UI, no telemetry and no third-party monitoring libraries.
GitHub:
https://github.com/slawek19926/Vitals
"Vitals summary"
Architecture
The application is split into two main layers.
The UI and application logic are written in Swift and AppKit.
The low-level monitoring layer is written in C++17 and exposes a plain C API to Swift.
Under the hood, Vitals uses several macOS facilities directly:
- "libproc"
- Mach APIs
- "sysctl"
- IOKit
- AppleSMC
- IOReport
- XPC for the optional privileged helper
I deliberately avoided external dependencies because I wanted to understand what macOS itself exposes and keep the resulting application small and native.
Apple Silicon power monitoring
One of the more interesting parts was power monitoring.
Where available, Vitals subscribes to IOReport's "Energy Model" channels.
It takes successive samples, calculates the delta between them and divides the reported energy delta by the actual elapsed time:
"power = energy_delta / elapsed_time"
This provides subsystem power readings for channels such as:
- CPU
- GPU
- ANE
- DRAM
- video encode/decode engines
- ISP
- display
There is no additional moving averaging at this layer. The application samples the more expensive power path roughly once per second and briefly keeps the last valid value if a sample is temporarily unavailable.
The complication is that on newer macOS versions some Energy Model counters are restricted or appear frozen for third-party processes.
For those cases, Vitals has an optional privileged XPC helper.
The helper runs Apple's own "powermetrics" tool and passes CPU, GPU and Neural Engine power readings, as well as P-core, E-core and GPU frequencies, back to the main application.
The main Vitals process itself still runs as the normal logged-in user.
SMC sensors
SMC monitoring is separate from IOReport.
Vitals opens the "AppleSMC" service through IOKit and enumerates the available SMC keys.
It currently groups readings such as:
- temperatures
- power
- voltage
- current
- fans
The exact set of keys depends on the Mac model and firmware, which is one of the reasons I'm interested in testing the application across different generations of Apple Silicon hardware.
"SMC sensors" 
Processes
The process monitor uses macOS process APIs rather than parsing output from command-line tools.
Vitals shows a PPID-based process tree with metrics including:
- CPU usage
- memory usage
- thread count
- disk reads and writes
- wakeups
- context switches
- energy impact
The optional helper also allows Vitals to retrieve information that macOS normally restricts when inspecting processes belonging to other users.
"Process monitor"
Apple Silicon view
Vitals also exposes Apple Silicon-specific information in one place.
That includes P/E CPU clusters, GPU information, Neural Engine information and media-engine capabilities.
"Apple Silicon view"
More than a menu bar monitor
I like tools such as Stats and MenuMeters, but Vitals is intended to cover a somewhat broader use case.
It currently includes:
- per-core CPU monitoring
- GPU and Neural Engine monitoring
- SMC sensors
- physical disk information and SMART
- per-interface network monitoring
- process monitoring
- disk-space analysis with a treemap
- system health checks
- alerts
- CPU benchmarks
- memory benchmarks
- disk benchmarks
- Metal GPU benchmarks
- configurable menu-bar modules
- floating desktop monitoring panels
There is also a Polish and English interface, and the language can be changed without restarting the app.
Privacy
Vitals does not collect or transmit telemetry.
The only network request made by the application is the optional check for the latest GitHub release, and that can be disabled.
There is no user account and no backend service.
Current limitation
There is one important limitation at the moment.
The downloadable release is not yet notarized because I currently don't have an Apple Developer Program membership.
The source code is public, so anyone can inspect it or build the application locally with Xcode.
Getting proper signing and notarization is one of the next things I want to solve because it would make installing the downloadable builds much smoother.
Open source
Vitals is licensed under GPLv3.
The repository includes the full Swift and C++ source code, build scripts, screenshots and downloadable releases:
https://github.com/slawek19926/Vitals
I'm especially interested in feedback from people using different Apple Silicon Macs.
SMC key mappings and some telemetry channels vary between machines and macOS versions, so reports from M1, M2, M3 and M4 hardware are particularly useful.
If you're interested in macOS internals, Apple Silicon monitoring or native AppKit development, I'd also be very interested in code review and technical feedback.
