### Install Python dependencies

Source: https://github.com/amanusk/s-tui/blob/master/README.md

Install the required Python libraries, urwid and psutil, for s-tui. These can be installed globally with sudo or for the current user using --user.

```bash
[sudo] pip install urwid (--user)
```

```bash
[sudo] pip install psutil (--user)
```

--------------------------------

### Install Development Dependencies

Source: https://github.com/amanusk/s-tui/blob/master/README.md

Installs the project in editable mode with test dependencies and specific versions of ruff and pyright.

```bash
pip install -e ".[test]"
pip install ruff==0.15.4 pyright==1.1.408
```

--------------------------------

### Install s-tui on OpenSUSE

Source: https://github.com/amanusk/s-tui/blob/master/README.md

Install s-tui on OpenSUSE using the zypper package manager.

```bash
sudo zypper install s-tui
```

--------------------------------

### Install s-tui with stress support

Source: https://github.com/amanusk/s-tui/blob/master/README.md

Install s-tui with optional dependencies for better stress test performance. This command installs the 'stress' extra, which includes numpy.

```bash
pip install s-tui[stress]
```

--------------------------------

### Install s-tui with pip

Source: https://github.com/amanusk/s-tui/blob/master/README.md

Install the latest version of s-tui using pip. This command installs the package for the current user. Ensure ~/.local/bin is in your PATH.

```bash
pip install s-tui --user
```

--------------------------------

### Install s-tui with pipsi

Source: https://github.com/amanusk/s-tui/blob/master/README.md

Install s-tui within a virtual environment using pipsi.

```bash
pipsi install s-tui
```

--------------------------------

### Install s-tui globally with pip

Source: https://github.com/amanusk/s-tui/blob/master/README.md

Install s-tui system-wide using pip with root privileges. You may need to install python-dev first.

```bash
sudo pip install s-tui
```

--------------------------------

### Set Up Pre-commit Hooks

Source: https://github.com/amanusk/s-tui/blob/master/README.md

Installs pre-commit and configures it to run checks before each push to ensure code quality.

```bash
pip install pre-commit
pre-commit install --hook-type pre-push
```

--------------------------------

### Install stress tool

Source: https://github.com/amanusk/s-tui/blob/master/README.md

Install the 'stress' utility for additional stress testing options, including memory and I/O. This is an optional dependency.

```bash
sudo apt-get install stress
```

--------------------------------

### Install s-tui on Fedora

Source: https://github.com/amanusk/s-tui/blob/master/README.md

Install s-tui on Fedora using the dnf package manager.

```bash
sudo dnf install s-tui
```

--------------------------------

### Install s-tui with PyPI

Source: https://context7.com/amanusk/s-tui/llms.txt

Install s-tui using pip. Use the '[stress]' extra for numpy support for maximum stress performance.

```bash
pip install s-tui --user

pip install s-tui[stress] --user
```

--------------------------------

### Install s-tui on Arch Linux/Manjaro

Source: https://github.com/amanusk/s-tui/blob/master/README.md

Install s-tui from the Arch User Repository (AUR) using an AUR helper like yay.

```bash
sudo pacman -S s-tui
```

```bash
yay -S s-tui-git
```

--------------------------------

### Install s-tui on Ubuntu

Source: https://github.com/amanusk/s-tui/blob/master/README.md

Install s-tui on Ubuntu 18.10 and newer using the apt package manager.

```bash
sudo apt install s-tui
```

--------------------------------

### Install s-tui on older Ubuntu via PPA

Source: https://github.com/amanusk/s-tui/blob/master/README.md

Install s-tui on Ubuntu 18.04 and 16.04 using a PPA. Note that the PPA may not be up-to-date.

```bash
sudo add-apt-repository ppa:amanusk/python-s-tui
sudo apt-get update
sudo apt-get install python3-s-tui
```

--------------------------------

### Install numpy directly

Source: https://github.com/amanusk/s-tui/blob/master/README.md

Install the numpy library directly. This is an optional dependency that enhances the performance of s-tui's built-in CPU stress test.

```bash
pip install numpy
```

--------------------------------

### Custom Source Implementation

Source: https://context7.com/amanusk/s-tui/llms.txt

Example of creating a custom sensor source by inheriting from the base `Source` class. Requires implementing `update()` and other relevant methods.

```python
from s_tui.sources.source import Source
from collections import OrderedDict

class MyCustomSource(Source):
    def __init__(self):
        super().__init__()
        self.name = "MySource"
        self.measurement_unit = "Hz"
        self.available_sensors = ["Channel0", "Channel1"]
        self.last_measurement = [0.0, 0.0]
        self.sensor_available = [True, True]
        self.last_thresholds = [None, None]
        self.is_available = True

    def update(self):
        # Simulate hardware polling
        self.last_measurement = [1000.0, 1200.0]
        self.eval_hooks()           # evaluate any attached threshold hooks

    def get_top(self):
        return 2000.0               # max expected value for graph scaling

    def get_maximum(self):
        return max(self.last_measurement)

    def get_edge_triggered(self):
        return any(v > 1100.0 for v in self.last_measurement)

    def reset(self):
        self.last_measurement = [0.0, 0.0]

src = MyCustomSource()
src.update()
print(src.get_sensors_summary())    # OrderedDict([('Channel0', '1000.0'), ('Channel1', '1200.0')])
print(src.get_source_name())        # "MySource"
print(src.get_measurement_unit())   # "Hz"
print(src.get_is_available())       # True
```

--------------------------------

### Install s-tui via Distribution Packages

Source: https://context7.com/amanusk/s-tui/llms.txt

Install s-tui using your distribution's package manager. Available on Ubuntu, Debian, Arch Linux, Fedora, and OpenSUSE.

```bash
sudo apt install s-tui          # Ubuntu 18.10+, Debian 10+
sudo pacman -S s-tui            # Arch Linux / Manjaro
sudo dnf install s-tui          # Fedora
sudo zypper install s-tui       # OpenSUSE
```

--------------------------------

### s-tui display version

Source: https://github.com/amanusk/s-tui/blob/master/README.md

Display the installed version of s-tui.

```bash
s-tui --version
```

--------------------------------

### Get Sensor Summary and Top Processes

Source: https://context7.com/amanusk/s-tui/llms.txt

Retrieves a summary of sensor readings and lists the top resource-consuming processes.

```python
print(util.get_sensors_summary())
```

```python
print(util.get_top())   # 100  (percent)
```

--------------------------------

### Run s-tui from source

Source: https://github.com/amanusk/s-tui/blob/master/README.md

Execute the s-tui application by running its main Python file. This command starts the terminal user interface.

```bash
python -m s_tui.s_tui
```

--------------------------------

### Get s-tui CLI Snapshot (Plain Text)

Source: https://context7.com/amanusk/s-tui/llms.txt

Output a single snapshot of all sensor readings in a plain-text format. Useful for scripting or piping into other tools.

```bash
# Plain-text one-liner (sensor: key: value, ...)
s-tui --terminal
# Example output:
# Frequency: Avg: 2400, Core 0: 2400, Core 1: 2400, ...
# Temp: PackageId0,0: 52.0, Core0,0: 49.0, ...
# Util: Avg: 12.3, Core 0: 8.0, Core 1: 16.5, ...
# Power: Package-0,0: 8.3,
```

--------------------------------

### Get s-tui CLI Snapshot (JSON)

Source: https://context7.com/amanusk/s-tui/llms.txt

Output a single snapshot of all sensor readings in a structured JSON format. Ideal for programmatic parsing.

```bash
# Structured JSON snapshot
s-tui --json
# Example output:
# {
#     "Frequency": {"Avg": "2400", "Core 0": "2400"},
#     "Temp": {"PackageId0,0": "52.0", "Core0,0": "49.0"},
#     "Util": {"Avg": "12.3", "Core 0": "8.0"},
#     "Power": {"Package-0,0": "8.3"},
#     "Throttle": ""
# }

# Parse JSON with jq to extract current average frequency
s-tui --json | jq '.Frequency.Avg'
```

--------------------------------

### Check CPU Governor and EPP Settings

Source: https://context7.com/amanusk/s-tui/llms.txt

View available CPU governors and the current setting, as well as available Energy Performance Preference (EPP) values. This requires appropriate permissions or running as root.

```bash
# Check available governors and current setting
cat /sys/devices/system/cpu/cpu0/cpufreq/scaling_available_governors
# performance powersave

cat /sys/devices/system/cpu/cpu0/cpufreq/scaling_governor
# powersave

# Check available EPP values
cat /sys/devices/system/cpu/cpu0/cpufreq/energy_performance_available_preferences
# default performance balance_performance balance_power power
```

--------------------------------

### s-tui CLI options

Source: https://github.com/amanusk/s-tui/blob/master/README.md

Display help message and additional command-line options for s-tui. Use this to see all available arguments.

```bash
s-tui --help
```

--------------------------------

### Utility Functions for Output and System Info

Source: https://context7.com/amanusk/s-tui/llms.txt

Import and use various helper functions for terminal/JSON/CSV output, retrieving CPU names, formatting time, locating executables, reading files, and managing user configuration directories. Ensure necessary modules are imported before use.

```python
from s_tui.helper_functions import (
    output_to_terminal,
    output_to_json,
    output_to_csv,
    get_processor_name,
    seconds_to_text,
    kill_child_processes,
    get_user_config_dir,
    get_user_config_file,
    make_user_config_dir,
    which,
    cat,
)

# Get CPU model name (Linux/macOS/FreeBSD)
print(get_processor_name())
# "Intel(R) Core(TM) i7-9750H CPU @ 2.60GHz"

# Format seconds to HH:MM:SS stress timer display
print(seconds_to_text(3723))   # "01:02:03"
print(seconds_to_text(0))      # "00:00:00"

# Locate executables on PATH (returns None if not found)
print(which("stress"))         # "/usr/bin/stress" or None
print(which("stress-ng"))      # "/usr/bin/stress-ng" or None

# Read a sysfs/procfs file as bytes or text, with optional fallback
gov = cat("/sys/devices/system/cpu/cpu0/cpufreq/scaling_governor", binary=False)
print(gov)   # "powersave"

raw = cat("/sys/class/thermal/thermal_zone0/temp", fallback=b"0")
print(int(raw) / 1000)  # 51.0  (°C)

# Config directory helpers
print(get_user_config_dir())   # "/home/user/.config/s-tui"
print(get_user_config_file())  # "/home/user/.config/s-tui/s-tui.conf"
make_user_config_dir()         # creates ~/.config/s-tui/hooks.d/ if absent

# Print one-shot stats to stdout (used by --terminal / --json flags)
from s_tui.sources.freq_source import FreqSource
from s_tui.sources.temp_source import TempSource
from s_tui.sources.util_source import UtilSource

sources = [FreqSource(), TempSource(), UtilSource()]
output_to_terminal(sources)    # prints and calls sys.exit()
# output_to_json(sources)      # JSON variant
```

--------------------------------

### Launch s-tui with Options

Source: https://context7.com/amanusk/s-tui/llms.txt

Launch the interactive terminal interface with various options like disabling mouse, setting temperature thresholds, or adjusting refresh rates.

```bash
# Basic launch
s-tui

# Disable mouse (required on some TTY systems without X)
s-tui --no-mouse

# Set a custom temperature alert threshold (°C)
s-tui --t_thresh 75

# Set a faster refresh rate (seconds)
s-tui --refresh-rate 0.5
```

--------------------------------

### Monitor CPU Package Power with RaplPowerSource

Source: https://context7.com/amanusk/s-tui/llms.txt

Measures real-time CPU power draw in Watts. Requires Intel RAPL or AMD energy sysfs interfaces. Ensure the power source is available before updating.

```python
from s_tui.sources.rapl_power_source import RaplPowerSource
import time

power = RaplPowerSource()

if power.get_is_available():
    power.update()          # baseline probe
    time.sleep(2)
    power.update()          # compute watts from energy delta

    print(power.get_sensor_list())
    # ['Package-0,0']       # may include 'core', 'uncore', 'dram' domains

    print(power.get_sensors_summary())
    # OrderedDict([('Package-0,0', '8.3')])  # Watts

    print(power.get_measurement_unit())  # 'W'
else:
    print("RAPL not available (requires Intel 2nd gen+ or AMD Family 17h)")
```

--------------------------------

### Enable MSR-based throttle detection

Source: https://context7.com/amanusk/s-tui/llms.txt

Load the msr module and run s-tui with root privileges to enable detailed per-core throttle reasons. This method provides more granular insights into thermal throttling.

```bash
sudo modprobe msr
sudo s-tui
```

--------------------------------

### s-tui with temperature threshold

Source: https://github.com/amanusk/s-tui/blob/master/README.md

Run s-tui and set a custom high temperature threshold for alerts.

```bash
s-tui --t_thresh 85
```

--------------------------------

### CPU Temperature Monitoring

Source: https://context7.com/amanusk/s-tui/llms.txt

Monitors CPU temperatures using `psutil`. Sensors outside `[1.0, 127.0]°C` are skipped. Alerts are triggered when readings exceed thresholds.

```python
from s_tui.sources.temp_source import TempSource

# Default threshold (80°C)
temp = TempSource()

if temp.get_is_available():
    temp.update()
    print(temp.get_sensor_list())
    # ['PackageId0,0', 'Core0,0', 'Core1,0', 'Core2,0', 'Core3,0']

    print(temp.get_sensors_summary())
    # OrderedDict([('PackageId0,0', '52.0'), ('Core0,0', '49.0'), ...])

    print(temp.get_threshold_list())
    # [95.0, 95.0, 95.0, 95.0, 95.0]  (from sensor 'high' or default 80)

    # Check if any sensor is above its threshold (triggers hook scripts)
    print(temp.get_edge_triggered())  # False

    # Per-sensor alert coloring for urwid
    print(temp.get_sensor_alerts())
    # [None, None, None, None, None]  (None = normal color, 'high temp txt' = alert)

# Custom threshold (e.g. 70°C)
temp_strict = TempSource(temp_thresh=70)
temp_strict.update()
print(temp_strict.get_edge_triggered())  # True if any core > 70°C
```

--------------------------------

### Run s-tui

Source: https://github.com/amanusk/s-tui/blob/master/README.md

Execute the s-tui application from the terminal. Ensure the executable is in your system's PATH.

```bash
s-tui
```

--------------------------------

### s-tui with debug logging

Source: https://github.com/amanusk/s-tui/blob/master/README.md

Run s-tui with debug logging enabled. Debug output is saved to a file.

```bash
s-tui --debug --debug-file s-tui.log
```

--------------------------------

### Grant Write Access for Non-Root Power Profile Management

Source: https://context7.com/amanusk/s-tui/llms.txt

Allow non-root users to modify CPU governor and EPP settings by granting write permissions to the relevant sysfs files. Alternatively, run s-tui as root or use `powerprofilesctl` if available.

```bash
# Grant write access for non-root use (or run s-tui as root)
sudo chmod a+w /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor
sudo chmod a+w /sys/devices/system/cpu/cpu*/cpufreq/energy_performance_preference

# Or use powerprofilesctl (no root needed if the daemon is running)
powerprofilesctl set performance   # maps to EPP "performance"
powerprofilesctl set balanced      # maps to EPP "balance_performance"
powerprofilesctl set power-saver   # maps to EPP "power"
```

--------------------------------

### s-tui for short debug run

Source: https://github.com/amanusk/s-tui/blob/master/README.md

Run s-tui for 5 seconds with debug logging enabled, then automatically quit.

```bash
s-tui --debug_run
```

--------------------------------

### Clone s-tui repository

Source: https://github.com/amanusk/s-tui/blob/master/README.md

Clone the s-tui repository from GitHub to run the application from source code. This command downloads the project files.

```bash
git clone https://github.com/amanusk/s-tui.git
cd s-tui
```

--------------------------------

### Monitor Fan Speeds with FanSource

Source: https://context7.com/amanusk/s-tui/llms.txt

Polls all fan RPM sensors using psutil. Ensure fan sensors are detected before updating.

```python
from s_tui.sources.fan_source import FanSource

fans = FanSource()

if fans.get_is_available():
    fans.update()
    print(fans.get_sensor_list())
    # ['fan1,0', 'fan2,0']   or labeled names like ['CPU Fan', 'Chassis Fan']

    print(fans.get_sensors_summary())
    # OrderedDict([('fan1,0', '1200'), ('fan2,0', '850')])  (RPM)

    print(fans.get_measurement_unit())  # 'RPM'
else:
    print("No fan sensors detected (common in laptops or containers)")
```

--------------------------------

### Log s-tui sensor data to CSV

Source: https://context7.com/amanusk/s-tui/llms.txt

Continuously log all sensor readings to a CSV file while the TUI is running. Customize the output file and refresh rate for logging.

```bash
# Log to auto-named file: s-tui_log_YYYY-MM-DD_HH_MM_SS.csv
s-tui --csv

# Log to a specific file
s-tui --csv --csv-file /tmp/cpu_stress_run.csv

# Combine with a custom refresh rate for higher-resolution logging
s-tui --csv --csv-file thermal_test.csv --refresh-rate 1.0

# Resulting CSV columns:
# Time,Temp:PackageId0,0,Temp:Core0,0,Frequency:Avg,Frequency:Core 0,
# Util:Avg,Util:Core 0,Power:Package-0,0,Throttle
# 2024-05-01_14:23:01,52.0,49.0,2400,2400,12.3,8.0,8.3,
```

--------------------------------

### Threshold-Triggered Callbacks with Hook and ScriptHook

Source: https://context7.com/amanusk/s-tui/llms.txt

Run arbitrary callbacks or shell scripts when a sensor source exceeds its threshold, with a configurable cooldown. Hooks are fired if edge-triggered and ready.

```python
from s_tui.sources.hook import Hook
from s_tui.sources.hook_script import ScriptHook
from s_tui.sources.temp_source import TempSource

# 1. Python callback hook — fires at most once every 60 seconds
def on_overheat(args):
    print("ALERT: CPU temperature threshold exceeded!")

hook = Hook(callback=on_overheat, timeout_milliseconds=60_000)
print(hook.is_ready())   # True (fires immediately on first trigger)
hook.invoke()            # calls on_overheat(); sets ready_time = now + 60s
print(hook.is_ready())   # False (cooling down)

# 2. Shell script hook — runs ~/.config/s-tui/hooks.d/tempsource.sh
#    when temperature exceeds threshold, at most once every 30 seconds
script_hook = ScriptHook(
    path="/home/user/.config/s-tui/hooks.d/tempsource.sh",
    timeout_milliseconds=30_000
)

# 3. Attach to a TempSource — called automatically on every update()
temp = TempSource(temp_thresh=75)
temp.add_edge_hook(script_hook)

# Now every temp.update() call will invoke the script if temp > 75°C
# and the 30-second cooldown has expired

# Example hook script: ~/.config/s-tui/hooks.d/tempsource.sh
# #!/bin/bash
# notify-send "CPU Overheating" "Temperature exceeded threshold!"
# echo "$(date): OVERHEAT" >> /var/log/cpu_alerts.log
```

--------------------------------

### Auto-fix Lint and Formatting Issues

Source: https://github.com/amanusk/s-tui/blob/master/README.md

Applies automatic fixes for linting and formatting issues using ruff.

```bash
ruff check --fix .
ruff format .
```

--------------------------------

### s-tui with JSON output

Source: https://github.com/amanusk/s-tui/blob/master/README.md

Run s-tui to display statistics in JSON format on a single line.

```bash
s-tui --json
```

--------------------------------

### Enable s-tui Debug Logging

Source: https://context7.com/amanusk/s-tui/llms.txt

Enable debug output to diagnose issues. Logs can be directed to a default file or a specified file.

```bash
# Log debug output to the default file _s-tui.log
s-tui --debug

# Log to a named file
s-tui --debug --debug-file /tmp/stui-debug.log

# Run for ~8 seconds then auto-quit (used in CI/testing)
s-tui --debug_run
```

--------------------------------

### s-tui with CSV output

Source: https://github.com/amanusk/s-tui/blob/master/README.md

Run s-tui and save statistics to a CSV file. A default filename is used if none is specified.

```bash
s-tui --csv --csv-file s-tui_log.csv
```

--------------------------------

### Run Code Checks Manually

Source: https://github.com/amanusk/s-tui/blob/master/README.md

Executes linting, formatting checks, type checking, and tests using ruff, pyright, and pytest.

```bash
ruff check .          # lint
ruff format --check . # format check
pyright s_tui/        # type check
pytest                # tests
```

--------------------------------

### CPU Stress Testing with BuiltinStresser

Source: https://context7.com/amanusk/s-tui/llms.txt

Spawns multiprocessing worker processes to load CPU cores using numpy or hashlib strategies. Workers are cleanly stopped via a multiprocessing.Event.

```python
from s_tui.builtin_stresser import (
    BuiltinStresser,
    STRATEGY_NUMPY,
    STRATEGY_HASHLIB,
    get_default_strategy,
    strategy_available,
)
import time

print(get_default_strategy())        # 'numpy' if numpy installed, else 'hashlib'
print(strategy_available(STRATEGY_NUMPY))    # True / False
print(strategy_available(STRATEGY_HASHLIB))  # always True

stresser = BuiltinStresser()

# Start 4 workers using the best available strategy
stresser.start(num_workers=4)
print(stresser.is_running())    # True

time.sleep(10)                  # Let it run (watch temperatures rise)

# Start again with explicit strategy (e.g. hashlib for containers without numpy)
stresser.start(num_workers=2, strategy=STRATEGY_HASHLIB)
print(stresser.is_running())    # True

# Graceful shutdown: signal → join(3s) → terminate → kill
stresser.stop()
print(stresser.is_running())    # False
```

--------------------------------

### Restore s-tui Configuration to Defaults

Source: https://context7.com/amanusk/s-tui/llms.txt

To reset s-tui settings to their default values, simply remove the configuration file located at `~/.config/s-tui/s-tui.conf`.

```bash
# Restore defaults by removing the config file
rm ~/.config/s-tui/s-tui.conf
```

--------------------------------

### CPU Frequency and Throttle Detection

Source: https://context7.com/amanusk/s-tui/llms.txt

Polls CPU frequencies and detects thermal throttling using Intel MSR or sysfs. Throttled sensors change to an alert color.

```python
from s_tui.sources.freq_source import FreqSource

freq = FreqSource()

if freq.get_is_available():
    freq.update()

    sensors = freq.get_sensor_list()
    print(sensors)
    # ['Avg', 'Core 0', 'Core 1', 'Core 2', 'Core 3']

    readings = freq.get_reading_list()
    print(readings)
    # [2400.0, 2400.0, 2401.0, 2399.0, 2400.0]  (MHz, integer-formatted)

    # Throttle labels — empty string = not throttled
    suffixes = freq.get_sensor_suffixes()
    print(suffixes)
    # ['', '', '', '', '']       # no throttle
    # ['T', 'T', '', 'T', '']   # thermal throttle on Avg + cores 0,2 (MSR mode)
    # ['Tc', '', '', '', '']     # core thermal throttle (sysfs fallback)

    # Alert colors — None = normal, 'throttle txt' = throttle color
    alerts = freq.get_sensor_alerts()
    print(alerts)
    # [None, None, None, None, None]

    print(f"Max frequency: {freq.get_maximum()} MHz")
    print(f"Top (rated max): {freq.get_top()} MHz")
```

--------------------------------

### s-tui Configuration File Structure

Source: https://context7.com/amanusk/s-tui/llms.txt

This INI file stores TUI settings like refresh rate, UTF-8 smoothing, and graph visibility. It is automatically generated by `GraphController.save_settings()` and loaded on startup by `GraphController._load_config()`.

```ini
# ~/.config/s-tui/s-tui.conf
# Generated by s-tui; edit manually or use "Save Settings" in the TUI

[GraphControl]
refresh = 1.0       ; update interval in seconds
utf8 = True         ; enable smooth UTF-8 graph edges
tthresh = 75        ; temperature alert threshold (°C)

[Temp,Graphs]
packageid0,0 = True
core0,0 = True
core1,0 = False     ; hide this core from the graph

[Temp,Summaries]
packageid0,0 = True
core0,0 = True

[Frequency,Graphs]
avg = True
core 0 = True
core 1 = True

[Util,Graphs]
avg = True
core 0 = True
```

--------------------------------

### CPU Utilization Polling

Source: https://context7.com/amanusk/s-tui/llms.txt

Polls per-core CPU utilization percentages, mapping psutil's index to logical core IDs and marking offline cores as unavailable.

```python
from s_tui.sources.util_source import UtilSource

util = UtilSource()
util.update()   # first call initializes psutil's interval counter

import time; time.sleep(1)
util.update()   # subsequent calls yield meaningful percentages

print(util.get_sensor_list())
```

--------------------------------

### s-tui with terminal output

Source: https://github.com/amanusk/s-tui/blob/master/README.md

Run s-tui to display a single line of statistics in the terminal without the full TUI.

```bash
s-tui --terminal
```

--------------------------------

### Run s-tui without root privileges

Source: https://context7.com/amanusk/s-tui/llms.txt

Execute s-tui without root to utilize sysfs counter-based detection. This method still shows throttle status (Tc/Tp labels) when throttle counters increment, but without the detailed MSR information.

```bash
s-tui   # shows Tc/Tp labels when throttle counters increment
```

--------------------------------

### s-tui disable mouse

Source: https://github.com/amanusk/s-tui/blob/master/README.md

Run s-tui on TTY systems with mouse input disabled.

```bash
s-tui --no-mouse
```

--------------------------------

### Verify MSR readability

Source: https://context7.com/amanusk/s-tui/llms.txt

Use 'rdmsr' to check specific MSR registers, such as IA32_THERM_STATUS for core 0. This helps confirm that MSRs are accessible and provides raw data for throttle events (e.g., bit 4 for PROCHOT log, bit 12 for thermal throttle log). Requires root privileges.

```bash
sudo rdmsr -p 0 0x19C   # IA32_THERM_STATUS for core 0
# Bit 4 = PROCHOT log, bit 12 = thermal throttle log, etc.
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.