Overview

Joular Core is a platform to measure power and energy across all systems and devices.

Joular Core is part of the project.

Joular Core aims to monitor hardware and software power and energy consumption on all platforms, operating systems and CPU & GPU architectures, i.e., everywhere.

The official website of Joular Core is: https://www.noureddine.org/research/joular/joularcore.

🔧 Key Features

• 📊 Monitor CPU & GPU power consumption on PCs, servers, and SBCs
• 🌐 Work seamlessly inside virtual machines
• 🔍 Track individual processes and multi-process applications on all platforms
• 📈 Export power measurements to the terminal or CSV files (multiple modes available)
• ⚙️ Inspect hardware-specific power data (CPU-only, GPU-only, or combined)
• ⌨️ Intuitive command-line interface (CLI)
• 🎨 Multi-platform graphical user interface (GUI)
• ⚡ Low overhead, written in Rust and compiled to native code

License

Joular Core is licensed under the GNU GPL 3 license only (GPL-3.0-only).

Copyright (c) 2025-2026, Adel Noureddine. All rights reserved. This program and the accompanying materials are made available under the terms of the GNU General Public License v3.0 only (GPL-3.0-only) which accompanies this distribution, and is available at: https://www.gnu.org/licenses/gpl-3.0.en.html

Author : Adel Noureddine

Supported Platforms

Joular Core supports a wide variety of platforms, operating systems and CPU architectures. It is as universal as it can get, and most environements are supported.

• 💻 Supported Systems: 🐧 Linux, 🪟 Windows, 🍎 MacOS, 🍓 Raspberry Pi, 💽 Virtual Machines.
• ⚙️ Supported Architectures: x86_64 (amd64), x86/i686, aarch64, arm, armv7, GPUs (Nvidia, Apple, AMD).

In particular:

• PC/Servers using a RAPL supported Intel processor (since Sandy Bridge) or a RAPL supported AMD processor (since Ryzen), on Windows and Linux.
• macOS computers on Intel mac or Apple ARM chip.
• Virtual machines (any supported guest on any host).
• For GPU: Nvidia, AMD and Apple
• Raspberry Pi devices (multiple models) on Linux (all revisions for each model are supported):
  • Model Zero W, for 32 bits OS
  • Model 1 B, for 32 bits OS
  • Model 1 B+, for 32 bits OS
  • Model 2 B, for 32 bits OS
  • Model 3 B, for 32 bits OS
  • Model 3 B+, for 32 bits OS
  • Model 4 B, for both 32 bits and 64 bits OS
  • Model 400, for 64 bits OS
  • Model 5 B, for 64 bits OS
• Asus Tinker Board (S)

CPU:

GPU:

Supported SBC platforms: Raspberry Pi (models: Zero W, 1 B, 1 B+, 2 B, 3 B, 3 B+, 4 B, 400, 5 B), Asus Tinker Board S.

Installation

Joular Core is written in Rust and can be easily compiled, and its binaries added to your system PATH.

Installers and Packages

We provide installation packages for a number of CPU architectures and operating systems.

For Windows:

• Installation MSI for 64 bits Windows.

For macOS:

• Installation PKG for Apple Silicon macOS.

For Linux:

• DEB packages for Debian-bases systems (Debian, Ubuntu, Raspberry Pi OS, etc.), for x86_64 and ARM aarch64 architectures.
• RPM packages for Red Hat and Fedora-based systems (RHEL, Fedora, etc.), for x86_64 architecture.
• AUR installation script for Arch-based systems, for x86_64 architecture.

For other architectures and distributions (32 bits Windows, Apple Intel macOS, other distros/architectures in Linux), you can just compile Joular Core and you’re good to start energy monitoring.

Binaries

Compiled version are available on our GitHub repository in the latest stable release. Just add the path of this binary to your user or system PATH environnemental variable and you’re good to go. You can also start the program directly with its full path, or double click to run.

Quick Usage of the command-line version

To use Joular Core, just run the command joularcore (on Linux or macOS), or joularcore.exe (on Windows).

On Intel or AMD PC/servers on Linux, Joular Core uses Intel’s RAPL through the Linux powercap sysfs, and therefore requires root/sudo access on the latest Linux kernels (5.10 and newer): sudo joularcore. An alternative is to change the permissions on the RAPL powercap files to provide read access to all. Check this issue in our GitHub on the matter. This is a limitation for all power monitoring tools on Linux using RAPL, and not specific to Joular Core.

On macOS, you also need to run Joular Core with elevated access (thus sudo): sudo joularcore.

On Windows, just run joularcore.exe.

On Raspberry Pi devices with Linux, just run joularcore.

By default, the software will show the power consumption of the CPU, GPU, total power, and CPU utilization.

To monitor a specific application, just run PowerJoular with the -a appName parameter, and a specific process with the -p PID. PowerJoular is a powerful tool with many functionalities that can be accessed using specific parameters. Check the Command Line Options page for the detailed list.

Quick Usage of the graphical user interface (GUI) version

Joular Core is shipped with an easy-to-use, yet powerful and complete, graphical user interface (GUI), which works seamlessly and in a coherent way across all platforms and operating systems.

To run the GUI, either:

• Start Joular Core with the -g or --gui argument.
• Use the dedicated GUI binary directly (double click for instance): joularcoregui (on Linux or macOS) or joularcoregui.exe (on Windows).

On RAPL-based Linux systems and on macOS, elevated access is needed to monitor CPU energy (hence the need to start it with sudo).

Most CLI features are available in the GUI, with easy-to-use buttons and configuration settings to monitor the entire computer, a specific process, or a specific multi-process application.

If the GUI is executed from a terminal, it also accepted the same CLI arguments as the CLI version. For instance, you can start the gui and an HTTP socket to export power data with: joularcore -g --api-port 8080

Compilation

Joular Core is written in Rust and uses Cargo for compilation.

Default build:

cargo build --release

This will build Joular Core with the virtual machine and GUI features, but not with SBC support.

SBC (Raspberry Pi) build:

cargo build --release --features sbc

This will build Joular Core with the virtual machine and GUI features, and with SBC support.

Feature selection:

You can build Joular Core with or without virtual machine support or the GUI. For instane, this is useful when you don’t need the GUI (i.e., in server environments) and want to build a smaller binary.

cargo build --release --no-default-features

⚙️ Available Features:

• vm (default: ON): Enables support for monitoring inside virtual machines.
• api (default: OFF): Enables support for the API with an HTTP server or WebSockets. Exporting power data to CSV files or to a ring buffer is enabled by default regardless of this feature.
• gui (default: ON): Compiles the application with the graphical user interface.
• sbc (default: OFF): Enables support for monitoring on single-board computers (e.g., Raspberry Pi) running Linux.
  • This disables RAPL-based monitoring and uses our SBC-specific power models.

You can mix and match features, for example:

# No GUI, but with VM
cargo build --release --no-default-features --features vm

# No GUI, no VM, but with SBC
cargo build --release --no-default-features --features sbc

# No VM, but with GUI and SBC
cargo build --release --no-default-features --features gui,sbc

Cross-Compilation

To cross-compile, use cargo-make with one of the targets defined in Makefile.toml.

For example, to build for all supported Raspberry Pi architectures (aarch64, arm, armv7):

cargo make build-sbc

With the proper Rust targets installed, you can hence cross-compile on all architectures and operating systems.

Dependencies

• Linux (PC, servers): Requires the RAPL interface for CPU power readings. RAPL files are usually readable only by the administrator, so you must either grant read access to these files or run Joular Core with sudo. More information in this issue.
• Windows: a RAPL driver. We currently support Hubblo’s RAPL driver. The easiest way to install a signed version of the driver is to install the Scaphandre tool from this installer.
• macOS: no dependencies required 😇 Uses powermetrics (already installed by default).
• Raspberry Pi: No dependencies required 😇

Virtual Machines

For virtual machines, two environment variables must be set depending on whether you want to monitor the CPU, the GPU, or both:

• VM_CPU_POWER_FILE: Path to the CPU power data file
• VM_CPU_POWER_FORMAT: Format of the CPU power data (joularcore or powerjoular or watts, default is watts if not set)
• VM_GPU_POWER_FILE: Path to the GPU power data file
• VM_GPU_POWER_FORMAT: Format of the GPU power data (joularcore or powerjoular or watts, default is watts if not set)

Single-Board Computers (SBC)

On SBC (Raspberry Pi, Asus TinkerBoard), Joular Core uses our own regression models to calculate CPU power consumption. These models are hard-coded in the code, but you can use your own models by supplying a JSON file with the model detail with the SBC_POWER_MODEL_JSON environmental variable. The format needs to follow the one used in our Power Models Database.

Command Line Options

To use Joular Core, just run the command joularcore or joularcore.exe.

The following options are available:

• -p, --pid <PID> : Monitor a specific process by its PID
• -a, --app <APP> : Monitor a specific application by its name (all PIDs)
• -f, --file <FILE> : Write output to CSV file
• -c, --component <COMPONENT> : Monitor only specific component (values: cpu, gpu)
• -i, --numeric : Output only numeric value (no formatting)
• -o, --overwrite : Overwrite file instead of append (only with -f)
• -g, --gui : Start GUI interface
• -r, --ringbuffer : Send power data to ring buffer
• -h, --help : Print help
• -V, --version : Print version

To use Joular Core inside virtual machines, two environment variables must be set depending on whether you want to monitor the CPU, the GPU, or both:

• VM_CPU_POWER_FILE: Path to the CPU power data file
• VM_CPU_POWER_FORMAT: Format of the CPU power data (joularcore or powerjoular or watts, default is watts if not set)
• VM_GPU_POWER_FILE: Path to the GPU power data file
• VM_GPU_POWER_FORMAT: Format of the GPU power data (joularcore or powerjoular or watts, default is watts if not set)

On SBC (Raspberry Pi, Asus TinkerBoard), Joular Core uses our own regression models to calculate CPU power consumption. These models are hard-coded in the code, but you can use your own models by supplying a JSON file with the model detail with the SBC_POWER_MODEL_JSON environmental variable. The format needs to follow the one used in our Power Models Database.

Exporting power and energy measurements

Joular Core can export the power and energy measurements through multiple interfaces and approaches. All the following export approaches works on all supported platforms and operating systems.

Write on terminal and stdout redirection

By default, Joular Core will write data to the terminal. However, this data could be friendly for stdout redirection by using the -i argument: joularcore -i or joularcore.exe -i

This will output just a float on the terminal that can be redirected anywhere. By default, the float will be the total power consumption. If combined with other arguments, such as the -c argument to select a specific component, it will provide only that specific component.

CSV files

Joular Core can export data to a CSV file with the -f argument, while supplying a filename or path.

joularcore -f myfile.csv will write a CSV with a header and a new line for every second of power monitoring. The format of the CSV file is the following: Timestamp,Total Power (W), CPU Power (W),GPU Power (W),CPU Usage (%),Process Power (W)

Inter-process communication with a shared memory ring buffer

Joular Core can also write data to a shared memory ring buffer, on all OSes, when executed with the -r argument: joularcore -r or joularcore.exe -r This allows much faster communication and sharing power data between Joular Core and other programs.

Default ring buffer paths are:

• /dev/shm/joularcorering on Linux
• /tmp/joularcorering on macOS
• Local\\JoularCoreRing on Windows

The ring buffer have a size of 5 data stuctures with the following values (by order): CPU power, GPU power, Total power, CPU usage, and PID or APP power. Unavailable values, such as when monitoring entire CPU and not a specific application, will be at 0.

HTTP and WebSockets API

Joular Core can expose power data through an HTTP server or WebSockets. To use this API, you need to enable the api feature when building Joular Core.

To run Joular Core and export data through the API, use the --api-port option to specify the port for the HTTP and WebSockets server endpoint. For example:

joularcore --api-port 8080

The API will expose the following endpoints:

• /data: HTTP endpoint to get the latest power data
• /ws: WebSockets endpoint for real-time power data

The API exposes data in JSON format:

• cpu_power: CPU power in Watts
• gpu_power: GPU power in Watts
• total_power: Total power in Watts
• cpu_usage: CPU usage in percentage
• pid_or_app_power: PID or application power in Watts (0 if option not selected)

Systemd Service

A systemd service is provided and can be installed (by copying joularcore.service in systemd folder to /etc/systemd/system/). The service will run the program with the -o option (which only saves the latest power data) and the -f option to save data to /tmp/joularcore-service.csv. The service can be enabled to run automatically on boot.

You can modify the service as needed to start Joular Core with any argument and output the data with any format (CSV, HTTP API, ring buffer shared memory, etc.).

The systemd service is automatically installed when installing Joular Core using the installer script.

Integration with Systems and Tools

Joular Core exports its power data with multiple outputs and approaches: to the terminal, to CSV files, to an HTTP and WebSockets API, and to a ring buffer shared memory (IPC). Check this page for details on these export approaches in Joular Core.

Therefore, Joular Core can be used in IDEs, integration systems CI/CD, alongside other profilers or debugging tools, connect with dashboard for real-time power monitoring, send data to remote databases, or anywhere needed!

All what is needed is to start Joular Core and configure the export you want to use, and that’s it.

Joular Core can also be run as a CLI service, on all platforms.

Virtual Machines

Joular Core also works inside virtual machines. All its functionalities (such as monitoring a PID or an application) work the same inside a virtual machine as with bare metal installation.

In virtual machines, Joular Core in the guest OS needs to get the power consumption of the virtual machine instance itself. This can only be done by installing on the host OS, a power monitoring tool (such as Joular Core itself or other ones), and monitoring the power consumption of the specific guest virtual machine process.

The power data of the VM process need to be written to a shared file between the host and the guest. Inside the guest, Joular Core will read this file continuously and use the reported power value as the power of the entire virtual machine.

Joular Core is agnostic to what power tools in installed in the host and can work with any available tool that is capable of monitoring the VM process.

For virtual machines, two environment variables must be set depending on whether you want to monitor the CPU, the GPU, or both:

• VM_CPU_POWER_FILE: Path to the CPU power data file
• VM_CPU_POWER_FORMAT: Format of the CPU power data (joularcore or powerjoular or watts, default is watts if not set)
• VM_GPU_POWER_FILE: Path to the GPU power data file
• VM_GPU_POWER_FORMAT: Format of the GPU power data (joularcore or powerjoular or watts, default is watts if not set)

Use case example with Joular Core on host and guest

A use case example is using Joular Core on both the host and the guest.

In the host OS

• Install Joular Core
• Run Joular Core while specifying the PID of the virtual machine of the guest OS (or the application name), and writing the power data in a CSV file in overwrite mode.
• For instance, you can run Joular Core with the following command: joularcore -p $VM_PID -o /home/vm/vm.csv
• Share the /home/vm/vm.csv between the host OS and the guest OS

In the guest OS

• Install Joular Core
• Share the /home/vm/vm.csv between the host OS and the guest OS, potentially having a different path of the file inside the guest. For instance, /opt/vm/vm.csv
• Run Joular Core after setting the needed environemental variables.
• For example, in our use case example, set VM_CPU_POWER_FILE to /opt/vm/vm.csv, and VM_CPU_POWER_FORMAT to joularcore
• You can add other options for your needs, such as -p or -a to monitor a specific process or application inside your virtual machine.

How Joular Core Works

Under construction.