LoupixDeck

An open-source control deck application for Loupedeck and Razer Stream Controller devices.

Create custom touch pages, rotary controls, folders, macros and application-aware layouts on Windows and Linux—without the official vendor software. Experimental alpha builds are also available for macOS.

Built with Avalonia and .NET 10.

Download latest release · Read the user manual · Report a bug · Plugin SDK

---

Why LoupixDeck?

• Cross-platform: native support for Windows and Linux, including SteamOS, plus experimental macOS builds
• Your layout, your way: profiles, workspaces, pages, nested folders and per-page wallpapers
• Powerful controls: layered buttons, multiple states, rotary actions, macros and app-focus switching
• Multiple devices: use several supported controllers at the same time, even identical models
• Extensible: install integrations from the built-in Plugin Store or create your own
• Portable: export and share profiles, workspaces or individual pages as .loupixprofile packages
• Ready-made profiles: start with a device-sized template for everyday controls, a feature tour, media, OBS, Resolve or Home Assistant
• Multilingual: English, German and Spanish interfaces

Supported devices

Device	Status	Controls
Loupedeck Live	✅ Supported	4×3 touch grid, 2 touch strips, 6 dials, 8 round buttons
Loupedeck Live S	✅ Supported	5×3 touch grid, 2 dials, 8 physical buttons
Razer Stream Controller	✅ Supported	4×3 touch grid, 2 side panels, 6 dials, 8 LED buttons
Razer Stream Controller X	✅ Supported	5×3 physical key grid
Loupedeck CT	🚧 Partial	4×3 touch grid, wheel display, 6 dials and additional buttons

Loupedeck CT support is still being completed and needs more hardware testing. The Stream Controller X has physical keys instead of a touchscreen; LoupixDeck maps each key to the corresponding display position and supports press-and-hold actions.

Multiple devices can run in one LoupixDeck instance. Devices are separated by USB serial number and retain their own configuration.

Install

Release builds are self-contained—the .NET runtime is included.

Windows

Download the latest release and choose one of these packages:

Package	Recommended for
LoupixDeck-Setup-win-x64.exe	Normal installation
LoupixDeck-win-x64.zip	Portable use

For the portable version, extract the archive and run LoupixDeck.exe.

Download for Windows

Linux

Run the installer as your normal user—do not prefix the command with sudo:

curl -fsSL https://github.com/RadiatorTwo/LoupixDeck/releases/latest/download/install-loupixdeck.sh | bash

The installer downloads the latest release, installs LoupixDeck, configures the required device permissions and creates an application-menu entry. Start it from your application menu or run:

loupixdeck

If hardware access, macro input or the desktop integration does not work, open Settings → Diagnostics. The Linux-only Device Doctor runs read-only checks for the system, session, devices, input permissions, plugins and installation, then offers copyable repair commands and a sanitized Markdown report.

Inspect the installer before running it

curl -fsSLO https://github.com/RadiatorTwo/LoupixDeck/releases/latest/download/install-loupixdeck.sh
less install-loupixdeck.sh
bash install-loupixdeck.sh

Install the current master branch

This requires Git and the .NET 10 SDK:

bash install-loupixdeck.sh --from-source

Add --restart to close a running instance before installation and launch it again afterwards.

SteamOS

Use the same command in Konsole while in Desktop Mode. The installer automatically uses a SteamOS-compatible installation inside your home directory and registers the device-permission rule so it survives system updates.

Only the device-permission step needs administrator rights. If you have never configured a SteamOS password, run passwd first.

A Flatpak is not provided because sandboxing blocks hardware access, input simulation, application launching and functionality required by many plugins.

macOS (experimental alpha)

macOS support is an experimental alpha. It is not yet tested as thoroughly as Windows and Linux. Expect missing features and rough edges. Bug reports and hardware test results are very welcome.

Download the disk image for your Mac from the latest release:

Package	Recommended for
LoupixDeck-osx-arm64.dmg	Apple Silicon (M1 and later)
LoupixDeck-osx-x64.dmg	Intel Macs

Open the disk image and drag LoupixDeck into your Applications folder.

Macros and direct keyboard/mouse input need the Accessibility permission. LoupixDeck asks for it on first use; you can also grant it under System Settings → Privacy & Security → Accessibility. Without this permission, macOS silently discards the injected input.

Download for macOS

macOS builds are sponsored by Web Engineer (@web-engineer).

First steps

1. Connect a supported device and start LoupixDeck.
2. Open the Apps and Commands panel from the top-left corner.
3. Drag an application or command onto a button—or select a control and double-click the item.
4. Select a button to customize its image, text, symbol, actions and states.
5. Add profiles, workspaces, pages and folders as your setup grows.
6. Open Plugins from the hamburger menu, then choose Plugin Store to install integrations.

LoupixDeck can also start with no device connected. It opens the main window without asking for a model and waits for a supported deck to be plugged in.

On a fresh installation, a template picker opens when the first device connects. Later, use New profile from template… in the profile menu or Add profile from template… under Settings → Profiles. Templates add a new profile, enable their required plugins for the device, and offer the Plugin Store for missing ones. See Profile templates for setup details.

For a complete walkthrough, see the User Manual.

What you can build

Buttons and visual layouts

• Combine image, animated image, text and symbol layers
• Move and edit layers with a live preview
• Add outlines, colors, transparency and symbols from a curated list or the full Material Design Icons and Material Design Light sets
• Add custom SVG/image icon folders to the symbol picker; placed icons are copied into the app and can keep their own colors or take a tint
• Edit a touch button's command parameters together in the Parameters tab
• Use per-page wallpapers and optional touch feedback
• Give a button several named states with separate visuals and actions

Pages and folders

• Organize layouts as Profile → Workspace → Page
• Create nested custom folders in the Folders panel and drag them onto touch keys
• Navigate with breadcrumbs in the application and an automatic Back button on the device
• Use plugin-provided dynamic folders for live content such as audio sessions or OBS scenes

Rotary controls

• Assign separate actions to rotate left, rotate right, click and press
• Run multi-command sequences from any gesture
• Apply built-in, plugin-provided or user-created dial presets, grouped by source
• Assign related plugin actions as a group
• Use plugin adjustment commands for a whole dial, with tick-aware turning, a press action and live value indicators on side strips
• Use independent rotary pages where supported

Macros and direct input

The visual macro editor supports keyboard and mouse input, delays, commands, variables, conditions, loops, wait conditions and prompts.

For simpler actions, buttons and dials can directly send mouse clicks, scrolling, keyboard/mouse chords, key combinations and multi-step key sequences.

Platform	Input backend
Linux	uinput
macOS (alpha)	CGEventPost (needs the Accessibility permission)
Windows	SendInput
Windows	Optional Interception driver for raw-input applications

Application-aware layouts

LoupixDeck can automatically switch pages when the foreground application changes. Rules can match the process name and, optionally, part of the window title.

Platform	Status
Windows	✅ Supported
Linux X11 / XWayland	✅ Supported via xprop
Pure Wayland	❌ Not available—there is no common foreground-window protocol

Integrations

Built-in commands and plugins cover:

• OBS Studio via obs-websocket
• Elgato Key Lights
• Audio devices, per-application mixing and sound playback on Windows and Linux
• SteelSeries Sonar on Windows
• Twitch chat and stream control with on-button feedback on Windows
• KDE Plasma desktops, windows, Activities and session controls on Linux
• Media Session on Windows and MPRIS Media on Linux
• Home Assistant and PowerToys integrations from the Plugin Store
• Cooler Control and Linux hardware information
• Argus Monitor on Windows
• Shell commands, page navigation and device power
• Runtime text, color and button-state updates

More features

• Multi-device support: hot-plug devices and target them individually
• Companion devices: let companions mirror a master's profiles, workspaces and folders while keeping their own pages
• Portable profiles: export and import profiles, workspaces or pages
• Screensavers: use a video, GIF or plugin-provided renderer
• Native haptics: configure vibration effects on supported touch controls
• CLI automation: control a running instance from scripts and external tools
• Automatic recovery: corrupted configuration files are backed up before replacement

Screenshots

Keys can play animated GIF and WebP images or short video clips, and a page can use a looping video as its wallpaper (video needs ffmpeg). Every animation runs at the same time, and the page wallpaper continues across the side strips of the Razer Stream Controller.

Touch button editor	Action panel

Macro editor	Plugin Store

Plugins

Plugins can add commands, live text, settings pages, integrations, screensavers, dynamic folders and animated side strips.

Open the separate Plugins window from the hamburger menu. Its searchable installed list shows status and version, lets you choose the device being configured, and keeps plugin settings available even when no deck is connected. Enabling remains an explicit per-device action.

The Plugin Store page uses a searchable tile grid and one catalogue request to check published versions. You can read release notes on demand, install, update, remove or adopt a hand-copied plugin, cancel a download, and restart when a staged change needs it. Downloads are checked against their published checksums, while settings and missing command assignments survive updates or temporary removal.

Plugins can ship translations that follow the app's language immediately. Plugins reporting unmet system requirements are marked Needs attention, with repair hints and Check again; Linux Diagnostics includes those requirements too. App updates, plugin updates and requirements share the main-window notice area. The Store lists installed plugins with updates first.

Want to create a plugin?

• Plugin SDK repository
• LoupixDeck.PluginSdk on NuGet
• Plugin SDK documentation

Portable profiles

Export a complete profile, a workspace or a single page from Settings → Profiles or Settings → Pages; profile and workspace exports plus Import Package… are also available from the main-window header menus. Profile and workspace packages include their custom folders and, optionally, the pages of a master's companions.

Before importing, LoupixDeck shows missing plugins and commands, device compatibility warnings and macro-name conflicts. You can add the package as a copy or replace an existing item; replacement can automatically create a backup first.

The .loupixprofile format is a regular ZIP archive containing only the required configuration, macros and assets.

Importing from the Loupedeck software

Import Loupedeck profile… (header menu and Settings → Profiles) converts a .lp5 profile exported from the Logitech/Loupedeck software: workspaces, touch pages, dial pages (split into left and right columns on the Razer Stream Controller, with the dial icons drawn on the side strips), round buttons, key icons and captions. Keyboard shortcuts, multi-actions, page and workspace switches, application launches, mouse clicks and wheel, media and volume actions are translated, as are supported Audio, Home Assistant, Spotify and OBS actions. The preview names missing plugins and unsupported actions; unsupported keys retain their readable icon with a red Not imported placeholder. Controls that do not fit move to extra pages. An optional application link opens the imported profile automatically. See the import walkthrough for limits and setup.

CLI and automation

Start the LoupixDeck executable again while the application is running to send it a command:

# Linux and macOS (on macOS the executable is
# /Applications/LoupixDeck.app/Contents/MacOS/LoupixDeck)
./LoupixDeck nextpage
./LoupixDeck page 3
./LoupixDeck updatebutton 6 text=Build_OK backColor=LimeGreen
./LoupixDeck System.ObsStartRecord

# Target a specific device by serial number or name
./LoupixDeck --device A1B2C3 page 3
./LoupixDeck -d "Loupedeck Live S" nextpage

# Windows
.\LoupixDeck.exe nextpage
.\LoupixDeck.exe page 3
.\LoupixDeck.exe updatebutton 6 text=Build_OK backColor=LimeGreen

Platform	IPC endpoint
Linux	Unix domain socket $XDG_RUNTIME_DIR/loupixdeck_app.sock (normally /run/user/<uid>/; /tmp/loupixdeck-<uid>/ when there is no runtime directory)
macOS	Unix domain socket $TMPDIR/loupixdeck_app.sock (the per-user /var/folders/…/T/ directory)
Windows	Named pipe LoupixDeck_Pipe

Only the user running LoupixDeck can connect to the socket. Scripts can call the executable as above, or write to the socket directly: one UTF-8 command per connection, answered with a single text reply.

printf 'nextpage' | nc -U "$XDG_RUNTIME_DIR/loupixdeck_app.sock"   # Linux
printf 'nextpage' | nc -U "$TMPDIR/loupixdeck_app.sock"            # macOS

Build from source

Install the .NET 10 SDK, then clone the repository:

git clone https://github.com/RadiatorTwo/LoupixDeck.git
cd LoupixDeck

Linux

dotnet publish LoupixDeck.csproj -c Release -r linux-x64 --self-contained true \
  /p:PublishSingleFile=true \
  /p:PublishTrimmed=false \
  /p:EnableCompressionInSingleFile=true \
  /p:ReadyToRun=true \
  -o publish/linux-x64

Windows

dotnet publish LoupixDeck.csproj -c Release -r win-x64 --self-contained true `
  /p:PublishSingleFile=true `
  /p:PublishTrimmed=false `
  /p:EnableCompressionInSingleFile=true `
  /p:ReadyToRun=true `
  -o publish/win-x64

Manual Linux device and macro permissions

The installer configures these permissions automatically. For a manual source installation, macro execution needs write access to /dev/uinput, and macro recording needs read access to /dev/input/event*.

Create a uinput rule:

KERNEL=="uinput", SUBSYSTEM=="misc", GROUP="input", MODE="0660", OPTIONS+="static_node=uinput"

Add your user to the input group, then log out and back in:

sudo usermod -aG input "$USER"

If the device itself is inaccessible, add rules for its VID/PID:

Device	VID:PID
Loupedeck Live	2ec2:0004
Loupedeck Live S	2ec2:0006
Loupedeck CT	2ec2:0003 / 2ec2:0007
Razer Stream Controller	1532:0d06
Razer Stream Controller X	1532:0d09

Example for Loupedeck Live S:

SUBSYSTEM=="usb", ATTRS{idVendor}=="2ec2", ATTRS{idProduct}=="0006", MODE="0666"
SUBSYSTEM=="tty", ATTRS{idVendor}=="2ec2", ATTRS{idProduct}=="0006", MODE="0666"

The Stream Controller X also needs access to its HID interface:

SUBSYSTEM=="hidraw", ATTRS{idVendor}=="1532", ATTRS{idProduct}=="0d09", MODE="0666"

Reload the rules and reconnect the device:

sudo udevadm control --reload-rules
sudo udevadm trigger

Debugging without a device

Any supported model can run as a virtual device, with no hardware attached:

./LoupixDeck --virtual-device loupedeck-ct
# or
LOUPIXDECK_VIRTUAL_DEVICE=loupedeck-ct ./LoupixDeck

Device	Slug
Loupedeck Live	loupedeck-live
Loupedeck Live S	loupedeck-live-s
Loupedeck CT	loupedeck-ct
Razer Stream Controller	razer-stream-controller
Razer Stream Controller X	razer-stream-controller-x

The app runs exactly as with real hardware, but nothing is sent to a serial port. A simulator window shows the frames the app sends, decoded from the same bytes the panel would receive. It also shows the LED colours, the brightness and the vibration. The simulator also takes input:

• Click or drag on a screen to touch it. On the Stream Controller X, a click presses the key.
• Scroll over a dial or the CT wheel to turn it.
• Click a dial or button to press it. Hold the click to hold the press.

The window opens on its own and can be reopened from the main menu. The option works in Release builds and on every platform. It runs alongside any connected devices.

The virtual device uses its own configuration file (config_<slug>_VIRTUAL.json) and never changes the configuration of a real device.

Troubleshooting

Enable managed crash logging:

./LoupixDeck --crashlog

Logs are written to the LoupixDeck user configuration directory. For very noisy first-chance exception logging, use --firstchance. Native crashes require the .NET minidump environment variables instead.

On Linux, run Settings → Diagnostics first for device access, udev, uinput, input-recording, D-Bus, Plugin Store and installation checks. Individual checks and categories can be rerun after applying a suggested fix.

For setup and usage help, check the User Manual or open an issue.

Optional Interception driver on Windows

The optional Interception driver can inject keyboard and mouse input at driver level for applications that read raw input.

• It is not bundled with LoupixDeck.
• It is downloaded only when installed from Settings.
• It is free for non-commercial use; commercial use requires a separate license from its author.
• Without it, macros use the standard Windows SendInput backend.

Contributing

Bug reports, hardware testing, translations, documentation improvements and pull requests are welcome.

Please read CONTRIBUTING.md before submitting a change. If you are unsure whether an idea fits the project, open an issue first.

Project status

LoupixDeck is actively developed and suitable for daily use on the fully supported devices listed above. Loupedeck CT support remains experimental while its remaining controls are implemented and verified. macOS support is an experimental alpha.

Credits

macOS builds are sponsored by Web Engineer (@web-engineer).

License

LoupixDeck is available under the MIT License. Third-party components remain subject to their own licenses.

The Loupedeck profile import is a C# port of loupedeck-to-loupixdeck by Vencite, used under the MIT License (Copyright (c) 2026 Vencite).

The bundled icon fonts come from Pictogrammers: Material Design Icons under the Pictogrammers Free License, Material Design Light under the SIL Open Font License 1.1. tools/UpdateMdiFont/update-mdi-font.ps1 checks and updates both fonts.