I built Vitals, a native macOS system monitor for Apple Silicon

Sławomir S — Tue, 22 Sep 2026 19:23:45 +0000

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.

DEV Community: Sławomir S

I built Vitals, a native macOS system monitor for Apple Silicon