corewatch

A Core Temp-style hardware monitor for Linux. It shows every temperature, fan speed, voltage, clock, load and power reading your machine exposes, refreshes them at an interval you choose (0.25 s to 60 s), and keeps a minimum, maximum, average and 15-minute history for each one.

Features

• Overview gauges across the top for the numbers you check most: CPU temperature (with the hottest core), GPU temperature (with the card's other temperatures, like hotspot and memory), CPU load (with the busiest core and the fastest core's clock) and CPU + GPU power (the ring fills against the CPU's and the card's power limits added together, in two colours, one per part; if either limit isn't reported, the ring splits the total between them instead). With a graphics card next to integrated graphics, the gauges follow the card; integrated graphics' power is never added to the CPU's, since the CPU's figure already includes it. Click a gauge (or Tab to it and press Enter) to open that sensor in the detail drawer. A gauge only appears if your hardware reports its sensor.

• Core heat map. The CPU card shows its cores as a honeycomb, each tinted by temperature (under 40 °C, 40–50, 50–70, 70 and up), so a hot core stands out at a glance. Intel hybrid CPUs get a row of P-cores and a row of E-cores. AMD CPUs report one temperature per chiplet rather than per core, so a Ryzen with two or more chiplets shows those, and one with a single chiplet (or an APU) has no map. Click a core, or use the arrow keys and Enter, to see its history.

• One card per device (CPU, GPU, motherboard, battery, network card), plus a Fans card that gathers every fan from the motherboard and the GPU, and a Storage card with every drive (the detail drawer still names the device each sensor belongs to). The CPU and GPU cards span the window; the rest sit two to a line when the window is wide enough.

• Your own layout. Settings → Edit layout… lets you rearrange the overview: drag a panel (the gauges or any card) by its handle, or move it with its arrows; make it half or the whole width; or hide it with its eye button. Hidden panels wait in a list under the cards, each with a button to show it again (including one whose device isn't connected right now), and stay hidden while you filter. Reset layout puts everything back, and Done or Esc finishes. The layout is remembered: a device you unplug comes back where it was, and one that's new takes its usual place.

• Each card opens on a view made for its device:

  • CPU: the heat map, with tiles for package and cores power, the fastest clock, load, the hottest core and Vcore (where the board's chip or zenpower reports it).
  • Fans: each fan's speed, a bar of how hard it's driven (its fan control setting where there is one, else its speed against its own fastest), and where it is.
  • Storage: each drive's temperature on a bar marked where the drive starts to warn.
  • Motherboard: its named voltage rails.
  • Network: download and upload, each with its last minute drawn, and the card's temperatures.

  Click an item, or Tab to the view and use the arrow keys and Enter, to open its sensor. All sensors in a card's header shows its full list under the view, and corewatch remembers which cards you left open that way. The GPU card, and any card with nothing for a view, is its full list. While you filter, every card lists just the sensors that match.

• The full list shows each sensor like the Storage and Fans cards do: its name and value, a bar, and a line with its min, max and average and any limits. The bar fills against what the sensor can reach: 90 °C for a temperature (more if its limits are higher, with a mark where it starts to warn), 100 % for load, the top clock for a clock, the limit for power. A sensor with nothing like that, a voltage say, shows its last 60 seconds there instead. Sensors are sorted by kind, in two columns on a full-width card and one on a half-width card. The Fans card's list uses the ten-step bars of its view for every row: a fan's speed lights as far as its control is set, and turns amber when it's driven hard.

• Detail drawer along the bottom for the selected sensor. Shut, it's one line: the sensor, its value and its last minute, so the cards get the window. Click a sensor, or that line, to open it to a 1, 5 or 15 minute chart with the hardware's limits drawn as dashed lines. Hover over the chart to read any point's value and time. Below the chart: lowest and highest (with the time each happened), averages for the session, the last minute and the last 5 minutes, variation, trend, and time spent past a limit or at critical. Drag its edge to resize it; it reopens at that height. Esc, its arrow, or clicking the shown sensor again shuts it.

• Focus view. Double-click any sensor (in a card, a gauge or the heat map), or use the focus button in the detail drawer, to see it across the whole window:

  • a dial with the reading against its scale, its high limit marked and its critical zone shaded. A power reading fills against its limit, and a clock against its top speed (each CPU core's own, and an NVIDIA card's). Sensors with no natural scale borrow one and name it under the ring, saying when the reading is off either end: a voltage fills between its limits, or across a supply rail's typical range, or else across its range on the chart (at least 0.05 V); a fan, a clock, power without a limit, current or traffic against its highest yet;
  • the headroom to its limit, and which way it's heading;
  • a large chart that always keeps the limits in view, with its peak and a 1-minute average;
  • every statistic, each with a word on what it means.

  Where the hardware reports no limit at all, corewatch fills in a typical one and says so: ±5 % for the named supply rails (+12V, +5V, +3.3V, +3.3V standby and AVCC), and for a graphics card's or a drive's other temperatures (hotspot, memory, a drive's extra sensors) the critical (or, without one, high) limit of its main one, since those run hotter than it by design. They show in the headroom, the chart, the drawer and the list as "typical"; a load or a fan control is simply "full at 100 %". They never turn a sensor amber or red or count as time past a limit. Sensors with nothing sensible to fill in (unnamed voltages, fan speeds, a board's other temperatures) still say no limit.

  A fan has no top speed to warn at, but it can stall: one that has run steadily since corewatch started and then reads 0 RPM for 10 seconds while its control asks 40 % or more turns amber (in a pinned tray icon too) and says "stalled" in the headroom, the drawer and the list, and the time counts as past a limit. Below 40 % a fan may be resting by design (a graphics card's zero-RPM mode, a board's fan stop). A ThinkPad's fan is never judged this way: its control reads 100 % while the firmware rests the fan. An NVIDIA card reports the speed it intends rather than the one it gets, so a blocked NVIDIA fan may never read 0 RPM.

  For a CPU sensor, Every core charts each core's temperature over the same minutes on one scale, with its peak and clock; click a core to focus on it. Same device charts up to 12 of the other sensors on its device over the same minutes, each on its own scale: a fan's control (or a control's fan) first, then its own kind, and a CPU's per-core sensors only when there are too few cores for Every core. Click one to focus on it. The pencil beside the sensor's name renames it, and Pin to tray works from here too. The up and down arrows beside Back (or Ctrl+PgUp and Ctrl+PgDn) step to the previous or next sensor in the overview's order, without going back. Esc or Back goes back, and so does typing in the filter.

• Readable names. Intel hybrid CPUs show P-core 0-7 and E-core 0-7 instead of the kernel's gappy core IDs, and an M1 Pro's cores read E-core 0-1 and P-core 0-7. Nuvoton motherboard chips get named voltage rails (Vcore, +12V, +5V, +3.3V, ...). Right-click any sensor and choose Rename… to give it your own name (handy for "Fan 2" → "CPU fan"); Reset name undoes it.

• Tray icon. corewatch's logo sits in the tray, in one colour like the desktop's own icons there. Its menu opens the window and has every option the window has: reset min/max, update interval, °C/°F, min / max in the list, and everything in the settings menu, through to Quit. Double-click it (or, on desktops where a click doesn't open the menu, click it) to bring the window up.

• Pin sensors to the tray. Right-click a sensor and choose Pin to tray, or use the button in the detail drawer. Each pinned sensor gets its own tray icon showing its number, like Core Temp's per-core icons: in the panel's own colour (with a faint outline, so it reads on either kind of panel) over a cyan line, which turns amber once the sensor is warm (a temperature from 50 °C, anything past its high limit or below its low limit, or a stalled fan). At critical the number turns red too. Right-click one to see its group, name, min, max and average, or to unpin it (which also works for a sensor that has stopped reporting; its icon shows a grey "?"). On desktops whose tray shows tooltips (KDE, Xfce, Cinnamon) hovering shows the same; Ubuntu's doesn't. Double-clicking a pinned icon also brings the window up.

• Noise hidden by default. Empty motherboard fan headers and unconnected temperature probes are hidden (Settings → Show unused sensors brings them back). A fan that stops after spinning is never hidden, and neither is anything in a warning state or a GPU fan idling at 0 RPM.

• Comfortable to leave open. Light and dark themes (following the desktop by default), a filter box (Ctrl+F), the update interval and °C/°F in the top row; everything else, from Reset min/max (Ctrl+R) and the min / max in the list down, is under the settings button at its right. The toolbar shows the computer's name next to the logo (turn off Show this computer's name for screenshots) and a LIVE chip that turns amber with WAITING FOR A READING if a reading is well overdue. Start when I log in starts corewatch at every login (it adds ~/.config/autostart/corewatch.desktop, which your desktop's Startup Applications settings also show), and Start minimized in the tray starts it without opening the window, at login or any other time (it needs a system tray; at login corewatch waits up to 30 s for the panel's tray to appear, and opens the window if none does). Opening corewatch while it's already running brings up the running one instead of starting a second copy. Sensors are read on a background thread, so a slow driver never freezes the window. Settings are remembered in ~/.config/corewatch/corewatch.conf.

• Terminal view (corewatch tui) for SSH sessions, and a one-shot dump (corewatch dump, or --json for scripts).

What it reads

Source	What you get
Kernel hwmon (/sys/class/hwmon)	Intel CPU package and per-core temperatures (coretemp), motherboard temperatures, fans, fan control, voltages, NVMe and network card temperatures, and anything else a driver publishes
AMD CPUs (k10temp, optional zenpower)	CPU temperature (the real die temperature, plus the fan-control value where the chip reports both) and one temperature per chiplet (CCD); AMD reports no per-core temperatures. With zenpower (Zen 1-3), core and SoC voltages, currents and power
AMD GPUs (amdgpu)	GPU, hotspot and memory temperatures (warning at the throttle point, critical at shutdown), fan speed (RPM and %), core voltage, graphics and memory clocks, power draw against its cap, load and video memory, under the card's model name
/proc/stat, cpufreq	Load and clock speed per physical core, with each core's top clock from the hardware. On ARM chips with two kinds of core (Apple's M chips among them), the cores the kernel rates less capable are named E-cores and the rest P-cores
Battery (/sys/class/power_supply)	A laptop's charge, the power going in or out, current, voltage, temperature, and its health (what it holds now against when it was new), in a Battery card. A mouse's or keyboard's battery is left out
Programs (/proc), on laptops	The 10 programs using the most CPU time over the last 10 s, in a Battery · programs card: each one's share of the CPU, and while running on the battery an estimate of the power it stands for (its share of the busy CPU time × the battery's draw). Linux counts no energy per program, so the estimate leaves out the display, Wi-Fi and the GPU's work: it ranks programs well, but treat the watts as a rough guide. All of a program's processes count as one (a browser's many, say). Read at most once a second
Apple Silicon Macs (Asahi Linux: macsmc_hwmon)	The board's temperatures, power readings, fans and voltages, under the Mac's name, and the speaker amplifiers' temperatures. The fans rest at 0 RPM until needed, which isn't a warning. The kernel reports no CPU temperature on these Macs, so there's no CPU temperature gauge or core heat map
RAPL (/sys/class/powercap)	CPU package and core power draw on Intel and AMD Zen, and Intel integrated graphics power (needs one permission tweak, see below). The package's power limit (the higher of its sustained and boost limits, as the firmware or a power profile sets them) is shown for reference, not as a warning
Intel graphics (i915, xe)	Graphics clock and active time (the share of time it isn't asleep) for integrated graphics and Arc cards. Integrated: power draw from RAPL; it has no temperature sensor of its own, so its heat shows in the CPU package temperature, and if it's switched off in the BIOS only its power draw appears, under the CPU. Arc: power draw against its limit and core voltage, plus fan speeds and GPU and memory temperatures where the kernel reports them (fans from about Linux 6.12, temperatures on Battlemage with xe). corewatch never keeps an idle Intel GPU awake: while nothing is using it, it shows 0 MHz and 0 % without reading it, and an Arc card's sensors stay blank until it's in use
NVIDIA NVML	GPU temperature, fan speeds (RPM and %), power draw (the power limit is shown for reference, not as a warning), graphics and memory clocks (with the card's top clock for each), load, video memory
NVIDIA NvAPI (libnvidia-api.so.1)	GPU hotspot and memory (VRAM) temperatures and the core voltage, which NVML doesn't expose; a voltage that reads outside about 0.5-1.5 V is left out. Uses the same driver calls as LACT; works as a normal user on RTX 20-40 cards
/sys/class/net	Download and upload rates for each physical network interface with a link (Docker bridges, loopback and unplugged ports are left out)

AMD support follows the kernel drivers' documented behaviour and is covered by tests, but has not yet been tried on real AMD hardware. If you have a Ryzen or Radeon, the output of corewatch dump --json --all in an issue is the most useful thing you can send.

Install

Ubuntu and Debian

On Ubuntu 24.04, Debian 13 or newer (PCs and ARM), add corewatch's apt repository and install it from there, so apt upgrade keeps it up to date:

curl -fsSL https://ronaldorcampos.github.io/corewatch/corewatch.gpg | sudo tee /usr/share/keyrings/corewatch.gpg > /dev/null

echo "deb [signed-by=/usr/share/keyrings/corewatch.gpg] https://ronaldorcampos.github.io/corewatch stable main" | sudo tee /etc/apt/sources.list.d/corewatch.list

sudo apt update && sudo apt install corewatch

Or, without the repository and its updates, download the .deb from the latest release (amd64 for PCs, arm64 for ARM) and install it with apt, which also installs the system libraries it needs:

sudo apt install ./corewatch_*_$(dpkg --print-architecture).deb

That gives you the corewatch command, its launcher entry and icon. The package carries its own Python and Qt under /opt/corewatch, and runs them isolated, so it doesn't touch, or depend on, the system's Python or yours.

If you had installed corewatch with uv before, remove that copy and its launcher entry, or they go on standing in for the package's:

uv tool uninstall corewatch; rm -f ~/.local/share/applications/corewatch.desktop ~/.local/share/icons/hicolor/scalable/apps/corewatch.svg

sudo apt remove corewatch removes the package. What it doesn't know about stays: your settings in ~/.config/corewatch, and the login entry if you turned on Start when I log in (turn it off before removing, or delete ~/.config/autostart/corewatch.desktop), and the CPU power rule if you copied it into place (sudo rm /etc/udev/rules.d/99-corewatch-rapl.rules). To drop the repository too: sudo rm /etc/apt/sources.list.d/corewatch.list /usr/share/keyrings/corewatch.gpg.

To build the package yourself from a clone, run packaging/deb/build.sh (it needs uv, dpkg-deb, and readelf from binutils); it writes it to dist/.

Fedora, RHEL and openSUSE

Download the .rpm from the latest release (x86_64 for PCs, aarch64 for ARM) and install it with dnf or zypper, which also install the system libraries it needs:

sudo dnf install ./corewatch-*.$(uname -m).rpm

On openSUSE: sudo zypper install --allow-unsigned-rpm ./corewatch-*.$(uname -m).rpm. It works on Fedora 42, RHEL 9 and openSUSE Leap 15.6 or newer on PCs. On ARM, Qt needs a newer C library: Fedora 42, RHEL 10 or openSUSE Leap 16 or newer. On RHEL, some of the libraries come from the AppStream repository, which is on by default.

It carries the same as the .deb, under /opt/corewatch, and the same about an earlier uv install applies. sudo dnf remove corewatch (or zypper remove) removes it, leaving behind what the .deb does. The CPU power rule is in /usr/share/corewatch here too. To build it yourself, run packaging/rpm/build.sh (it needs uv, rpmbuild and readelf).

Anywhere else, with uv

You need Linux with glibc 2.34 or newer (Ubuntu 22.04, Debian 12, Fedora 35 or later; the Qt toolkit's wheels require it), uv, and Python 3.13 (uv fetches it if needed). The NVIDIA driver is optional; without it the GPU card simply doesn't appear.

uv tool install git+https://github.com/ronaldorcampos/corewatch

That puts corewatch in ~/.local/bin. To add it to your app launcher (GNOME, KDE and others), first install its icon (the touch makes the desktop look again even if another app, such as Steam, has left an icon cache there that doesn't know about it yet):

curl -fsSL --create-dirs -o ~/.local/share/icons/hicolor/scalable/apps/corewatch.svg https://raw.githubusercontent.com/ronaldorcampos/corewatch/main/src/corewatch/assets/corewatch.svg && touch ~/.local/share/icons/hicolor

Then the desktop entry, pointing it at the full path because launchers don't always search ~/.local/bin. Install it second: GNOME reloads its icons when the entry appears, so the icon needs to be in place by then:

curl -fsSL --create-dirs -o ~/.local/share/applications/corewatch.desktop https://raw.githubusercontent.com/ronaldorcampos/corewatch/main/packaging/corewatch.desktop && sed -i "s|^Exec=corewatch\$|Exec=$HOME/.local/bin/corewatch|" ~/.local/share/applications/corewatch.desktop

To update to the latest version later:

uv tool install --reinstall git+https://github.com/ronaldorcampos/corewatch

From a clone

To work on corewatch, or run your own changes:

git clone https://github.com/ronaldorcampos/corewatch.git
cd corewatch
uv tool install .

uv tool install takes a snapshot of the code; after changing or pulling it, refresh with uv tool install --reinstall .. The launcher entry and icon are in packaging/corewatch.desktop and src/corewatch/assets/corewatch.svg.

The tray on GNOME

The tray icon needs a system tray, and GNOME has one only with the AppIndicator extension. Ubuntu ships it enabled; Fedora (Asahi Remix included) doesn't. Without it, corewatch shows no icon, greys out Keep running in the tray when closed and Start minimized in the tray, and closing the window quits it. On Fedora, install the extension:

sudo dnf install gnome-shell-extension-appindicator

Log out and back in, since GNOME only finds a new extension when you log in, then turn it on:

gnome-extensions enable appindicatorsupport@rgcjonas.gmail.com

Usage

corewatch                # desktop window
corewatch tui            # terminal view
corewatch dump           # print every reading once
corewatch dump --json    # the same, for scripts

Options: -i/--interval SECONDS (0.25-60, for this run only), -f/--fahrenheit, --minimized (start in the tray without opening the window, whatever the setting says), and for dump, --all to include unused inputs.

Terminal view keys: q quit · r reset min/max · f toggle °C/°F · u show/hide unused sensors · +/- faster/slower updates.

Getting fan speeds and voltages

Most desktop boards report fans and voltages through a "Super I/O" chip, whose kernel driver often isn't loaded by default. corewatch says so in a banner when it finds no fans or voltages.

On ASUS, MSI and ASRock boards from the last few years that chip is a Nuvoton, handled by nct6775 (newer ASUS boards, such as the ROG STRIX Z790 series, are reached through ASUS WMI):

sudo modprobe nct6775

To load it at every boot:

echo nct6775 | sudo tee /etc/modules-load.d/nct6775.conf

For other boards, sudo sensors-detect (from lm-sensors) finds the right module and offers to add it to /etc/modules. corewatch picks up a newly loaded driver without a restart.

The driver doesn't name voltage inputs. On NCT679x chips corewatch names the ones the chip wires internally on every board (AVCC, +3.3V, +3.3V standby, CMOS battery). On ASUS boards it also names Vcore, +5V and +12V, and multiplies the last two back up from their 1:5 and 1:12 resistor dividers. Check those three against your BIOS's Monitor page once. The remaining inputs are board-specific and stay "Voltage N".

Getting CPU power draw

Since 2020 the kernel only lets root read the RAPL energy counters, because power readings can leak information through a side channel (CVE-2020-8694, "PLATYPUS"). On a personal desktop it is common to make them readable anyway. Install the udev rule, then apply it without rebooting:

curl -fsSL https://raw.githubusercontent.com/ronaldorcampos/corewatch/main/packaging/99-corewatch-rapl.rules | sudo tee /etc/udev/rules.d/99-corewatch-rapl.rules > /dev/null

(From a clone, sudo cp packaging/99-corewatch-rapl.rules /etc/udev/rules.d/ does the same. The packages carry the rule without turning it on: sudo cp /usr/share/corewatch/99-corewatch-rapl.rules /etc/udev/rules.d/.)

sudo udevadm trigger --subsystem-match=powercap --action=add

Restart corewatch afterwards; it checks for the counters when it starts.

Contributing

Pull requests are welcome, and hardware reports (corewatch dump --json --all) especially, as issues. CONTRIBUTING.md covers setting up, the checks and how pull requests are merged; SECURITY.md covers reporting a vulnerability.

Licensed under the MIT License. The bundled fonts (Chakra Petch, JetBrains Mono and IBM Plex Sans, in src/corewatch/assets/fonts) are under the SIL Open Font License; their licences are beside them.