SC Controller

User-mode driver, mapper and GTK3 based GUI for Steam Controller, DS4 and many other controllers.

Features

• Allows to setup, configure and use the Steam Controller without ever launching Steam
• Connect multiple controllers at the same time, each with its own remembered profile
• Supports profiles switchable in GUI or with controller button
• Stick, Pads and Gyroscope input
• Steam Controller 2 (2026) support, including its capacitive stick-touch and grip sensors — bind actions to them directly, or use them as conditions in mode-shift combinations
• Haptic Feedback and in-game Rumble support
• OSD, Menus, On-Screen Keyboard for desktop and in games.
• Automatic profile switching based on active window.
• Macros, button cycling, rapid fire, modeshift, mouse regions, …
• Emulates Xbox360 controller, mouse, trackball and keyboard.

Based on Standalone Steam Controller Driver by Ynsta.

Using multiple controllers

SC Controller can drive several controllers at once — Steam Controllers (v1 and v2), a DualShock 4 and others can all be connected together.

• One window, two bars: pick the controller, then its profile. Just connect them: a controller-selector bar lists every connected controller (by type, numbered when you have more than one of the same model) together with its current profile; choosing one shows it on the big controller image, and a second bar sets that controller's profile. There is no separate window per device. The controller that connected first is the primary one — it is the one drawn by default and the target when a command (a menu, the OSD) does not name a specific controller.
• Each controller keeps its own profile. Selecting a controller and setting a profile applies only to that controller. The choice is remembered and restored automatically the next time that controller connects, so you do not have to re-pick it every session.
• Disconnecting is safe. Turning one controller off (or letting it go idle) leaves the window and the other controllers untouched; when it comes back it returns to its remembered profile.

Two Steam Controller v1s and a Steam Controller v2 connected at once: the selector at the top lists each controller — numbered when there are duplicates — alongside its current profile.

Telling controllers apart

How a controller is identified — and therefore which remembered profile and per-controller settings it gets — is governed by Use Serial Numbers to Identify Controllers in Settings:

• Off (default): controllers are identified by connection order (first connected, second connected, …). This is simplest for a fixed setup, but if you change which controller powers on first they will swap profiles.
• On: each controller is identified by its own hardware serial number, so its profile and settings follow the physical device no matter what order things connect in.

Turn this on when you regularly use more than one controller — especially two of the same model, such as two Steam Controllers — and want each to reliably keep its own profile.

Like what I'm doing?

You can check out the ways to donate on my website, or just go straight to my Ko-Fi.

Donation links for kozec, who is the original developer, can be found on the old upstream repository.

Packages

Linux:

• Arch Linux: Found in official extra repository and AUR/sc-controller-git
• Ubuntu (22.04-jammy, 24.04-noble): Packaged as AppImage in GitHub releases, which may also run fine on other operating systems - jammy image is currently the most compatible one
• Gentoo: Packaged as game-util/sc-controller
• Void Linux: Packaged as sc-controller - Run xbps-install -S sc-controller in a terminal, points to archived Ryochan7's fork at the time of writing
• Others: You can attempt to use one of the AppImages (try all, AppImages built on older distributions tend to work better), or a package meant for your parent distribution if applicable. Flatpak is planned.

AppImage: install the udev rules

The AppImage is self-contained but cannot install the udev rules it needs (those live in a system directory). Without them your user can't access the controller and SC Controller can't create the virtual gamepad (/dev/uinput), so a detected controller appears to "do nothing". Distro packages install these rules for you; AppImage users must do it once, by hand:

1. Download 69-sc-controller.rules from the latest release.
2. Copy it into place — this needs sudo:

   sudo cp 69-sc-controller.rules /etc/udev/rules.d/69-sc-controller.rules

3. Reload and re-apply the rules:

   sudo udevadm control --reload-rules && sudo udevadm trigger

4. Unplug and replug the controller (or its wireless dongle) — or reboot.

Only the AppImage needs this; the Arch and other distro packages already ship these rules. The Steam Deck doesn't need it either — SteamOS already ships udev rules for Steam devices, so the AppImage works out of the box there.

Windows:

• It should be possible to get it running as per the wiki, but this is untested and might be broken, report a bug if so

Building the package by yourself

Dependencies

• Python 3.9+
• GTK 3.24+
• PyGObject
• python-gi-cairo and gir1.2-rsvg-2.0 on Debian-based distributions (included in PyGObject elsewhere)
• setuptools
• python-evdev
• python-pylibacl
• python-vdf
• python-libusb1
• python-ioctl-opt
• gtk-layer-shell

Via Python into a local build directory

• Download and extract latest release .zip releases without .git directory are currently broken - tracked in #50
• Clone the repository git clone https://github.com/C0rn3j/sc-controller.git and navigate into it: cd sc-controller
• python3 -m build --wheel
• python3 -m installer --destdir="./build" dist/*.whl
• Run the app via: SCC_SHARED="${PWD}" PYTHONPATH="./build/usr/lib/python3.12/site-packages" PATH="${PWD}/build/usr/bin:${PATH}" ./build/usr/bin/sc-controller

Via Docker

A test build with Docker can be created using the following way:

docker build -o build-output --build-arg BASE_CODENAME=noble .

Via Python venv through run.sh

• Download and extract latest release .zip releases without .git directory are currently broken - tracked in #50
• Clone the repository git clone https://github.com/C0rn3j/sc-controller.git and navigate into it: cd sc-controller
• Optionally checkout a branch or a tag, like python3(default) or v0.4.9.8.8
• Execute ./run.sh, this automatically builds the project into a venv called .env, activates it and runs sc-controller, which in turn runs scc-daemon if one does not run already
• If you are debugging an issue, running ./run.sh daemon first will launch the daemon in debug mode, allowing you to launch sc-controller in another terminal with ./run.sh