Hardware telemetry and the netgraph

Read CPU, GPU, frame, memory and network figures from C++, Visual Scripting, Wolang and .ui bindings, react to thermal alerts, and show the netgraph.

Last updated Oct 27, 2026Edit this pageVersion 1.0.0

The telemetry service samples what the machine is doing (CPU, GPU, the frame, memory and the network link) and turns sustained heat, thermal throttling and VRAM pressure into alerts. Every figure is readable from C++, Visual Scripting, Wolang and a .ui binding, and the netgraph overlay shows them on screen.

What it measures

GroupFiguresWhere they come from
Framefps, frame time, 1 % low, game and render thread time, GPU frame timethe engine loop and the GPU timestamps
CPUtotal and per-core load, frequency, package temperature, throttlingthe OS: NtQuerySystemInformation and the power manager on Windows, /proc/stat, cpufreq, hwmon and the thermal throttle counters on Linux, host_processor_info and the thermal state on macOS
GPUload, temperature, hotspot, memory temperature, core and memory clock, power draw, throttle reasonsNVML on NVIDIA, Level Zero sysman on Intel, hwmon (amdgpu, i915, xe) on Linux, IOKit on macOS
VRAMused and budgetDXGI QueryVideoMemoryInfo, VK_EXT_memory_budget, the Metal working set
Memoryprocess resident memorythe OS
Networkping, jitter, packet loss out and in, bandwidth in and out, server tick ratethe session's transport (ENet) and replication

A metric the machine does not report is unavailable, never 0. Windows exposes no CPU temperature without a kernel driver, NVML reports no hotspot, ENet measures loss only on what it sends: those read as unavailable everywhere, in C++ as FTelemetryValue::Available == false, to a script as -1, in a binding as no value, on screen as n/a.

The vendor libraries ship with the GPU driver and are never redistributed with a game. Each loads only when that vendor's GPU is the one the engine renders on, and the engine matches the device by PCI id on a machine with several. AMD on Windows reports through ADLX and Intel on Windows through IGCL when Level Zero is absent; neither is wired yet, so there the GPU figures other than VRAM read as unavailable and the log says so.

Note

The service runs on a thread of its own at telemetry.SampleHz (4 Hz) while something reads it (a getter, the netgraph, a binding, stat hardware or stat net within the last two seconds) and at telemetry.Alert.SampleHz (1 Hz) otherwise while alerts are on. With telemetry.Enable 0 nothing is sampled. Frame and network figures are taken on the game thread at the end of a frame, at the same rate.

Read it

From C++:

ReadTelemetry.cpp
#include "Logging/Logger.h"
#include "Telemetry/Telemetry.h"

const Mowo::FTelemetrySnapshot snapshot = Mowo::FTelemetry::GetSnapshot();
const Mowo::FTelemetryValue& gpu = snapshot.Get(Mowo::ETelemetryMetric::GpuTemperatureC);
if (gpu.Available) {
	MOWO_LOG_INFO("GPU at %.0f C, %s", gpu.Value, snapshot.GpuSource.c_str());
}

From Visual Scripting and Wolang, MPerformanceStatics and MNetStatics answer plain numbers: GetFps, GetOnePercentLowFps, GetGpuTemperatureC, GetCpuLoad, GetCpuCoreLoad(core), GetVramUsedMB, GetPingMs, GetJitterMs, GetPacketLossOutPercent, GetBandwidthInKBps, GetServerTickRateHz and the rest. Each returns -1 when the metric is unavailable; IsMetricAvailable(id) tells a missing metric from a real -1, and GetMetric(id) reads any metric by its ETelemetryMetric number. GetSnapshot returns the main figures as one FPerformanceSnapshot struct for Visual Scripting's struct pins.

Warning

Wolang cannot yet call a *Statics class's functions directly or receive a returned string; both are open in the Wolang compiler. The numeric getters are the ones it will bind first, and nothing here works around it.

From a .ui file, bind to perf. and net. sources (FTelemetry::MetricKey lists them):

Netgraph.ui (excerpt)
TextBlock "Ping" {
    Bindings { Bind { property: "text"  source: "net.pingMs" } }
}
TextBlock "GpuTemp" {
    Bindings { Bind { property: "text"  source: "perf.gpu.temperatureC" } }
}
SourceValue
perf.fps, perf.frameMs, perf.onePercentLowFps, perf.gameThreadMs, perf.renderThreadMs, perf.gpuFrameMsthe frame
perf.cpu.load, perf.cpu.frequencyMHz, perf.cpu.temperatureCthe CPU
perf.gpu.load, perf.gpu.temperatureC, perf.gpu.hotspotC, perf.gpu.memoryTemperatureC, perf.gpu.coreClockMHz, perf.gpu.memoryClockMHz, perf.gpu.powerWthe GPU
perf.vram.usedMB, perf.vram.budgetMB, perf.memory.processMBmemory
net.pingMs, net.jitterMs, net.lossOutPercent, net.lossInPercent, net.inKBps, net.outKBps, net.tickRateHzthe link
net.connected, perf.alert.any1 or 0

Alerts

AlertRaises atClears under
GPU hottelemetry.Alert.GpuTempC (87 °C), or the hotspot at telemetry.Alert.GpuHotspotC (105 °C)telemetry.Alert.GpuTempClearC (80 °C)
GPU thermal throttlingthe driver reports a thermal slowdownit stops
CPU hottelemetry.Alert.CpuTempC (95 °C)telemetry.Alert.CpuTempClearC (88 °C)
CPU throttlingthe OS holds the CPU below its rated speedit stops
VRAM near budgettelemetry.Alert.VramFraction (0.95 of the OS budget)telemetry.Alert.VramClearFraction (0.88)

A reading must stay past a threshold for telemetry.Alert.HoldSeconds (3 s) to raise an alert, and back under its clear threshold as long to clear it, so a value hovering at the line is one alert, not one per sample. A GPU held at its power limit under load is normal and never alerts. The thresholds are cvars, so a project sets them in its INI and a device profile sets them per GPU (the Steam Deck's raises at 97 °C). telemetry.Alert.Enable 0 turns alerts off; telemetry.Alert.Throttling 0 keeps the temperature alerts and drops the throttling ones.

Each transition writes one log line ([Telemetry] alert raised: GPU hot (89.00, threshold 87.00)) and, on the game thread, calls FTelemetry::OnAlert() and posts a TelemetryAlertEvent on the EventBus:

WatchHeat.cpp
#include "Events/EventBus.h"
#include "Logging/Logger.h"
#include "Telemetry/TelemetryEvents.h"

Mowo::EventBus::Get().Subscribe<Mowo::TelemetryAlertEvent>([](Mowo::TelemetryAlertEvent& event) {
	if (event.GetData().Active && event.GetData().Alert == Mowo::ETelemetryAlert::GpuHot) {
		MOWO_LOG_INFO("lower the effects budget");
	}
});

A script polls IsAlertActive(id), IsAnyAlertActive and GetAlertSerial, which counts every raise and clear; the FOnTelemetryAlert delegate type documents the C++ signature.

In the editor a raised alert is a toast with Open Performance settings. A packaged game shows nothing by default; turn on Project Settings > Engine > Performance > Show Thermal Warnings to Players (telemetry.ShowPlayerWarnings 1) to draw a one-line banner while an alert is raised, or react to the event in your own UI.

The netgraph

CommandShows
net.graph 1frame rate and 1 % low, ping and jitter, loss, bandwidth and the server tick, in the bottom-right corner
net.graph 2adds the frame-time and ping graphs
net.graph 3adds the GPU temperature graph and the CPU, GPU and VRAM line
stat hardwarethe hardware panel: CPU and GPU load, clocks, temperature, power, throttling, VRAM and process memory
stat netthe network panel
telemetry.dumpthe current snapshot as two log lines

The netgraph is off by default in a packaged game. A project turns it on with net.graph=1 under [ConsoleVariables] in its INI or on Project Settings > Engine > Performance > Netgraph; players change it with the Performance Overlay row in the game's Display settings.

Hybrid CPUs

On a CPU with performance and efficiency cores (Intel 12th generation and later, Apple silicon), the job system sizes its pool to the cores: workers that prefer the P-cores, leaving three P-core threads for the game, render and RHI threads, take every High-priority job, and the rest prefer the E-cores. The render, RHI and audio threads prefer the P-cores; the telemetry thread prefers the E-cores. Preferences are soft (Windows CPU sets, Linux affinity, macOS QoS classes), so an idle core of either kind still picks work up. --job-workers=N sizes the pool by hand and --no-hybrid-cores turns the preferences off. The [JobSystem] log line at startup shows the topology and the split.

API reference

  • Telemetry module: FTelemetry, FTelemetrySnapshot, ETelemetryMetric, ETelemetryAlert, TelemetryAlertEvent, MPerformanceStatics, MNetStatics
  • ArcUI module: AArcUINetGraph

Engine sources

This page describes behavior implemented in these files of the engine repository, checked against commit 77b5ea1b2.

  • Engine/Source/Runtime/Telemetry/Public/Telemetry/Telemetry.h
  • Engine/Source/Runtime/Telemetry/Public/Telemetry/TelemetryAlerts.h
  • Engine/Source/Runtime/Telemetry/Public/Telemetry/TelemetryEvents.h
  • Engine/Source/Runtime/Telemetry/Public/Telemetry/TelemetryProviders.h
  • Engine/Source/Runtime/Telemetry/Public/Telemetry/Statics/MPerformanceStatics.h
  • Engine/Source/Runtime/Telemetry/Public/Telemetry/Statics/MNetStatics.h
  • Engine/Source/Runtime/Platform/Public/Platform/PlatformHardwareSensors.h
  • Engine/Source/Runtime/Platform/Public/Platform/PlatformCpuTopology.h
  • Engine/Source/Runtime/ArcUI/Public/ArcUI/Widgets/AArcUINetGraph.h

Page feedback

Was this page helpful?