MacPulse — CPU & GPU Monitor for macOS

MacPulse is a free, open-source CPU and GPU monitor for macOS. It shows processor usage, graphics activity, memory, temperature, clocks, fan speed, and available power telemetry from the menu bar and native desktop widgets.

It is a lightweight Swift and SwiftUI system monitor for Apple Silicon Macs, Intel Macs, and compatible accelerated Hackintosh systems. MacPulse has no analytics, no advertisements, no account, and no background network requests.

Download MacPulse 2.1.2 for macOS (.dmg)
_{Universal application for Apple Silicon and Intel Macs · macOS 13 or newer}

Install MacPulse

1. Download

Click Download MacPulse 2.1.2 (.dmg). If the download does not start, open the v2.1.2 release page, expand Assets, and select MacPulse-2.1.2.dmg.

2. Install

1. Open the downloaded MacPulse-2.1.2.dmg file.
2. Drag MacPulse.app onto the Applications shortcut.
3. Open the Applications folder in Finder.

3. Open it for the first time

This release is built without a paid Apple Developer certificate. macOS may block a normal double-click even though the published file matches the verified source build.

1. In Finder, Control-click or right-click MacPulse.app.
2. Choose Open.
3. Choose Open again in the confirmation dialog.
4. Look for the MacPulse gauge icon in the menu bar.

You only need the Control-click procedure on the first launch. For additional confidence, compare the downloaded file with the SHA-256 checksum on the release page.

Important

Installable Mac binaries are published as GitHub Release assets, not under Packages. GitHub Packages provides registries for formats such as npm, Maven, NuGet, RubyGems, and containers; it is not a generic DMG download area. The verified MacPulse DMG is attached directly to the release above.

Use MacPulse

View live CPU and GPU activity

Click the MacPulse icon in the menu bar. The dashboard shows the data currently exposed by your Mac, including:

• CPU and GPU usage;
• recent CPU and GPU activity;
• memory usage;
• GPU temperature, clocks, fan speed, power, and memory when the active driver exposes them;
• system and component power fields when macOS provides reliable values.

Not exposed means that macOS or the active hardware driver does not publish that measurement. MacPulse does not invent missing values.

Add a Mac desktop widget

1. Control-click or right-click an empty area of the desktop.
2. Choose Edit Widgets.
3. Search for MacPulse.
4. Choose Overview, CPU, or GPU.
5. Select a size and place the widget on the desktop.

The menu-bar dashboard is the live view. macOS controls WidgetKit refresh timing, so desktop widgets update periodically rather than every second.

Change settings

Open the menu-bar dashboard and click Settings…. You can control startup behavior, menu-bar labels, visual smoothing, sampling policy, GPU selection, displayed fields, and widget synchronization.

Build MacPulse from source

Building from source requires macOS 13 or newer, Xcode 15 or newer, and the Xcode command-line tools. A paid Apple Developer account is not required for a local build.

Easiest method

1. Download the repository with Code → Download ZIP, then extract it.
2. Open the extracted macpulse folder.
3. Double-click Build and Install MacPulse.command.
4. Allow Terminal to run the script if macOS asks.
5. Wait for MacPulse was installed and opened.

To create your own DMG, double-click Build and Create DMG.command. The result is written to the dist folder.

Terminal method

git clone https://github.com/vluncasu/macpulse.git
cd macpulse
./scripts/doctor.sh
./scripts/build-local.sh
./scripts/install-local.sh

For a complete local build and DMG:

./scripts/build-and-package.sh

See Building for signing options and troubleshooting.

Screenshots

The interface is shown in its normal usage order: first the live menu-bar dashboard, then the desktop widgets. These are real captures from an Intel/AMD test system; available fields and numeric values depend on the Mac and the telemetry exposed by its active macOS drivers.

Menu-bar dashboard

Live overview CPU, GPU, power, history, and CPU composition.	Detailed telemetry Memory, temperature, clocks, fan, power, and GPU memory when exposed.

Desktop widgets

Standard appearance Compact CPU, GPU, memory, temperature, and freshness state.	Tinted appearance The same information adapted to the selected desktop treatment.

View all WidgetKit layouts

Overview family Small, medium, and large layouts.	Focused metrics Dedicated CPU and GPU layouts.

Settings

Every settings surface is included below. The captures are cropped to the application window and exclude unrelated desktop, account, browser, and file information.

General Startup, menu-bar display, labels, and monitoring controls.	Appearance Visual response, dashboard fields, and history duration.
Sampling Adaptive profile, Low Power Mode, GPU selection, and effective policy.	Widgets Synchronization, included families, and desktop setup.
Compatibility Hardware metadata, telemetry providers, power fields, and diagnostics.	About Privacy principles, project links, defaults, and license.

1. Scope

MacPulse has four defined functions:

1. sample CPU utilization from public Mach host statistics;
2. sample GPU telemetry from properties published by macOS graphics drivers in IORegistry;
3. present telemetry in a menu-bar dashboard and WidgetKit widgets;
4. adapt sampling frequency according to interface visibility, system activity, Low Power Mode, and thermal state.

MacPulse is a read-only monitor. It does not modify fan curves, frequencies, voltages, power limits, drivers, kernel extensions, or firmware settings.

2. Supported systems

The application targets macOS 13 or newer and builds as a universal binary for arm64 and x86_64.

Platform	CPU activity	GPU activity	Extended GPU fields	Power fields
Apple Silicon Mac	Supported	Driver-dependent through AGXAccelerator	Driver-dependent	Battery total where exposed; other fields may be unavailable
Intel Mac with Intel graphics	Supported	Driver-dependent through IOAccelerator	Driver-dependent	Battery total where exposed
Intel Mac with AMD graphics	Supported	Commonly exposed through IOAccelerator	Temperature, clocks, fan, power, and VRAM may be exposed	GPU power may be exposed by the driver
Accelerated Hackintosh	Supported	Depends on native macOS graphics acceleration	Depends on the active driver and injected properties	Hardware- and driver-dependent
macOS virtual machine	Supported	Only when the hypervisor exposes a compatible accelerated service	Hypervisor-dependent	Usually unavailable
Unaccelerated framebuffer	Supported	Unavailable	Unavailable	Usually unavailable

Compatibility means that MacPulse can consume telemetry already published by macOS. It does not enable unsupported graphics hardware.

3. Measurement definitions

3.1 CPU utilization

CPU utilization is computed from consecutive HOST_CPU_LOAD_INFO samples.

For two consecutive observations:

active = delta(user) + delta(system) + delta(nice)
total  = active + delta(idle)
CPU utilization = 100 * active / total

User and system components are retained separately. The displayed value is filtered for visual stability; the unfiltered value remains available in the internal snapshot.

3.2 CPU load average

The one-, five-, and fifteen-minute load averages are obtained from the operating system. They represent runnable and uninterruptible work relative to time. They are not percentages and are not normalized by logical processor count.

3.3 GPU utilization

The GPU reader enumerates AGXAccelerator and IOAccelerator services through IOKit. It searches nested driver dictionaries for documented and commonly published property names, including:

Device Utilization %
Device Utilization
GPU Activity(%)
GPU Activity %
GPU Utilization %
GPU Core Utilization
Renderer Utilization
accelBusyPercent
GPU Busy %

A value is accepted only when it can be parsed as a finite number. Unit fractions in the interval (0, 1] are converted to percentages. Final percentages are constrained to the interval [0, 100].

The reader does not interpret an absent property as zero. The state is reported as unavailable. A temporary failed read can retain the preceding valid value for a bounded interval and marks the sample as stale.

3.4 GPU selection

Systems may publish multiple GPU services or multiple telemetry dictionaries for one physical device. MacPulse:

1. enumerates all matching services;
2. derives stable identifiers from IORegistry entry identifiers;
3. merges complementary fields from duplicate observations;
4. scores observations by telemetry completeness and current activity;
5. applies the selected policy: automatic, highest activity, prefer discrete, or prefer integrated;
6. retains limited continuity to prevent rapid switching between devices.

The automatic policy gives priority to active observations with usable utilization values. A previously selected device receives only a limited continuity preference and cannot permanently suppress an active alternative.

3.5 Memory

Memory data is derived from HOST_VM_INFO64. MacPulse reports total, estimated used, wired, compressed, and reclaimable cached memory. The displayed pressure value is a documented proxy based on constrained memory. It is not presented as a reproduction of Apple Activity Monitor's private memory-pressure algorithm.

3.6 Power

Power telemetry is incomplete on many macOS systems. MacPulse follows the following policy:

• total system power is displayed only when a battery power source exposes voltage and instantaneous current;
• GPU power is displayed only when the graphics driver publishes a power property;
• CPU package power and memory power remain unavailable unless a reliable public source is present;
• unavailable fields are displayed as Not exposed;
• component values are not added to an invented total;
• no private SMC interface, privileged helper, or external command requiring administrator access is used.

On desktop Macs without a battery, total wall power cannot be derived from public battery telemetry. Accurate wall power requires an external power meter.

4. User interface

4.1 Menu-bar application

MacPulse runs with LSUIElement enabled. It does not appear in the Dock and does not open a window at launch. The status item can show:

• icon only;
• CPU percentage;
• CPU and GPU percentages.

The numeric menu-bar title is rate-limited to avoid continuous layout movement.

4.2 Dashboard

The menu-bar popover is the live surface. It displays:

• CPU and GPU circular gauges;
• CPU user and system composition;
• recent CPU and GPU history;
• memory statistics;
• detected graphics devices;
• GPU temperature, clock, fan, power, and memory fields when available;
• total system and component power fields when available;
• telemetry freshness and sampling interval.

Visible labels for the application, CPU, and GPU can be changed in Settings. These changes affect interface text only. They do not change bundle identifiers, filenames, widget kinds, or installed application metadata.

4.3 Widgets

The extension provides overview, CPU, and GPU widgets in multiple sizes. WidgetKit controls execution and refresh scheduling. The widgets therefore provide periodic snapshots, not a guaranteed one-second live display.

The no-team edition does not use an App Group entitlement. The widget performs an independent bounded sample when WidgetKit requests a timeline.

5. Adaptive sampling

Sampling is controlled by a deterministic policy with three user profiles: Responsive, Balanced, and Efficient. The policy considers:

• whether the dashboard is visible;
• sustained low activity;
• Low Power Mode;
• thermal state;
• sleep and wake transitions.

GPU polling can be slower than CPU polling because IORegistry traversal is comparatively more expensive. Sampling intervals are operational targets, not real-time guarantees.

6. Architecture

MacPulse.app
  AppDelegate
  StatusItemController
  SettingsWindowController
  MonitorStore
    CPUReader
    MemoryReader
    PowerReader
    GPUReader
      IOKit enumeration
      GPUStatisticsParser
    MetricSmoother
    SamplingPolicy
  SwiftUI dashboard and settings

MacPulseWidget.appex
  TimelineProvider
  bounded CPU/GPU/memory/power sample
  small, medium, and large SwiftUI layouts

The application uses public macOS frameworks:

• AppKit;
• SwiftUI;
• WidgetKit;
• Foundation;
• Combine;
• Mach host APIs;
• IOKit;
• ServiceManagement.

No external runtime dependency is required.

7. Building without an Apple Developer Team ID

Requirements:

• macOS 13 or newer;
• Xcode 15 or newer;
• Xcode command-line tools;
• no paid Apple Developer membership is required for the local build.

Double-click:

Build and Install MacPulse.command

or run:

./scripts/doctor.sh
./scripts/build-local.sh
./scripts/install-local.sh

The build uses ad-hoc signing:

CODE_SIGN_STYLE=Manual
CODE_SIGN_IDENTITY=-
DEVELOPMENT_TEAM=
PROVISIONING_PROFILE_SPECIFIER=

Ad-hoc signing is suitable for local execution. It is not a substitute for Developer ID signing and notarization.

8. Creating a drag-to-install DMG

Double-click:

Build and Create DMG.command

The script performs the following operations:

1. validates the macOS/Xcode environment;
2. builds a universal Release application with an ad-hoc signature;
3. verifies the application and embedded widget signature;
4. creates a staging volume containing MacPulse.app and an Applications shortcut;
5. configures a Finder icon-view window;
6. creates a compressed read-only DMG;
7. verifies the disk image;
8. writes a SHA-256 checksum.

The output is written to:

dist/MacPulse.app
dist/MacPulse-2.1.2-local.zip
dist/MacPulse-2.1.2.dmg
dist/MacPulse-2.1.2.dmg.sha256
dist/SHA256SUMS.txt

When the DMG is opened, install the application by dragging MacPulse.app onto the Applications shortcut.

The same process can be run from Terminal:

./scripts/build-and-package.sh

To package an existing application bundle:

./scripts/package-dmg.sh ./dist/MacPulse.app

9. Distribution constraints

A DMG is a container format. Creating a DMG does not establish publisher identity and does not satisfy Gatekeeper distribution requirements.

For use on the same Mac, the ad-hoc build is sufficient. For distribution to other users without security warnings, the application must be:

1. signed with a Developer ID Application certificate;
2. submitted to Apple's notarization service;
3. stapled after successful notarization;
4. packaged into the final DMG;
5. optionally notarized and stapled again as a disk image.

A paid Apple Developer Program membership is required for Developer ID distribution.

Detailed procedures are provided in docs/DISTRIBUTION.md and docs/BUILDING.md.

10. Privacy and security

MacPulse:

• performs no network requests during normal operation;
• contains no analytics or advertising SDK;
• requires no account;
• does not collect device identifiers;
• does not read user documents;
• does not request administrator privileges;
• does not install a privileged helper;
• does not modify hardware control settings.

Diagnostic export excludes user name, host name, filesystem paths, serial number, and network identifiers.

See docs/PRIVACY.md and SECURITY.md.

11. Validation

The repository contains:

• parser tests for representative GPU property dictionaries;
• metric smoothing tests;
• portable core tests;
• source-validation scripts;
• Xcode project validation;
• plist and entitlement validation;
• shell-script syntax validation;
• application and DMG signature/integrity checks on macOS.

Hardware validation remains necessary because GPU and power telemetry are driver-specific. The validation matrix is maintained in docs/HARDWARE_VALIDATION_MATRIX.md.

12. Repository structure

MacPulse/                 Application target
MacPulseWidget/           WidgetKit extension
Shared/                   Shared data structures and policy
MacPulseTests/            Xcode unit tests
CoreSources/              Portable source links
CoreTests/                Portable Swift tests
scripts/                  Build, install, package, and release scripts
docs/                     Technical documentation
docs/images/screenshots/  Curated public product captures
MacPulse.xcodeproj/        Xcode project

13. License and project

MacPulse is distributed under the MIT License. See LICENSE.

Project maintained by TerabitLab. Source, issues, and releases are hosted in this repository.