Corsair Novablade Pro & 8Bitdo Pro 2 Controllers Get Native Support in Linux 7.3-Rc7

Hey there, homelabbers! Welcome back to Self-Hosted Tech. When we talk about self-hosting, homelabs, and local AI, our minds usually jump straight to Docker containers, Proxmox clusters, Kubernetes manifests, and Ollama models running on repurposed GPUs. But today, we’re taking a slight detour into a category that is just as important to the modern homelabber: hardware and gaming.

If you’re anything like me, your homelab isn’t just a sterile rack of blinking lights. It’s a powerhouse. You might be running a local AI model to upscale your retro game textures, or perhaps you’ve set up a self-hosted cloud gaming rig using Sunshine and Moonlight to stream your Steam library to your living room TV. If that’s the case, you know the pain of trying to get premium game controllers to play nice with Linux.

Well, I’ve got some fantastic news for you. The upcoming Linux kernel 7.3-Rc7 is dropping, and it brings native, out-of-the-box support for two of the best controllers on the market: the 8Bitdo Pro 2 and the highly anticipated Corsair Novablade Pro.

Let’s dive into what this means for your self-hosted gaming setups, why mainline kernel support is a massive win, and how you can get these controllers up and running on your Linux server today.

Why Native Kernel Support is a Game-Changer

Before we look at the controllers themselves, let’s talk about why a kernel update—specifically a release candidate like 7.3-Rc7—matters so much.

In the past, connecting a modern Bluetooth controller to a Linux machine meant relying on user-space tools, third-party daemons, and community-maintained drivers like xpadneo, steam-input, or joydev wrappers. While these tools are brilliant pieces of community engineering, they introduce extra latency, consume CPU cycles, and are notoriously fragile. A simple kernel update could break your controller mapping, leaving you unable to play your favorite self-hosted emulator games.

With Linux 7.3-Rc7, the maintainers have merged new HID (Human Interface Device) drivers directly into the mainline kernel.

Here is what that means for you:

• Zero-Configuration Pairing: Plug and play is finally a reality. Once the kernel recognizes the device, the input events are mapped correctly without needing extra software.
• Lower Latency: Because the driver runs in kernel space, the communication between the controller and your system bypasses the user-space translation layers. This results in snappier, more responsive gameplay.
• Battery Reporting: Native HID drivers can accurately poll the battery levels of wireless controllers, allowing your system to warn you before your controller dies in the middle of a boss fight.
• Rumble and Haptic Feedback: Force feedback is natively supported, meaning those subtle vibrations in racing games or action RPGs will work flawlessly in your LXC containers or VMs.

Meet the Controllers

The 8Bitdo Pro 2: The Homelabber’s Swiss Army Knife

If you’ve spent any time in the retro-gaming or emulation communities, you know the 8Bitdo Pro 2. It is arguably the most versatile controller ever made. It features an asymmetric layout similar to an Xbox controller, but includes a classic D-pad that is perfect for SNES, Genesis, and arcade emulation.

It supports Bluetooth, USB-C wired connections, and even has a 2.4GHz wireless dongle (sold separately) for ultra-low latency. It also features two extra back buttons (L3 and R3) that can be mapped to whatever you want.

With Linux 7.3-Rc7, the kernel now perfectly understands the 8Bitdo Pro 2’s various input modes (X-Input, S-Input, and D-Input). You no longer have to guess which mode you need to be in before pairing. The new hid-8bitdo driver handles the handshake seamlessly.

The Corsair Novablade Pro: Premium Performance

The Corsair Novablade Pro is a newer, high-end entrant to the controller market, and it’s built for enthusiasts. It boasts Hall Effect joysticks (meaning no stick drift, ever), mechanical face buttons, and customizable trigger stops. It’s the kind of controller you want to use when playing modern, demanding titles streamed from your homelab to a thin client.

Previously, connecting the Novablade Pro to Linux required jumping through hoops, often forcing users to run it through a Windows VM via PCIe passthrough just to get the proprietary Corsair software to recognize it. Linux 7.3-Rc7 introduces the hid-corsair-novablade driver. This driver not only maps the standard inputs but also exposes the controller’s extra paddles and trigger stops as standard evdev events, making them mappable in Steam Input or RetroArch without needing a Windows VM.

How This Impacts Your Self-Hosted Setup

So, how does this tie back into our usual topics of homelabs and local AI?

Imagine this workflow: You are running a local AI model on your server’s GPU to upscale textures for a GameCube game. You compile those textures and drop them into a Docker container running RetroArch. You then stream that container’s display via Moonlight to a Raspberry Pi connected to your living room TV.

Before kernel 7.3-Rc7, the weak link in that chain was often the controller. You’d have to run bluetoothctl, pair the 8Bitdo Pro 2, realize the D-pad wasn’t working, switch the controller to X-input mode, re-pair it, and hope the udev rules didn’t conflict.

Now, the entire pipeline is self-hosted, low-latency, and completely automated. The kernel handles the AI texture loading (via GPU compute), the container handles the game, Moonlight handles the stream, and the native kernel driver handles your Corsair Novablade Pro or 8Bitdo Pro 2. It’s a beautiful thing.

Practical Walkthrough: Setting Up Your Controllers on Linux 7.3-Rc7

Let’s get our hands dirty. If you want to test this out on your homelab server or a Linux desktop acting as your self-hosted gaming rig, here is a practical walkthrough on updating to the RC kernel, pairing your controllers, and verifying the inputs.

Note: Since 7.3-Rc7 is a release candidate, it is bleeding-edge. I highly recommend testing this on a secondary machine or a disposable Proxmox VM before rolling it out to your primary production server.

Step 1: Installing the 7.3-Rc7 Kernel

Depending on your distribution, installing a release candidate kernel varies. If you are on Ubuntu or Debian, you can use the mainline tool. If you are on Arch Linux, you can grab it from the linux-rc repository.

Here is how you would do it on an Ubuntu-based system:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# Update your current packages
sudo apt update && sudo apt upgrade -y

# Install the mainline kernel tool
sudo apt install mainline

# Fetch and install the 7.3 release candidate 7
sudo mainline --install 7.3-rc7

# Once installed, reboot your system
sudo reboot

After rebooting, verify you are running the new kernel:

1
2

uname -r
# Output should be: 7.3.0-rc7-generic

Step 2: Pairing via Bluetooth

Since both the 8Bitdo Pro 2 and the Corsair Novablade Pro shine in wireless mode, we need to pair them using bluetoothctl. Make sure your Bluetooth daemon (bluetoothd) is running and that you have bluez installed.

Put your controller into pairing mode. For the 8Bitdo Pro 2, hold the Pair button on the back. For the Corsair Novablade Pro, hold the Bluetooth button until the LED flashes.

Now, open your terminal:

1

bluetoothctl

You will be dropped into the interactive Bluetooth prompt. Run the following commands:

1
2
3
4

[bluetooth]# power on
[bluetooth]# agent on
[bluetooth]# default-agent
[bluetooth]# scan on

Wait a few seconds. You should see your controller pop up in the scan results with its MAC address (e.g., XX:XX:XX:XX:XX:XX).

1
2
3

[bluetooth]# pair XX:XX:XX:XX:XX:XX
[bluetooth]# trust XX:XX:XX:XX:XX:XX
[bluetooth]# connect XX:XX:XX:XX:XX:XX

If the kernel driver is working correctly, you should see a message indicating the device has been successfully connected and configured. You can now exit the utility:

1

[bluetooth]# quit

Step 3: Verifying Inputs with evtest

To make sure the native kernel driver is actually translating your button presses into Linux input events, we use a tool called evtest. This is a lifesaver for debugging controller issues in homelabs.

Install it if you haven’t already:

1

sudo apt install evtest

Now, run it. You’ll be presented with a list of all input devices currently registered on your system. Look for your controller on the list (it will usually be named something like “8Bitdo Pro 2” or “Corsair Novablade Pro”).

1
2

sudo evtest
# Select the device number corresponding to your controller

Once selected, start pressing buttons, moving joysticks, and pulling triggers on your controller. You will see a stream of output in your terminal that looks something like this:

1
2
3
4
5

Event: time 1715223434.123456, type 1 (EV_KEY), code 304 (BTN_A), value 1
Event: time 1715223434.123456, -------------- SYN_REPORT ------------
Event: time 1715223434.134567, type 1 (EV_KEY), code 304 (BTN_A), value 0
Event: time 1715223434.134567, -------------- SYN_REPORT ------------
Event: time 1715223435.145678, type 3 (EV_ABS), code 0 (ABS_X), value 1234

If you see these events, congratulations! The Linux 7.3-Rc7 kernel is successfully reading your inputs natively. No extra drivers, no wrappers, no fuss.

Step 4: Passing the Controller to a Docker Container

If you are running your emulators or games inside a Docker container (like the excellent linuxserver/retroarch image), you need to pass the input device into the container.

First, find the input event number assigned to your controller:

1
2

ls -l /dev/input/
# Look for eventX, where X is the number assigned to your controller

When you spin up your container, pass that device through using the --device flag:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

docker run -d \
  --name=retroarch \
  -e PUID=1000 \
  -e PGID=1000 \
  -v /path/to/roms:/roms \
  -v /path/to/bios:/bios \
  --device /dev/input/eventX \
  --device /dev/input/js0 \
  -p 80:80 \
  --restart unless-stopped \
  lscr.io/linuxserver/retroarch:latest

Because the kernel is handling the low-level driver work, the container just sees a standard Linux joystick. RetroArch will instantly recognize it, and you can map your buttons directly in the RetroArch GUI.

Troubleshooting and Udev Rules

Even with mainline kernel support, Linux permissions can sometimes get in the way. If you find that your controller works in evtest but doesn’t work inside your container or a specific application, it’s likely a udev permissions issue.

By default, input devices are owned by root and the input group. If your container or user doesn’t have access to the input group, it won’t be able to read the controller.

You can create a custom udev rule to ensure your controllers always get the right permissions when connected.

Create a new rule file:

1

sudo nano /etc/udev/rules.d/99-controllers.rules

Add the following lines to grant read/write access to everyone (useful for homelab servers, though you might want to lock this down on a multi-user desktop):

1
2
3
4
5

# 8Bitdo Pro 2
SUBSYSTEM=="input", ATTRS{name}=="8BitDo Pro 2", MODE="0666"

# Corsair Novablade Pro
SUBSYSTEM=="input", ATTRS{name}=="Corsair Novablade Pro", MODE="0666"

Save the file and reload the udev rules:

1
2

sudo udevadm control --reload-rules
sudo udevadm trigger

Disconnect and reconnect your controller. It should now have the proper permissions, and your self-hosted applications should be able to read the inputs without requiring root privileges.

Summary

The Linux kernel continues to impress, and the 7.3-Rc7 release is no exception. By bringing native, mainline HID support for the 8Bitdo Pro 2 and the Corsair Novablade Pro, the kernel maintainers have made self-hosted gaming on Linux infinitely more accessible.

No more relying on fragile user-space wrappers or dedicating an entire Windows VM just to run your controller software. Whether you’re building a retro emulation powerhouse in a Docker container, streaming AAA games to your living room via Moonlight, or just playing around with AI-upscaled game textures, these native drivers ensure your input latency is low and your configuration is stable.

If you haven’t yet tried running a gaming rig from your homelab, now is the perfect time to start. The hardware support is finally catching up to the incredible self-hosted software we have at our disposal.

What do you think? Are you planning to update your homelab server to the 7.3-Rc7 kernel to test out these new controller drivers? What self-hosted games or emulators are you running right now?

Drop a comment below and let us know! If you found this article helpful, make sure to hit that like button, subscribe to the Self-Hosted Tech YouTube channel, and check out our other guides on local AI and homelab hardware. Until next time, keep your servers cool and your ping low!