Skip to content

Linux Installation

Jump to bottom
oxGorou edited this page Jun 11, 2026 · 15 revisions

Linux Installation

This page covers everything from a fresh system to a working UXTU4Linux setup. Follow the steps in order.

1. System requirements

Before you start, make sure you have:

  • Linux, any distro with systemd. OpenRC, runit and other init systems work with manual daemon startup (see Non-systemd setup).
  • Python 3.10 or newer. Most distros from 2022 onward ship this. Check with python3 --version. The install script can install it for you if it's missing.
  • Root / sudo access, needed for the daemon service and the kernel module.
  • An AMD Ryzen APU or desktop CPU. Intel is not supported. If you're not sure whether your CPU is supported, install the app and run it; hardware detection will tell you.

2. Install the ryzen_smu kernel module

The daemon communicates with the CPU through the ryzen_smu kernel module. Without it, no preset can be applied. Do this part first, the rest is quick.

The minimum required version is 0.1.7.

2.1 Install build dependencies

You need cmake, gcc, g++ (or gcc-c++), dkms and openssl. DKMS rebuilds the module automatically when your kernel updates, so you only do this once.

Debian / Ubuntu / Linux Mint / Pop!_OS:

sudo apt update
sudo apt install cmake gcc g++ dkms openssl

Fedora:

sudo dnf install cmake gcc gcc-c++ dkms openssl

AlmaLinux / Rocky Linux 9:

sudo dnf install epel-release
sudo dnf install cmake gcc gcc-c++ dkms openssl

DKMS lives in EPEL on RHEL-based systems, so epel-release has to go in first. On RHEL itself you also need the CodeReady Builder repo enabled through subscription-manager.

CentOS Stream 9:

sudo dnf config-manager --set-enabled crb
sudo dnf install epel-release
sudo dnf install cmake gcc gcc-c++ dkms openssl

Arch Linux / Manjaro / EndeavourOS:

sudo pacman -S cmake gcc dkms openssl

openSUSE Tumbleweed / Leap:

sudo zypper install cmake gcc gcc-c++ dkms openssl

Void Linux:

sudo xbps-install -S cmake gcc dkms openssl

Gentoo:

sudo emerge --ask dev-build/cmake sys-kernel/dkms dev-libs/openssl

2.2 Build and install ryzen_smu

For more information, visit ryzen_smu

git clone https://github.com/amkillam/ryzen_smu
cd ryzen_smu
sudo make dkms-install

This registers the module with DKMS and builds it for your running kernel. On future kernel updates, DKMS rebuilds it automatically.

Verify the build succeeded:

sudo modprobe ryzen_smu
lsmod | grep ryzen_smu

You should see ryzen_smu in the output. If modprobe fails with "Operation not permitted" or a signature error, continue to the Secure Boot section below.

2.3 Secure Boot

If Secure Boot is enabled, the kernel refuses to load unsigned modules. Check whether Secure Boot is active:

mokutil --sb-state

If it says SecureBoot enabled, you need to enroll the DKMS signing key that was created during make dkms-install.

Enroll the key:

sudo mokutil --import /var/lib/dkms/mok.pub

This asks you to set a one-time password. Pick something you can type on the next boot, you'll need it in the MOK manager.

Reboot:

sudo reboot

On the next boot a blue MOK Manager screen appears. It only shows for a few seconds, so watch for it. Select:

  1. Enroll MOK
  2. Continue
  3. Yes to confirm enrollment
  4. Enter the one-time password you set
  5. Reboot

After booting back in, verify the module loads:

sudo modprobe ryzen_smu
lsmod | grep ryzen_smu

If the MOK manager screen never appeared, check that your firmware has MOK support enabled. Some firmwares call it "UEFI Secure Boot Key Management" or similar. On most consumer laptops it's available in the BIOS/UEFI settings.

2.4 Verify ryzen_smu is working

Check the sysfs interface the module exposes:

ls /sys/kernel/ryzen_smu_drv/

You should see files like drv_version, codename, pm_table, rsmu_cmd, mp1_smu_cmd, smn, smu_args. If the directory exists and isn't empty, the module is working.

Check the version:

cat /sys/kernel/ryzen_smu_drv/drv_version

It should be 0.1.7 or higher.

3. Install UXTU4Linux

With ryzen_smu in place, install the app:

curl -fsSL https://raw.githubusercontent.com/HorizonUnix/UXTU4Linux/main/install.sh | bash

Run it as your normal user, not as root (the script refuses to run under sudo and asks for it only where needed).

The installer:

  • Installs dmidecode, wget, unzip and curl through your package manager (apt, dnf, yum, pacman or zypper), plus Python 3.10+ if your system doesn't have it
  • Downloads the latest release and puts the app at /opt/uxtu4linux/src/
  • Creates a Python virtual environment at /opt/uxtu4linux/venv/ and installs pyzmq into it
  • Creates the launcher at /usr/local/bin/uxtu4linux
  • If a previous installation exists, updates the files and restarts the daemon

The systemd service is not created by the install script. The first-run setup wizard does that, so you get to see and confirm it.

If your distro uses a package manager the script doesn't know (Void, Gentoo, NixOS, ...), see Manual installation below.

If you skipped the dependency step or want to install dmidecode yourself:

sudo apt install dmidecode        # Debian / Ubuntu / Mint / Pop!_OS
sudo dnf install dmidecode        # Fedora / RHEL family
sudo pacman -S dmidecode          # Arch / Manjaro / EndeavourOS
sudo zypper install dmidecode     # openSUSE
sudo xbps-install -S dmidecode    # Void
sudo emerge --ask sys-apps/dmidecode   # Gentoo

Verify it works:

sudo dmidecode -t processor | head -20

You should see your CPU information. If it's blank or errors out, check whether your system firmware exposes DMI data (almost all do).

4. First run

uxtu4linux

The setup wizard runs automatically the first time.

Step 1, Welcome: just an intro screen. Press Enter to continue.

Step 2, Background Daemon: the wizard installs and starts the systemd service. If it's already running you can skip this step or restart it. Wait for the "Daemon is running" confirmation before continuing. On systems without systemd, the wizard shows you the exact command to run in another terminal and waits up to 2 minutes for the daemon to come up.

Step 3, Your Hardware: the app detects your CPU family, architecture and type, and shows which preset profile will be used. If your CPU is supported you'll see something like Family: HawkPoint, Type: Amd_Apu. If it shows Unknown, see Linux Troubleshooting.

Once setup finishes, you land on the main menu. Go to Power Management to apply your first preset.

5. Non-systemd setup

On distros using OpenRC, runit, s6 or no service manager at all, start the daemon manually.

Open a terminal and run:

uxtu4linux

Wait until UXTU4Linux successfully sets up the Python virtual environment. Once this is complete, you will be prompted to run the following command in a new terminal:

sudo /opt/uxtu4linux/venv/bin/python3 /opt/uxtu4linux/src/Assets/Modules/daemon.py

To have the daemon start automatically without systemd, add it to your init system. The exact method depends on your distro.

OpenRC example (/etc/init.d/uxtu4linux):

#!/sbin/openrc-run
command="/opt/uxtu4linux/venv/bin/python3"
command_args="/opt/uxtu4linux/src/Assets/Modules/daemon.py"
command_background=true
pidfile="/run/${RC_SVCNAME}.pid"

Make it executable and enable it:

sudo chmod +x /etc/init.d/uxtu4linux
sudo rc-update add uxtu4linux default
sudo rc-service uxtu4linux start

6. Manual installation

If you don't want to use the install script:

# Get the app. Either clone the repo:
git clone https://github.com/HorizonUnix/UXTU4Linux.git
# or download the release zip and unzip it. Either way you end up with a
# directory containing UXTU4Linux.py and Assets/.

# Create the venv and install pyzmq
sudo python3 -m venv /opt/uxtu4linux/venv
sudo /opt/uxtu4linux/venv/bin/python3 -m pip install pyzmq

# Copy the app files (the inner UXTU4Linux folder, the one with UXTU4Linux.py in it)
sudo cp -r UXTU4Linux/UXTU4Linux /opt/uxtu4linux/src

# The TUI runs as your user and writes its config into Assets/, so own the files
sudo chown -R "$USER" /opt/uxtu4linux/src

# Create the launcher. It must use the venv Python, since pyzmq lives there.
sudo tee /usr/local/bin/uxtu4linux > /dev/null << 'EOF'
#!/usr/bin/env bash
exec "/opt/uxtu4linux/venv/bin/python3" "/opt/uxtu4linux/src/UXTU4Linux.py" "$@"
EOF
sudo chmod +x /usr/local/bin/uxtu4linux

For systemd, create /etc/systemd/system/uxtu4linux.service:

[Unit]
Description=UXTU4Linux Power Management Daemon
After=multi-user.target

[Service]
Type=simple
ExecStart=/opt/uxtu4linux/venv/bin/python3 /opt/uxtu4linux/src/Assets/Modules/daemon.py
Restart=on-failure
RestartSec=5
StandardOutput=journal
StandardError=journal

[Install]
WantedBy=multi-user.target

Enable and start it:

sudo systemctl daemon-reload
sudo systemctl enable --now uxtu4linux.service

You can also skip writing the unit file by hand: run uxtu4linux and let the setup wizard create it.

7. Updating

The app checks GitHub for the latest version and shows the changelog if a newer one is available. The update backs up your config.ini and custom.json, replaces the app files, restores your settings, restarts the daemon and relaunches the TUI.

You can also force an update to the latest stable or the latest beta build from About.

Re-running the install script also works as an update; it replaces the app files and restarts the daemon while leaving the venv and service alone.

Report an issue · Releases

Home

Getting started

Using the app

Internals

Clone this wiki locally