Joular Core ⚡

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

Detailed documentation (including user and reference guides) are available at: https://joular.github.io/joularcore/.

📡 Supported platforms

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

Note: Joular Core is still under heavy development, in alpha quality. Expect bugs and still under-development features.

🌍 Universal Compatibility:

CPU:

OS	x86_64	i686	Apple Silicon	arm	armv7	aarch64
Windows	🌟	🌟
Linux	🌟	🌟
macOS	🌟		🌟
SBC (Raspberry Pi)				🌟	🌟	🌟
Virtual Machines	🌟	🌟	🌟	🌟	🌟	🌟

GPU:

OS	Nvidia GPU	AMD GPU	Apple GPU
Windows	🌟	🌟
Linux	🌟	🌟
macOS			🌟
SBC (Raspberry Pi)
Virtual Machines	🌟	🌟	🌟

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.

🚀 Features

• 📊 Monitor power consumption of CPU and GPU of PCs, servers, and single-board computers
• 🌐 Monitor inside virtual machines
• 🔍 Monitor individual processes and multi-process applications on all platforms and OSes
• 📈 Expose power consumption to the terminal, CSV files, to a ring buffer (in multiple modes), and through an API with an HTTP server or WebSockets.
• ⚙️ Expose specific hardware component power consumption (CPU, GPU or all)
• ⌨️ Provide a command-line interface (CLI)
• 🎨 Provide a multi-platform graphical user interface (GUI) to display power consumption
• ⚙️ systemd service (daemon) to continuously & automatically monitor power on Linux
• ⚡ Low overhead (written in Rust and compiled to native code)

Cross-OS Command-Line Interface:

Cross-OS GUI:

Process monitoring:

Multi-process application monitoring:

Other features

📦 Building & Compiling

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: ON): 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.

💡 Configuration

On all platforms (except virtual machines), Joular Core will work automatically without any specific settings or configuration. Joular Core will detect the platform, collect relevant power and CPU usage data, and display power consumption for CPU and supported GPUs.

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. After installing the driver, Joular Core runs in user mode, so no admin rights or elevated access needed.
• macOS: no dependencies required 😇 Uses powermetrics (already installed by default, but also requires sudo to get power data).
• Raspberry Pi: No dependencies required, and no sudo needed 😇

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.

Options

• -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

Graphical user interface (GUI)

Joular Core is also available with a graphical user interface (GUI), which works seamlessly and in a coherent way across all platforms and operating systems. Most functionalities of Joular Core can be executed from the GUI, such as monitoring a specific process or a specific application, or writing to a CSV file. The GUI also supports the same CLI arguments as the terminal version, such as exporting data to an HTTP API/sockets.

To run the GUI, either:

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

Shared memory ring buffer

Joular Core output power data to the terminal and to CSV files, but it can also write this data to a shared memory ring buffer, on all OSes. 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 on Linux

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.

⌛ Goals of Joular Core

Joular Core is currently under development and aims to:

• Replace our collection of energy and power measurement tools and software, in particular PowerJoular, WinPowerMonitor and MacPowerMonitor. Windows and macOS now support features previously exclusive to Linux in PowerJoular, including per-process and per-application monitoring, file exports, and a GUI interface.
• Simplify and streamline cross-OS development with a unified code base in Rust, replacing our existing code in Ada (Linux), C++ (Windows) and Shell scripts (macOS).
• Measure energy everywhere and anywhere, that is on all platforms, operating systems, architectures and hardware components (CPU, GPU, etc.).
• Be the core foundation for source-code monitoring tools and profilers, containers and virtual machine monitoring, and be embedded in other monitoring and reporting tools, GUIs or dashboards.
• Provide seamless features across all platforms, including a solid and reliable command-line tool, and an easy-to-use GUI.

📑 Help needed!

Joular Core is a free and open-source tool. We call for developers and researchers to contribute to the development, testing and using of this software. Feel free to provide pull requests, comments and ideas in our issue tracker, and report testing on various hardware platforms.

📰 License

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

Copyright © 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 (GPL-3.0-only) which accompanies this distribution.

Author : Prof. Adel Noureddine