Perfectionner l’accélération de la souris sur Hyprland : retrouver la sensation Windows

TL;DR : Si la douce accélération du pointeur de Windows vous manque sous Linux, Hyprland vous permet de la recréer à l’aide d’un accel_profile personnalisé. Ce guide explique comment générer votre propre courbe avec un script Python et l’appliquer pour obtenir une sensation de souris naturelle et réactive, aussi bien pour le jeu que pour le développement.

Pendant des années, j’ai jonglé entre Windows et Linux, en développant, en jouant, et en comparant constamment les petites nuances entre les deux. Même si Windows a ses défauts, il y a une chose qu’il fait vraiment bien : l’accélération de la souris.

Quand je suis finalement passé 100 % à Linux (Wayland + Hyprland), l’une des premières choses qui m’a dérangé a été la sensation peu naturelle des mouvements de souris. L’accélération linéaire par défaut sous Linux ne suffisait tout simplement pas. En alternant entre la précision nécessaire au code et la rapidité des jeux nerveux, j’avais besoin d’une courbe d’accélération correcte, plus proche de ce que Windows fournit.

Découvrir les profils d’accélération de Hyprland

Après quelques recherches, je suis tombé sur le paramètre accel_profile dans le bloc de configuration input de Hyprland :
https://wiki.hypr.land/Configuring/Variables/#input

La documentation explique les bases, mais en pratique, les exemples fournis ne vous donneront rien qui s’approche du comportement de Windows avec “Améliorer la précision du pointeur” (“Enhance pointer precision”). En fait, ils paraissent souvent soit trop lents, soit trop imprévisibles.

Voici un exemple de bloc input Hyprland par défaut avant personnalisation :

input {
    sensitivity = 0
    accel_profile = linear
    follow_mouse = 1
}

Certains utilisateurs soutiennent qu’un profil linéaire est objectivement meilleur : prévisible, constant, plus simple pour la mémoire musculaire. Je comprends cet argument. Mais le cerveau humain est une machine à apprendre des schémas. Après des années à utiliser l’accélération Windows, vos réflexes sont littéralement calibrés sur cette courbe non linéaire spécifique. Essayer de la “désapprendre” est plus difficile qu’il n’y paraît.

C’est pourquoi, après plusieurs jours à tenter de m’adapter, j’ai décidé de faire l’inverse : amener une accélération à la Windows sur Hyprland.

Comprendre le modèle d’accélération de libinput

Pour vraiment comprendre le fonctionnement de tout ça, il est utile de savoir que le système d’accélération du pointeur de Hyprland repose directement sur libinput, le même backend utilisé par GNOME, KDE et la plupart des compositeurs Wayland modernes.

libinput définit trois profils d’accélération :

• adaptive : le profil par défaut qui ajuste l’accélération dynamiquement en fonction de la vitesse du pointeur.
• flat : un simple mapping 1:1 entre le mouvement du périphérique et celui du pointeur (aucune accélération).
• custom : une courbe entièrement définie par l’utilisateur, offrant un contrôle complet sur le comportement du pointeur.

Le profil d’accélération personnalisé expose une fonction f(x) qui mappe la vitesse du périphérique (en unités par milliseconde) à la vitesse de sortie. Chaque point définit comment l’accélération se comporte à différentes vitesses, et libinput interpole linéairement entre ces points.
La syntaxe de Hyprland accel_profile = custom ... est une implémentation directe de ce concept.

📘 Référence : Documentation libinput sur l’accélération du pointeur

Exemple de visualisation

Ci-dessous, une comparaison conceptuelle entre une courbe d’accélération linéaire (par défaut) et une courbe personnalisée de type Windows générée avec ce script :

La courbe linéaire augmente à un rythme constant, tandis que la courbe personnalisée de type Windows monte plus agressivement aux vitesses élevées, créant cette réactivité familière de “flick and glide”.

Reproduire la courbe Windows avec Python

Après quelques recherches, j’ai trouvé ce script brillant de fufexan sur GitHub :

• https://gist.github.com/fufexan/de2099bc3086f3a6c83d61fc1fcc06c9

C’est une adaptation d’un script plus ancien de yinonburgansky :

• https://gist.github.com/yinonburgansky/7be4d0489a0df8c06a923240b8eb0191

Ce script Python vous permet de définir votre DPI de souris, DPI d’écran, facteur de scaling, et sensibilité. Chaque paramètre influence le comportement de la courbe :

• DPI de la souris : définit votre précision de base.
• DPI de l’écran : ajuste la vitesse perçue du mouvement en fonction de la résolution.
• Facteur de scaling : compense le scaling d’affichage (par exemple pour les configs HiDPI).
• Sensibilité : contrôle la pente et l’intensité de l’accélération.

Il génère ensuite un ensemble lisse de points de courbe d’accélération que vous pouvez brancher directement dans votre configuration Hyprland.

Le script Python

Maintenant que vous comprenez comment fonctionne la génération de la courbe, voici le script Python complet que j’utilise pour reproduire l’accélération du pointeur Windows sur Hyprland.
Il est léger, configurable, et peut même appliquer le nouveau profil instantanément via hyprctl.

Si vous voulez une version autonome de l’outil, voici le script Python complet adapté pour Hyprland.
Il est basé sur les formules de calcul d’accélération de Windows d’origine, avec des ajustements pour le rendre prêt à l’emploi pour les utilisateurs Linux.

#!/usr/bin/env python3

# original at https://gist.github.com/yinonburgansky/7be4d0489a0df8c06a923240b8eb0191
# modified for ease of use in Hyprland

# calculations are based on http://www.esreality.com/index.php?a=post&id=1945096
# assuming Windows 10 uses the same calculation as Windows 7.
# guesses have been made — calculation is not 100% accurate.
# touchpad users: ensure your touchpad is calibrated with `sudo libinput measure touchpad-size`

import struct
import os
import sys
# import matplotlib.pyplot as plt  # Optional: uncomment for curve visualization

# ===== PARAMETERS =====
# Set these according to your device:
device_dpi = 1000  # Mouse DPI
screen_dpi = 96
screen_scaling_factor = 1
sample_point_count = 20  # Increase for more accurate curves
sensitivity_factor = 6   # See table below
# Sensitivity factor translation (Windows slider notches):
# 1 = 0.1 | 2 = 0.2 | 3 = 0.4 | 4 = 0.6 | 5 = 0.8 | 6 = 1.0 (default)
# 7 = 1.2 | 8 = 1.4 | 9 = 1.6 | 10 = 1.8 | 11 = 2.0
# ===== END PARAMETERS =====

def find_arg(arg):
    return arg in sys.argv

if find_arg("help") or find_arg("-h") or find_arg("--help") or find_arg("h"):
    print(f'{sys.argv[0]} [[accel_profile] [scroll_points] device=<device>]')
    print('To get the device, run `hyprctl devices` and get its name')
    exit(0)

# Scale factors (approximate Windows model)
scale_x = device_dpi / 1e3
scale_y = screen_dpi / 1e3 / screen_scaling_factor * sensitivity_factor

def float16x16(num):
    return struct.unpack('<i', num[:-4])[0] / int(0xffff)

# Windows 10 registry curve points
X = [
    bytes.fromhex("00 00 00 00 00 00 00 00"),
    bytes.fromhex("15 6e 00 00 00 00 00 00"),
    bytes.fromhex("00 40 01 00 00 00 00 00"),
    bytes.fromhex("29 dc 03 00 00 00 00 00"),
    bytes.fromhex("00 00 28 00 00 00 00 00"),
]
Y = [
    bytes.fromhex("00 00 00 00 00 00 00 00"),
    bytes.fromhex("fd 11 01 00 00 00 00 00"),
    bytes.fromhex("00 24 04 00 00 00 00 00"),
    bytes.fromhex("00 fc 12 00 00 00 00 00"),
    bytes.fromhex("00 c0 bb 01 00 00 00 00"),
]

windows_points = [[float16x16(x), float16x16(y)] for x, y in zip(X, Y)]
points = [[x * scale_x, y * scale_y] for x, y in windows_points]

def get_device():
    for i in sys.argv:
        if str(i).startswith('device='):
            return str(i)[7:]

def find2points(x):
    i = 0
    while i < len(points) - 2 and x >= points[i + 1][0]:
        i += 1
    return points[i], points[i + 1]

def interpolate(x):
    (x0, y0), (x1, y1) = find2points(x)
    return ((x - x0) * y1 + (x1 - x) * y0) / (x1 - x0)

def sample_points(count):
    last_point = -2
    max_x = points[last_point][0]
    step = max_x / (count + last_point)
    sample_points_x = [si * step for si in range(count)]
    sample_points_y = [interpolate(x) for x in sample_points_x]
    return sample_points_x, sample_points_y

sample_points_x, sample_points_y = sample_points(sample_point_count)
step = sample_points_x[1] - sample_points_x[0]
sample_points_str = " ".join(["%.3f" % number for number in sample_points_y])

print(f'\tPoints: {sample_points_str}')
print(f'\tStep size: {step:0.10f}')

def hyprctl(device, option, arg):
    os.system(f"hyprctl keyword 'device[{device}]:{option}' '{arg}'")

if find_arg("accel_profile"):
    device = get_device()
    print(f"Setting device '{device}':accel_profile using hyprctl")
    hyprctl(device, 'accel_profile', f'custom {step} {sample_points_str}')

if find_arg("scroll_points"):
    device = get_device()
    print(f"Setting device '{device}':scroll_points using hyprctl")
    hyprctl(device, 'scroll_points', f'{step} {sample_points_str}')

Après l’avoir enregistré sous ~/.config/hypr/conf/accel.py, rendez-le exécutable :

chmod +x ~/.config/hypr/conf/accel.py

Puis exécutez-le normalement ou en ciblant un périphérique spécifique :

~/.config/hypr/conf/accel.py custom 2 device=logitech-pro-x-wireless-1

Ce script génère une courbe d’accélération réaliste de type Windows et vous permet même de l’appliquer instantanément via hyprctl.
Vous pouvez ajuster les valeurs de DPI et de sensibilité pour affiner votre expérience sur plusieurs périphériques.

Exécuter le script

Voici à quoi cela ressemble en pratique :

❯ ~/.config/hypr/conf/accel.py
Points: 0.000 0.194 0.388 0.583 0.777 1.046 1.338 1.630 1.922 2.214 2.507 2.799 3.091 3.488 3.932 4.375 4.819 5.263 5.707 6.150 6.594 7.038 7.481 7.925 8.369 8.812 9.256 9.700 10.143 10.587 11.031 11.474 11.918 12.362 12.805 13.249 13.693 14.137 14.580 15.497
Step size: 0.1625288215

Cela vous donne les points de la courbe d’accélération et la valeur de step size requise par Hyprland.

Appliquer la configuration

Une fois que vous avez les valeurs, ajoutez-les à votre fichier de configuration input de Hyprland, par exemple :

❯ cat ~/.config/hypr/conf/keyboard.conf | grep -i accel
    accel_profile = custom 0.1625288215 0.000 0.194 0.388 0.583 0.777 1.046 1.338 1.630 1.922 2.214 2.507 2.799 3.091 3.488 3.932 4.375 4.819 5.263 5.707 6.150 6.594 7.038 7.481 7.925 8.369 8.812 9.256 9.700 10.143 10.587 11.031 11.474 11.918 12.362 12.805 13.249 13.693 14.137 14.580 15.497

Notez le point clé : le mot-clé custom doit apparaître en premier, immédiatement suivi par la step size, puis par les points de la courbe.

Après avoir enregistré votre configuration, rechargez Hyprland pour appliquer les changements :

hyprctl reload

Le résultat est une sensation d’accélération bien plus naturelle : fluide, prévisible, et familière pour quiconque est habitué au comportement de Windows.

Optionnel : cibler un périphérique spécifique

Vous pouvez aussi spécifier le périphérique directement lors de l’exécution du script :

~/.config/hypr/conf/accel.py custom 2 device=logitech-pro-x-wireless-1

Pour trouver l’identifiant de votre souris, utilisez :

❯ hyprctl devices
mice:
	Mouse at 55d41bf937b0:
		logitech-pro-x-wireless
			default speed: 0.00000
			scroll factor: -1.00
	Mouse at 55d41e78e0c0:
		logitech-pro-x-wireless-2
			default speed: 0.00000
			scroll factor: -1.00

Une fois la configuration effectuée, rechargez Hyprland et profitez d’un mouvement ultra-fluide.

Dernières réflexions

Cette configuration peut sembler exagérée pour certains, mais les petits détails ergonomiques comme l’accélération du pointeur font une énorme différence en termes de confort et de précision. Si votre cerveau s’est adapté à une courbe non linéaire, lutter contre lui ne fera que créer de la friction.

La courbe idéale de chacun sera légèrement différente selon le DPI, la résolution et la sensibilité. Expérimentez avec vos propres paramètres et n’hésitez pas à partager votre configuration. Il existe une communauté croissante d’utilisateurs Hyprland qui peaufinent leurs setups pour obtenir cette sensation parfaite.

Avec cette méthode, vous pouvez profiter d’un mélange parfait entre la flexibilité de Linux et le comportement de souris familier que vous aimiez sous Windows, rendant Hyprland à la fois naturel et réactif pour le jeu et le développement.