diff --git a/README.md b/README.md
index 45074ac..381afbb 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,9 @@
 # TachyPy
+[![CI](https://github.com/Charestlab/tachypy/actions/workflows/ci.yml/badge.svg)](https://github.com/Charestlab/tachypy/actions/workflows/ci.yml)
+[![PyPI version](https://img.shields.io/pypi/v/tachypy.svg)](https://pypi.org/project/tachypy/)
+[![Python versions](https://img.shields.io/pypi/pyversions/tachypy.svg)](https://pypi.org/project/tachypy/)
 [![Docs Status](https://readthedocs.org/projects/tachypy/badge/?version=latest)](https://tachypy.readthedocs.io/en/latest/?badge=latest)
+[![License](https://img.shields.io/github/license/Charestlab/tachypy.svg)](https://github.com/Charestlab/tachypy/blob/main/LICENSE)
 
 TachyPy is a psychophysics engine for Python focused on precise visual timing with
 OpenGL rendering, a GLFW-first display/input backend, and experiment-friendly
@@ -53,7 +57,8 @@ software timestamps alone.
 - Psychophysics helpers (`make_gabor`, gratings, normalization, dithering).
 - Audio playback utility (`Audio`) backed by `tachyaudio`.
 - Optional Wooting analog-keyboard integration (`tachypy[wooting]`): on-screen
-  pressure feedback and `WOOTING_ACQUISITION` straight from `tachypy`.
+  pressure feedback, analog scrollbar interaction, and
+  `WOOTING_ACQUISITION` straight from `tachypy`.
 - Test suite for core logic and regressions.
 
 ## Installation
@@ -88,7 +93,8 @@ pip install -e ".[wooting]"     # Wooting analog-keyboard integration
 ### Wooting analog-keyboard integration
 
 `pip install "tachypy[wooting]"` adds support for Wooting analog keyboards
-(pressure acquisition, logging, and on-screen visual feedback):
+(pressure acquisition, logging, visual feedback, and analog scrollbar
+interaction):
 
 ```python
 from tachypy import Screen, WOOTING_ACQUISITION
@@ -183,7 +189,7 @@ TACHYPY_FONT="Avenir Next, Helvetica, Arial" python example_tachypy.py
 - `GLSystemText` supports system font selection by family name, fallback list
   (e.g. `"Avenir Next, Helvetica, Arial"`), or direct font file path.
 - For production instruction text, prefer `Text`.
-- The old texture-backed constructor is backbenched as `tachypy.text.LegacyText`.
+- The old texture-backed constructor is retained as `tachypy.text.LegacyText`.
 
 ## API Naming
 
diff --git a/docs/api.rst b/docs/api.rst
index ba83517..88555bb 100644
--- a/docs/api.rst
+++ b/docs/api.rst
@@ -35,6 +35,12 @@ Core modules
 .. automodule:: tachypy.scrollbar
    :members:
 
+Scrollbar interaction
+---------------------
+
+.. automodule:: tachypy.scrollbar_interaction
+   :members:
+
 .. automodule:: tachypy.psychophysics
    :members:
 
diff --git a/docs/examples.rst b/docs/examples.rst
index 6d48bdf..b284743 100644
--- a/docs/examples.rst
+++ b/docs/examples.rst
@@ -29,12 +29,6 @@ Use ``Esc`` to quit, click ``START``/``STOP``/``RESET``, or use ``Space`` and
 
    tachypy-clock-demo --windowed
 
-Run the default demo:
-
-.. code-block:: bash
-
-   python example_tachypy.py
-
 Notes
 -----
 
diff --git a/docs/index.rst b/docs/index.rst
index 17f1975..0ce2f67 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -13,6 +13,7 @@ abstractions for display/input, and helper utilities for experiment workflows.
    timing_validation
    text_rendering
    audio
+   scrollbar
    wooting
    examples
    contributing
diff --git a/docs/scrollbar.rst b/docs/scrollbar.rst
new file mode 100644
index 0000000..a191664
--- /dev/null
+++ b/docs/scrollbar.rst
@@ -0,0 +1,88 @@
+Scrollbar widget
+================
+
+TachyPy's :class:`~tachypy.scrollbar.Scrollbar` is a customizable visual
+widget for selecting a continuous value, ``0``–``100`` by default. It is
+independent of the input device: the same widget can be controlled with the
+mouse, an analog keyboard, or another custom interaction loop.
+
+Normal mouse use
+----------------
+
+Create the scrollbar with the display dimensions, draw it every frame, and
+pass the current mouse position to ``handle_mouse``. The value is selected when
+a mouse button is released:
+
+.. code-block:: python
+
+   from tachypy import ResponseHandler, Screen, Scrollbar
+
+   screen = Screen(fullscreen=False)
+   responses = ResponseHandler(screen=screen)
+   scrollbar = Scrollbar(
+       screen_width=screen.width,
+       screen_height=screen.height,
+       position_y=screen.height / 2,
+       half_bar_length=350,
+       num_marks=11,
+       text_left="0",
+       text_right="100",
+       content_scale=screen.content_scale,
+   )
+
+   value = None
+   while value is None:
+       responses.get_events()
+       if responses.should_quit():
+           break
+
+       scrollbar.handle_mouse(*responses.get_mouse_position())
+       screen.fill((128, 128, 128))
+       scrollbar.draw()
+       screen.flip()
+
+       for click in responses.get_mouse_clicks():
+           if click["type"] == "mouseup":
+               value = scrollbar.get_value()
+
+   screen.close()
+
+The widget's value can also be controlled directly:
+
+.. code-block:: python
+
+   scrollbar.set_value(50)       # choose an initial/current value
+   current = scrollbar.get_value()
+
+Customization
+-------------
+
+The constructor keeps the appearance and geometry of the scrollbar explicit.
+Common options include:
+
+* ``half_bar_length``, ``bar_thickness`` and ``bar_color`` for the main bar;
+* ``num_marks``, ``mark_thickness`` and ``mark_color`` for tick marks;
+* ``text_left``, ``text_right``, ``font_name``, ``font_size`` and
+  ``text_color`` for endpoint labels;
+* ``half_end_height``, ``end_thickness`` and ``end_color`` for the endpoints;
+* ``limit_mouse`` to require the cursor to stay near the bar's horizontal line;
+* ``content_scale=screen.content_scale`` for sharp labels on Retina/HiDPI
+  displays.
+
+For the complete constructor reference, see the
+:class:`~tachypy.scrollbar.Scrollbar` API documentation.
+
+Analog keyboard interaction
+----------------------------
+
+Analog keyboard controls are documented with the Wooting integration because
+they include key roles, pressure-to-speed mapping, confirmation safety, Wooting
+key validation, and keyboard/mouse modes. The interaction layer keeps this
+widget unchanged and simply drives its existing ``set_value``/``draw`` API:
+
+.. seealso::
+
+   :doc:`wooting`
+
+The generic, keyboard-agnostic API is documented in
+:mod:`tachypy.scrollbar_interaction`.
diff --git a/docs/text_rendering.rst b/docs/text_rendering.rst
index 37debc9..851e50e 100644
--- a/docs/text_rendering.rst
+++ b/docs/text_rendering.rst
@@ -28,7 +28,7 @@ Recommended usage
 - Use ``Text`` for high-quality instruction screens and overlays.
 - Use ``GLSystemText`` only when you want the explicit historical class name.
 - Use ``GLTextSDF`` when scalable text quality matters and shaping is simple.
-- The old Pillow texture-backed constructor is backbenched as
+- The old Pillow texture-backed constructor is retained as
   ``tachypy.text.LegacyText`` for compatibility.
 
 HiDPI and Retina displays
diff --git a/docs/wooting.rst b/docs/wooting.rst
index 4063fa0..ea4cb17 100644
--- a/docs/wooting.rst
+++ b/docs/wooting.rst
@@ -5,9 +5,9 @@ TachyPy integrates with **TachyWooting**, a hardware toolbox for Wooting analog
 keyboards (analog pressure acquisition,
 hierarchical HDF5 logging, light-press / release readiness checks). The hardware
 toolbox is usable on its own; this page documents only what becomes available
-**inside TachyPy** once the integration is installed — chiefly on-screen visual
-pressure feedback. For the full keyboard/logging reference, see TachyWooting's own
-documentation.
+**inside TachyPy** once the integration is installed — on-screen visual pressure
+feedback and analog scrollbar responses. For the full keyboard/logging
+reference, see TachyWooting's own documentation.
 
 Installation
 ------------
@@ -24,8 +24,9 @@ the keyboard through the top-level ``tachypy`` namespace:
 One import surface
 ------------------
 
-The enriched ``WOOTING_ACQUISITION`` — the hardware acquisition class plus TachyPy
-visual feedback — is available straight from the top-level package:
+The enriched ``WOOTING_ACQUISITION`` — the hardware acquisition class plus
+TachyPy visual feedback and analog scrollbar interaction — is available straight
+from the top-level package:
 
 .. code-block:: python
 
@@ -46,24 +47,28 @@ How the enrichment works
 ------------------------
 
 ``WOOTING_ACQUISITION`` is enriched in ``tachypy/wooting/__init__.py``: it is a
-thin subclass that combines TachyWooting's hardware acquisition class with
-:class:`~tachypy.feedback.VisualPressureFeedbackMixin`. The mixin is what adds the
-``wait_light_press_visual`` method — nothing else changes:
+thin subclass that combines TachyWooting's hardware acquisition class with two
+TachyPy mixins. ``VisualPressureFeedbackMixin`` adds
+``wait_light_press_visual`` and ``AnalogSliderMixin`` adds ``interact_slider``:
 
 .. code-block:: python
 
    from tachywooting import WOOTING_ACQUISITION as _BaseAcquisition
    from tachypy.feedback import VisualPressureFeedbackMixin
+   from tachypy.scrollbar_interaction import AnalogSliderMixin
 
-   class WOOTING_ACQUISITION(_BaseAcquisition, VisualPressureFeedbackMixin):
-       """Hardware acquisition + logging (base) + TachyPy visual feedback (mixin)."""
+   class WOOTING_ACQUISITION(
+       _BaseAcquisition, VisualPressureFeedbackMixin, AnalogSliderMixin
+   ):
+       """Hardware acquisition plus TachyPy feedback and slider interaction."""
 
 This keeps the hardware package (TachyWooting) completely free of TachyPy — the
-visual method is grafted on here, on TachyPy's side. Because the mixin only relies
-on the :class:`~tachypy.feedback.PressureSource` contract (reading pressures plus
-the light-press thresholds), the very same pattern enriches any future analog
-keyboard: subclass its base acquisition class and mix in
-``VisualPressureFeedbackMixin``.
+TachyPy features are grafted on here, on the integration side. The visual mixin
+relies on the :class:`~tachypy.feedback.PressureSource` contract, while the
+slider mixin relies on ``read_pressures(keys)`` and optional
+``validate_analog_keys(keys)``. The same pattern can enrich another analog
+keyboard by subclassing its acquisition class and selecting the applicable
+TachyPy mixins.
 
 First-time setup
 ----------------
@@ -160,6 +165,131 @@ fall outside the acceptable interval.
    :alt: Interactive fixation cross with real-time pressure feedback
    :width: 100%
 
+Analog scrollbar responses
+--------------------------
+
+The Wooting acquisition provides pressure-controlled responses for any
+configured :class:`~tachypy.scrollbar.Scrollbar` through ``interact_slider``.
+For normal mouse-only use and visual customization, see :doc:`scrollbar`.
+
+Quick start
+~~~~~~~~~~~
+
+Pass a normal TachyPy scrollbar to the enriched Wooting acquisition. The
+defaults are ``Z`` to decrease, ``C`` to increase, and ``X`` to confirm:
+
+.. code-block:: python
+
+   from tachypy import Screen, Scrollbar, WOOTING_ACQUISITION
+
+   acq = WOOTING_ACQUISITION()
+   acq.initialize_keyboard()
+   screen = Screen(fullscreen=False)
+   scrollbar = Scrollbar(screen_width=screen.width, screen_height=screen.height,
+                         position_y=screen.height / 2,
+                         content_scale=screen.content_scale)
+
+   try:
+       value, reaction_time = acq.interact_slider(
+           slider=scrollbar,
+           screen=screen,
+       )
+   finally:
+       acq.uninitialize_keyboard()
+       screen.close()
+
+The method returns ``(value, reaction_time)`` on confirmation and
+``(None, None)`` when the participant presses ``Escape`` or closes the window.
+A default :class:`~tachypy.responses.ResponseHandler` is created automatically.
+
+Controls and pressure mapping
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The controls are:
+
+.. list-table:: Default analog controls
+   :header-rows: 1
+   :widths: 18 28 54
+
+   * - Key
+     - Role
+     - Behaviour
+   * - ``Z``
+     - Decrease
+     - Moves toward the lower end of the scrollbar. Speed depends on pressure.
+   * - ``C``
+     - Increase
+     - Moves toward the higher end of the scrollbar. Speed depends on pressure.
+   * - ``X``
+     - Confirm
+     - Selects the current value when its pressure crosses the confirmation threshold.
+
+Use any three distinct analog keys by passing ``decrease_key``, ``increase_key``
+and ``confirm_key``. TachyPy validates their Wooting analog mappings before the
+loop starts and raises if a configured key is unavailable.
+
+.. code-block:: python
+
+   value, reaction_time = acq.interact_slider(
+       slider=scrollbar, screen=screen,
+       decrease_key="a", increase_key="d", confirm_key="space")
+
+Movement is continuous. For pressure ``p`` above the deadzone ``d``, the
+private :func:`~tachypy.scrollbar_interaction._effective_pressure` helper uses:
+
+.. math::
+
+   p_{effective} = \left(\frac{p - d}{1 - d}\right)^\gamma
+
+Pressures at or below ``d`` produce zero movement; the normalized result is
+raised to ``pressure_gamma`` and converted to a proportion of
+``movement_speed``. ``gamma=1`` is linear after the deadzone, ``gamma>1`` gives
+gentler fine control, and ``0<gamma<1`` is more responsive. ``gamma=0`` is an
+on/off step and is rejected. The default is ``pressure_gamma=2.5``.
+
+``X`` cannot confirm while ``Z`` or ``C`` is active. Confirmation is
+edge-triggered, and all three keys must be released below ``release_threshold``
+before the next trial is armed.
+
+Input modes and customization
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The default ``input_mode="keyboard"`` uses analog ``Z``/``C`` movement and
+``X`` confirmation. Use ``input_mode="mouse_keyboard"`` to allow both mouse
+and analog-key movement, with either a mouse click or ``X`` for confirmation:
+
+.. code-block:: python
+
+   value, reaction_time = acq.interact_slider(
+       slider=scrollbar,
+       screen=screen,
+       input_mode="mouse_keyboard",
+       confirm_key="x",
+   )
+
+The cursor is hidden and recentered at screen edges. A left click or ``X``
+confirms after ``mouse_quiet_period`` seconds without mouse movement. Pressure
+on any analog key temporarily gives the keyboard exclusive control. ``X``
+must be released and pressed again if it was held during mouse movement.
+
+The interaction loop does not recreate the scrollbar, so all of its visual
+customization remains available. Pass ``drawables`` for instruction text or
+other TachyPy objects, and tune ``initial_value``, ``movement_speed``,
+``pressure_deadzone``, and ``pressure_gamma`` as needed.
+
+Demo and API
+~~~~~~~~~~~~~~~~~~~~~
+
+Try the three-trial demo with:
+
+.. code-block:: bash
+
+   tachypy-wooting-slider-demo
+
+The complete API, including the keyboard-agnostic
+:func:`~tachypy.scrollbar_interaction.run_slider_interaction`, is documented in
+:mod:`tachypy.scrollbar_interaction`.
+
 Logging and a full experiment loop
 ----------------------------------
 
diff --git a/setup.cfg b/setup.cfg
index 57a0034..af2266f 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -42,7 +42,7 @@ test =
     pytest-cov>=5.0
     ruff>=0.6
 wooting =
-    tachywooting>=0.2.2
+    tachywooting>=0.2.4
 
 [options.entry_points]
 console_scripts =
diff --git a/setup.py b/setup.py
index 12a8dad..9a2fa52 100644
--- a/setup.py
+++ b/setup.py
@@ -18,7 +18,7 @@
         'system_text': ['freetype-py>=2.4', 'uharfbuzz>=0.39'],
         'glfw': ['glfw>=2.7'],
         'audio': [],
-        'wooting': ['tachywooting>=0.2.2'],
+        'wooting': ['tachywooting>=0.2.4'],
     },
     python_requires='>=3.10',
     author='Ian Charest, Mathias Salvas-Hebert and Frederic Gosselin',
@@ -41,6 +41,7 @@
             'tachypy-clock-demo=tachypy.examples.clock_timer_demo:main',
             'tachypy-wooting-fixation-demo=tachypy.wooting.demos.visual_fixation_demo:main',
             'tachypy-wooting-mini-bw=tachypy.wooting.demos.mini_bw_experiment:main',
+            'tachypy-wooting-slider-demo=tachypy.wooting.demos.slider_demo:main',
         ],
     },
 )
diff --git a/src/tachypy/__init__.py b/src/tachypy/__init__.py
index 858f0e5..3109563 100644
--- a/src/tachypy/__init__.py
+++ b/src/tachypy/__init__.py
@@ -46,6 +46,8 @@
     "PressureFeedbackConfig",
     "PressureSource",
     "VisualPressureFeedbackMixin",
+    "AnalogSliderMixin",
+    "run_slider_interaction",
 ]
 
 
@@ -93,6 +95,8 @@
     "PressureFeedbackConfig": ("tachypy.feedback", "PressureFeedbackConfig"),
     "PressureSource": ("tachypy.feedback", "PressureSource"),
     "VisualPressureFeedbackMixin": ("tachypy.feedback", "VisualPressureFeedbackMixin"),
+    "AnalogSliderMixin": ("tachypy.scrollbar_interaction", "AnalogSliderMixin"),
+    "run_slider_interaction": ("tachypy.scrollbar_interaction", "run_slider_interaction"),
     # Wooting keyboard integration — convenience shortcut for the one distinctive,
     # high-frequency entry point: `from tachypy import WOOTING_ACQUISITION`.
     # Resolved lazily from the `tachypy.wooting` facade, which requires the
diff --git a/src/tachypy/feedback/runner.py b/src/tachypy/feedback/runner.py
index bd4f250..a3a7de0 100644
--- a/src/tachypy/feedback/runner.py
+++ b/src/tachypy/feedback/runner.py
@@ -248,6 +248,9 @@ def wait_light_press_visual(
         target_keys = list(target_keys)
         if len(target_keys) != 2:
             raise ValueError("wait_light_press_visual requires exactly two target keys")
+        validate = getattr(self, "validate_analog_keys", None)
+        if callable(validate):
+            validate(target_keys)
 
         if widget is not None:
             conflicting = [
diff --git a/src/tachypy/scrollbar.py b/src/tachypy/scrollbar.py
index 22ea12c..833a1f4 100644
--- a/src/tachypy/scrollbar.py
+++ b/src/tachypy/scrollbar.py
@@ -226,6 +226,13 @@ def handle_mouse(self, mouse_x: float, mouse_y: float) -> bool:
         self._update_mobile_line_geometry()
         return True
 
+    def move_by(self, delta_x: float, mouse_y: float | None = None) -> bool:
+        """Move the marker by a relative x-distance in screen pixels."""
+        return self.handle_mouse(
+            self.mobile_line_x + delta_x,
+            self.position_y if mouse_y is None else mouse_y,
+        )
+
     def get_normalized_value(self) -> float:
         """Return current position in [0, 1]."""
         return (self.mobile_line_x - self.min_x) / (self.max_x - self.min_x)
diff --git a/src/tachypy/scrollbar_interaction.py b/src/tachypy/scrollbar_interaction.py
new file mode 100644
index 0000000..1febb93
--- /dev/null
+++ b/src/tachypy/scrollbar_interaction.py
@@ -0,0 +1,418 @@
+"""Keyboard and mouse interaction for TachyPy scrollbar-like widgets.
+
+The interaction loop is deliberately separate from :class:`tachypy.scrollbar.Scrollbar`:
+``Scrollbar`` owns drawing and value/geometry handling, while this module owns
+input, timing, pressure mapping, confirmation, and quit handling. This keeps
+all of TachyPy's scrollbar customization available regardless of how the value
+is selected.
+
+There are two intended entry points:
+
+``AnalogSliderMixin.interact_slider``
+    Convenience method for an acquisition object that provides
+    ``read_pressures(keys)`` and, optionally, ``validate_analog_keys(keys)``.
+    ``WOOTING_ACQUISITION`` gains this method through the TachyPy Wooting
+    integration.
+
+``run_slider_interaction``
+    Keyboard-agnostic loop for other analog keyboards or custom input sources.
+    Supply a ``control_reader`` returning :class:`SliderControls` each frame.
+
+The default keyboard mapping is ``Z`` to decrease, ``C`` to increase, and
+``X`` to confirm. The movement keys are analog: pressure is converted to a
+nonlinear speed, so light presses provide fine control. Confirmation is only
+accepted when neither movement key is active.
+"""
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+from typing import Callable, Literal
+
+from tachypy.responses import ResponseHandler
+
+
+@dataclass(frozen=True)
+class SliderControls:
+    """One frame of normalized controls for a scrollbar interaction.
+
+    Each value should normally be in the inclusive range ``0.0``–``1.0``.
+    ``decrease`` and ``increase`` control movement; ``confirm`` selects the
+    current scrollbar value when it crosses the confirmation threshold.
+
+    Attributes
+    ----------
+    decrease : float
+        Analog pressure for the key that moves the scrollbar toward its lower
+        values (``Z`` by default).
+    increase : float
+        Analog pressure for the key that moves the scrollbar toward its higher
+        values (``C`` by default).
+    confirm : float
+        Analog pressure for the selection key (``X`` by default).
+    """
+
+    decrease: float = 0.0
+    increase: float = 0.0
+    confirm: float = 0.0
+
+
+class AnalogSliderMixin:
+    """Add pressure-driven scrollbar interaction to an analog acquisition.
+
+    The host object must implement ``read_pressures(keys)`` and return a mapping
+    from each requested key to a normalized pressure. If it implements
+    ``validate_analog_keys(keys)``, that method is called before the loop starts.
+    The Wooting implementation raises for an unmapped key, before any response
+    is collected.
+
+    The mixin does not draw or replace the scrollbar. Pass any configured
+    :class:`tachypy.scrollbar.Scrollbar` instance to :meth:`interact_slider`.
+
+    Example
+    -------
+    .. code-block:: python
+
+       acq = WOOTING_ACQUISITION()
+       acq.initialize_keyboard()
+       try:
+           value, reaction_time = acq.interact_slider(
+               slider=scrollbar,
+               screen=screen,
+               input_mode="keyboard",       # or "mouse_keyboard"
+               decrease_key="z",            # lower value
+               increase_key="c",             # higher value
+               confirm_key="x",              # select value
+           )
+       finally:
+           acq.uninitialize_keyboard()
+
+    ``Escape`` is handled automatically when no ``response_handler`` is
+    supplied. Additional ``run_slider_interaction`` options can be forwarded as
+    keyword arguments, for example ``pressure_gamma`` or ``drawables``.
+    """
+
+    def interact_slider(
+        self, *, slider, screen, response_handler=None,
+        decrease_key="z", increase_key="c", confirm_key="x", **kwargs,
+    ):
+        """Run a scrollbar response using this acquisition's analog pressures.
+
+        Parameters
+        ----------
+        slider : object
+            TachyPy ``Scrollbar``-like object. It must expose ``set_value``,
+            ``get_value``, and ``draw``. In ``mouse_keyboard`` mode it must also
+            expose ``move_by(delta_x, mouse_y)``.
+        screen : TachyPy Screen-like object
+            Display surface exposing ``flip()`` and optionally ``fill(color)``.
+        response_handler : ResponseHandler, optional
+            Input/event handler. If omitted, a default handler is created so
+            window close and ``Escape`` can abort the interaction.
+        decrease_key, increase_key, confirm_key : str or int, optional
+            The three analog keys. Defaults to ``Z``, ``C``, and ``X``. They
+            must be distinct, non-empty, and valid analog keys. A Wooting host
+            raises before the loop if a key is not mapped as analog.
+        **kwargs
+            Options forwarded to :func:`run_slider_interaction`, including
+            ``input_mode``, ``drawables``, ``initial_value``,
+            ``movement_speed``, ``pressure_deadzone``, and ``pressure_gamma``.
+
+        Returns
+        -------
+        (float, float) or (None, None)
+            Selected scrollbar value and reaction time in seconds. ``(None,
+            None)`` means the participant quit or the window was closed.
+
+        Notes
+        -----
+        In ``keyboard`` mode, movement pressure is sampled continuously. In
+        ``mouse_keyboard`` mode, the mouse or the analog movement keys control
+        the value, and the confirm key or a mouse click selects it.
+        """
+        keys = tuple(str(key).strip().lower() for key in (decrease_key, increase_key, confirm_key))
+        if not all(keys) or len(set(keys)) != 3:
+            raise ValueError("Slider keys must be three distinct non-empty names")
+        validate = getattr(self, "validate_analog_keys", None)
+        if callable(validate):
+            validate(keys)
+
+        def read():
+            values = self.read_pressures(keys)
+            return SliderControls(*(values[key] for key in keys))
+
+        return run_slider_interaction(
+            slider=slider, screen=screen,
+            response_handler=response_handler or ResponseHandler(screen=screen),
+            control_reader=read, **kwargs,
+        )
+
+
+def _effective_pressure(pressure: float, deadzone: float, gamma: float) -> float:
+    """Map raw pressure to movement strength after a deadzone.
+
+    For ``pressure > deadzone``, the exact mapping is::
+
+        effective = ((pressure - deadzone) / (1 - deadzone)) ** gamma
+
+    The result is clipped to the ``0.0``–``1.0`` range before exponentiation.
+    ``gamma=1`` is therefore linear *after* the deadzone. ``gamma > 1`` makes
+    low pressures disproportionately gentle while keeping full pressure at
+    full speed. ``gamma=0`` would be a step function (zero below the deadzone,
+    one above it), not a linear mapping, and is rejected by the public loop.
+    """
+    if pressure <= deadzone:
+        return 0.0
+    return ((min(1.0, float(pressure)) - deadzone) / (1.0 - deadzone)) ** gamma
+
+
+def run_slider_interaction(
+    *,
+    slider,
+    screen,
+    response_handler=None,
+    input_mode: Literal["keyboard", "mouse_keyboard"] = "keyboard",
+    control_reader: Callable[[], SliderControls] | None = None,
+    validate_input: Callable[[], None] | None = None,
+    drawables=(),
+    initial_value: float = 50.0,
+    movement_speed: float = 100.0,
+    pressure_deadzone: float = 0.05,
+    pressure_gamma: float = 2.5,
+    confirm_threshold: float = 0.6,
+    release_threshold: float = 0.03,
+    mouse_quiet_period: float = 0.08,
+    background_color=(128, 128, 128),
+    clock: Callable[[], float] = time.perf_counter,
+    wait_until: Callable[[float], None] | None = None,
+):
+    """Run a customizable scrollbar with analog controls.
+
+    This is the backend-agnostic interaction loop. It never imports Wooting or
+    another keyboard package: ``control_reader`` supplies the current controls,
+    one :class:`SliderControls` object per frame. Use
+    :meth:`AnalogSliderMixin.interact_slider` when the input source already has
+    a ``read_pressures`` method.
+
+    Parameters
+    ----------
+    slider : object
+        Scrollbar-like widget exposing ``set_value(value)``, ``get_value()``,
+        and ``draw()``. For ``mouse_keyboard`` it must also expose
+        ``move_by(delta_x, mouse_y)``. A normal TachyPy ``Scrollbar`` keeps all
+        of its visual and mouse customization.
+    screen : TachyPy Screen-like object
+        Must expose ``flip()``; if it exposes ``fill(color)``, the screen is
+        cleared before each frame.
+    response_handler : ResponseHandler-like object, optional
+        Used for event polling, window-close/Escape detection, and mouse
+        position in ``mouse_keyboard`` mode. It is optional in keyboard-only
+        mode, although supplying one enables quit handling. Mouse mode also
+        requires ``set_position`` for automatic edge recentering.
+    input_mode : {"keyboard", "mouse_keyboard"}, default="keyboard"
+        ``"keyboard"`` uses analog decrease/increase pressures for movement and
+        the confirm pressure for selection. ``"mouse_keyboard"`` accepts both
+        mouse or analog-key movement and either a left mouse click or the confirm
+        pressure for selection; the mouse must be quiet for
+        ``mouse_quiet_period`` before confirmation.
+        Any analog-key pressure above the deadzone temporarily gives the
+        keyboard exclusive control.
+        The hidden cursor is recentered horizontally when it reaches a screen
+        edge, so relative movement remains available in both directions.
+    control_reader : callable
+        Zero-argument callable returning ``SliderControls`` for the current
+        frame. Values are expected in ``0.0``–``1.0``.
+    validate_input : callable, optional
+        Called once before the loop. Use this in a keyboard-specific adapter to
+        validate key availability without putting keyboard imports here.
+    drawables : sequence, optional
+        Objects with ``draw()`` called after the scrollbar on every frame.
+    initial_value : float, default=50.0
+        Value assigned to the scrollbar at the start of the interaction.
+    movement_speed : float, default=100.0
+        Maximum scrollbar units per second at full effective pressure.
+    pressure_deadzone : float, default=0.05
+        Pressures at or below this value do not move the scrollbar.
+    pressure_gamma : float, default=2.5
+        Exponent used after deadzone normalization in
+        ``effective = normalized_pressure ** pressure_gamma``. ``1`` gives a
+        linear mapping after the deadzone; values above ``1`` make light
+        presses slower and improve fine adjustment. ``0`` is invalid because it
+        would create an abrupt on/off step rather than a useful speed curve.
+    confirm_threshold : float, default=0.6
+        Pressure that the confirm key must cross to select the value.
+    release_threshold : float, default=0.03
+        All three controls must fall below this level before a trial is armed.
+        This prevents a key held from the previous trial from immediately
+        moving or confirming the next one.
+    mouse_quiet_period : float, default=0.08
+        Required seconds without mouse movement before mouse confirmation is
+        accepted. It is also used by ``mouse_keyboard`` mode before keyboard
+        confirmation.
+    background_color : tuple, default=(128, 128, 128)
+        RGB color used to clear the screen when ``fill`` is available.
+    clock : callable, default=time.perf_counter
+        Monotonic clock used for movement integration and reaction time.
+    wait_until : callable, optional
+        ``wait_until(deadline)`` used to pace the loop. Defaults to a portable
+        sleep-based implementation; inject a deterministic function in tests.
+
+    Returns
+    -------
+    (float, float) or (None, None)
+        The selected scrollbar value and elapsed reaction time in seconds, or
+        ``(None, None)`` if the response handler requests a quit.
+
+    Raises
+    ------
+    ValueError
+        If the input mode, control reader, or pressure thresholds are invalid.
+
+    Examples
+    --------
+    A Wooting experiment normally uses the mixin adapter:
+
+    .. code-block:: python
+
+       value, rt = acquisition.interact_slider(
+           slider=scrollbar, screen=screen,
+           drawables=(instruction_text,),
+           pressure_gamma=2.5,
+       )
+
+    A different analog keyboard can use the generic loop directly:
+
+    .. code-block:: python
+
+       def read_controls():
+           return SliderControls(
+               decrease=keyboard.pressure("z"),
+               increase=keyboard.pressure("c"),
+               confirm=keyboard.pressure("x"),
+           )
+
+       value, rt = run_slider_interaction(
+           slider=scrollbar, screen=screen, control_reader=read_controls,
+       )
+    """
+    if input_mode not in ("keyboard", "mouse_keyboard"):
+        raise ValueError("input_mode must be 'keyboard' or 'mouse_keyboard'")
+    if control_reader is None:
+        raise ValueError("control_reader is required")
+    if input_mode == "mouse_keyboard" and response_handler is None:
+        raise ValueError("response_handler is required for mouse input")
+    if input_mode == "mouse_keyboard" and not hasattr(response_handler, "set_position"):
+        raise ValueError("mouse_keyboard mode requires response_handler.set_position")
+    if input_mode == "mouse_keyboard" and not hasattr(slider, "move_by"):
+        raise ValueError("mouse_keyboard mode requires slider.move_by(delta_x, mouse_y)")
+    mouse_was_visible = getattr(screen, "mouse_visible", None)
+    if input_mode == "mouse_keyboard" and hasattr(screen, "hide_mouse"):
+        screen.hide_mouse()
+    if not 0 <= pressure_deadzone < 1 or pressure_gamma <= 0:
+        raise ValueError("Invalid pressure mapping parameters")
+    if not 0 <= release_threshold < confirm_threshold <= 1:
+        raise ValueError("Require 0 <= release_threshold < confirm_threshold <= 1")
+    if validate_input is not None:
+        validate_input()
+    if wait_until is None:
+        wait_until = lambda deadline: time.sleep(max(0.0, deadline - clock()))
+    if response_handler is not None:
+        if hasattr(response_handler, "clear_events"):
+            response_handler.clear_events()
+        if hasattr(response_handler, "reset_timer"):
+            response_handler.reset_timer()
+
+    slider.set_value(initial_value)
+    previous_confirm = 0.0
+    armed = False
+    last_mouse_move = float("-inf")
+    last_mouse_position = None
+
+    def draw():
+        if hasattr(screen, "fill"):
+            screen.fill(background_color)
+        slider.draw()
+        for drawable in drawables:
+            drawable.draw()
+        screen.flip()
+
+    def finish(result):
+        if input_mode == "mouse_keyboard" and mouse_was_visible is not None:
+            (screen.show_mouse if mouse_was_visible else screen.hide_mouse)()
+        return result
+
+    draw()
+    start = last = clock()
+    next_tick = start
+
+    while True:
+        if response_handler is not None:
+            response_handler.get_events()
+            if response_handler.should_quit():
+                return finish((None, None))
+
+        now = clock()
+        dt = min(max(0.0, now - last), 0.1)
+        last = now
+        controls = control_reader()
+        keyboard_active = max(controls.decrease, controls.increase, controls.confirm) > pressure_deadzone
+        movement_active = (
+            input_mode in ("keyboard", "mouse_keyboard")
+            and max(controls.decrease, controls.increase) > pressure_deadzone
+        )
+
+        mouse_position = None
+        mouse_moved = False
+        previous_mouse_position = None
+        if input_mode == "mouse_keyboard":
+            mouse_position = response_handler.get_mouse_position()
+            previous_mouse_position = last_mouse_position
+            mouse_moved = previous_mouse_position is not None and mouse_position != previous_mouse_position
+            if mouse_moved:
+                last_mouse_move = now
+            last_mouse_position = mouse_position
+
+        if not armed:
+            armed = max(controls.decrease, controls.increase, controls.confirm) < release_threshold
+            previous_confirm = controls.confirm
+            if not armed:
+                draw()
+                next_tick += 0.001
+                wait_until(next_tick)
+                continue
+
+        if input_mode == "mouse_keyboard" and mouse_moved:
+            if not keyboard_active:
+                delta_x = mouse_position[0] - previous_mouse_position[0]
+                slider.move_by(delta_x, mouse_position[1])
+            if hasattr(screen, "width") and (
+                    mouse_position[0] <= 1 or mouse_position[0] >= screen.width - 1):
+                center = (screen.width / 2, mouse_position[1])
+                response_handler.set_position(*center)
+                last_mouse_position = center
+                last_mouse_move = now
+
+        if movement_active:
+            direction = _effective_pressure(controls.increase, pressure_deadzone, pressure_gamma)
+            direction -= _effective_pressure(controls.decrease, pressure_deadzone, pressure_gamma)
+            slider.set_value(slider.get_value() + movement_speed * direction * dt)
+
+        if input_mode == "mouse_keyboard" and not keyboard_active:
+            for click in response_handler.get_mouse_clicks():
+                if (click["type"] == "mouseup" and click.get("button", 0) == 0
+                        and now - last_mouse_move >= mouse_quiet_period):
+                    return finish((slider.get_value(), now - start))
+
+        if (
+            # A held X pressed during mouse movement must be released/repressed
+            # before confirming, preventing simultaneous input sources.
+            previous_confirm < confirm_threshold <= controls.confirm
+            and not movement_active
+            and (input_mode == "keyboard" or now - last_mouse_move >= mouse_quiet_period)
+        ):
+            return finish((slider.get_value(), now - start))
+        previous_confirm = controls.confirm
+        draw()
+
+        next_tick += 0.001
+        wait_until(next_tick)
diff --git a/src/tachypy/wooting/__init__.py b/src/tachypy/wooting/__init__.py
index 228b981..b11e8ee 100644
--- a/src/tachypy/wooting/__init__.py
+++ b/src/tachypy/wooting/__init__.py
@@ -3,7 +3,8 @@
 This module is the single import surface for using a Wooting analog keyboard
 *inside* TachyPy experiments. It re-exports TachyWooting's public API and adds an
 enriched :class:`WOOTING_ACQUISITION` that gains TachyPy visual feedback
-(``wait_light_press_visual``) on top of the hardware acquisition class.
+(``wait_light_press_visual``) and analog scrollbar interaction
+(``interact_slider``) on top of the hardware acquisition class.
 
 TachyPy core never imports this module, so ``pip install tachypy`` stays usable
 without a keyboard. Importing this module without TachyWooting installed raises a
@@ -20,6 +21,7 @@
     ) from exc
 
 from tachypy.feedback import VisualPressureFeedbackMixin
+from tachypy.scrollbar_interaction import AnalogSliderMixin
 
 # Re-export the keyboard's public API so experiments need only one import.
 from tachywooting import (  # noqa: F401
@@ -34,12 +36,14 @@
 from tachywooting.visualize import visualize, visualize_all_keys  # noqa: F401
 
 # TachyPy-enriched acquisition class that combines Wooting's hardware acquisition and TachyPy's visual feedback.
-class WOOTING_ACQUISITION(_tachywooting.WOOTING_ACQUISITION, VisualPressureFeedbackMixin):
+class WOOTING_ACQUISITION(_tachywooting.WOOTING_ACQUISITION, VisualPressureFeedbackMixin, AnalogSliderMixin):
     """Wooting acquisition enriched with TachyPy visual feedback.
 
     Identical to :class:`tachywooting.WOOTING_ACQUISITION` (acquisition, logging,
     readiness checks) plus :meth:`~tachypy.feedback.VisualPressureFeedbackMixin.wait_light_press_visual`
-    for on-screen pressure feedback.
+    for on-screen pressure feedback and
+    :meth:`~tachypy.scrollbar_interaction.AnalogSliderMixin.interact_slider`
+    for pressure-controlled scrollbar responses.
     """
 
 
diff --git a/src/tachypy/wooting/demos/__init__.py b/src/tachypy/wooting/demos/__init__.py
index ccb4412..a6d3603 100644
--- a/src/tachypy/wooting/demos/__init__.py
+++ b/src/tachypy/wooting/demos/__init__.py
@@ -5,4 +5,5 @@
 
 - ``tachypy-wooting-fixation-demo`` → :func:`visual_fixation_demo.main`
 - ``tachypy-wooting-mini-bw`` → :func:`mini_bw_experiment.main`
+- ``tachypy-wooting-slider-demo`` → :func:`slider_demo.main`
 """
diff --git a/src/tachypy/wooting/demos/slider_demo.py b/src/tachypy/wooting/demos/slider_demo.py
new file mode 100644
index 0000000..7d4c0d4
--- /dev/null
+++ b/src/tachypy/wooting/demos/slider_demo.py
@@ -0,0 +1,69 @@
+"""Minimal three-trial Wooting analog scrollbar demo.
+
+Run with ``python -m tachypy.wooting.demos.slider_demo`` or the installed
+``tachypy-wooting-slider-demo`` command.
+
+The demo uses the TachyPy ``Scrollbar`` widget unchanged and adds interaction
+through ``WOOTING_ACQUISITION.interact_slider`` in ``mouse_keyboard`` mode:
+the mouse or analog ``Z``/``C`` keys move the scrollbar, while a mouse click
+or ``X`` confirms it. Press ``Escape`` to quit.
+"""
+from __future__ import annotations
+
+try:
+    from tachypy import Screen, Scrollbar, Text, WOOTING_ACQUISITION
+except ImportError as exc:  # pragma: no cover
+    raise SystemExit("Install the Wooting extra first: pip install 'tachypy[wooting]'") from exc
+
+
+N_TRIALS = 3
+
+
+def main() -> int:
+    acquisition = WOOTING_ACQUISITION()
+    screen = None
+    try:
+        acquisition.initialize_keyboard()
+        screen = Screen(width=1100, height=650, fullscreen=False, grab_input=False)
+        instruction = "MOUSE or Z/C : MOVE    CLICK or X : CONFIRM"
+
+        slider = Scrollbar(
+            screen_width=screen.width,
+            screen_height=screen.height,
+            position_y=screen.height / 2,
+            half_bar_length=350,
+            num_marks=11,
+            content_scale=screen.content_scale,
+        )
+        message = Text(
+            "",
+            dest_rect=(60, 40, screen.width - 60, 180),
+            color=(0, 0, 0),
+            content_scale=screen.content_scale,
+        )
+
+        print(f"Controls: {instruction}. Press Escape to quit.")
+        for trial in range(1, N_TRIALS + 1):
+            message.set_text(f"TRIAL {trial}/{N_TRIALS}\n{instruction}\nESCAPE : QUIT")
+            value, reaction_time = acquisition.interact_slider(
+                slider=slider,
+                screen=screen,
+                drawables=(message,),
+                input_mode="mouse_keyboard",
+                mouse_quiet_period=0.04,
+            )
+            if value is None:
+                print("Demo cancelled.")
+                return 0
+            print(f"Trial {trial}: value={value:.2f}, reaction_time={reaction_time:.3f}s")
+
+        print("Demo complete.")
+        return 0
+    finally:
+        acquisition.uninitialize_keyboard()
+        if screen is not None and hasattr(screen, "close"):
+            screen.close()
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/tests/test_slider_interaction.py b/tests/test_slider_interaction.py
new file mode 100644
index 0000000..526c360
--- /dev/null
+++ b/tests/test_slider_interaction.py
@@ -0,0 +1,217 @@
+from tachypy.scrollbar_interaction import (
+    SliderControls,
+    _effective_pressure,
+    run_slider_interaction,
+)
+
+
+class FakeSlider:
+    def __init__(self):
+        self.value = 50.0
+
+    def set_value(self, value):
+        self.value = max(0.0, min(100.0, value))
+
+    def get_value(self):
+        return self.value
+
+    def draw(self):
+        pass
+
+    def handle_mouse(self, x, _y):
+        changed = self.value != x
+        self.set_value(x)
+        return changed
+
+    def move_by(self, delta_x, _mouse_y=None):
+        changed = delta_x != 0
+        self.set_value(self.value + delta_x)
+        return changed
+
+
+class FakeInput:
+    def __init__(self, values):
+        self.values = iter(values)
+
+    def __call__(self):
+        return next(self.values)
+
+
+class FakeResponse:
+    def get_events(self):
+        pass
+
+    def should_quit(self):
+        return False
+
+    def set_position(self, _x, _y):
+        pass
+
+
+class FakeMouseResponse(FakeResponse):
+    def __init__(self, positions, clicks=True, click_after=0):
+        self.positions = iter(positions)
+        self.clicks = clicks
+        self.frame = 0
+        self.click_after = click_after
+
+    def get_mouse_position(self):
+        return next(self.positions)
+
+    def get_mouse_clicks(self):
+        self.frame += 1
+        return ([{"type": "mouseup", "pos": (80.0, 0.0)}]
+                if self.clicks and self.frame > self.click_after else [])
+
+
+class EdgeMouseResponse(FakeResponse):
+    def __init__(self):
+        self.positions = iter([(500.0, 300.0), (999.0, 300.0), (500.0, 300.0)])
+        self.recenters = []
+
+    def get_mouse_position(self):
+        return next(self.positions)
+
+    def get_mouse_clicks(self):
+        return []
+
+    def set_position(self, x, y):
+        self.recenters.append((x, y))
+
+
+class FakeScreen:
+    width = 1000
+
+    def fill(self, color):
+        pass
+
+    def flip(self):
+        pass
+
+
+def test_pressure_mapping_is_precise_at_low_pressure():
+    assert _effective_pressure(0.05, 0.05, 2.5) == 0.0
+    assert _effective_pressure(0.2, 0.05, 2.5) < _effective_pressure(0.8, 0.05, 2.5)
+
+
+def test_keyboard_slider_moves_and_confirms():
+    slider = FakeSlider()
+    clock_value = iter([0.0, 0.001, 0.002, 0.003, 0.004])
+    result = run_slider_interaction(
+        slider=slider,
+        screen=FakeScreen(),
+        response_handler=FakeResponse(),
+        control_reader=FakeInput([
+            SliderControls(),
+            SliderControls(decrease=0.8),
+            SliderControls(),
+            SliderControls(confirm=0.8),
+        ]),
+        clock=lambda: next(clock_value),
+        wait_until=lambda _: None,
+    )
+    assert result[0] < 50.0
+    assert result[1] > 0.0
+
+
+def test_confirmation_is_blocked_during_movement_until_x_is_repressed():
+    slider = FakeSlider()
+    clock_value = iter(i / 1000 for i in range(8))
+    result = run_slider_interaction(
+        slider=slider,
+        screen=FakeScreen(),
+        response_handler=FakeResponse(),
+        control_reader=FakeInput([
+            SliderControls(),
+            SliderControls(increase=0.8),
+            SliderControls(increase=0.8, confirm=0.8),
+            SliderControls(confirm=0.8),
+            SliderControls(),
+            SliderControls(confirm=0.8),
+        ]),
+        clock=lambda: next(clock_value),
+        wait_until=lambda _: None,
+    )
+    assert result[0] > 50.0
+
+
+def test_mouse_click_confirms_after_quiet_period():
+    slider = FakeSlider()
+    clock_value = iter([0.0, 0.0, 0.01, 0.06])
+    result = run_slider_interaction(
+        slider=slider,
+        screen=FakeScreen(),
+        response_handler=FakeMouseResponse(
+            [(10.0, 0.0), (50.0, 0.0), (50.0, 0.0)], click_after=2
+        ),
+        control_reader=FakeInput([SliderControls(), SliderControls(), SliderControls()]),
+        input_mode="mouse_keyboard",
+        mouse_quiet_period=0.04,
+        clock=lambda: next(clock_value),
+        wait_until=lambda _: None,
+    )
+    assert result == (90.0, 0.06)
+
+
+def test_mouse_keyboard_keeps_analog_key_movement():
+    slider = FakeSlider()
+    clock_value = iter([0.0, 0.0, 0.01, 0.02, 0.10])
+    result = run_slider_interaction(
+        slider=slider,
+        screen=FakeScreen(),
+        response_handler=FakeMouseResponse([(50.0, 0.0)] * 4, clicks=False),
+        control_reader=FakeInput([
+            SliderControls(),
+            SliderControls(increase=0.8),
+            SliderControls(),
+            SliderControls(confirm=0.8),
+        ]),
+        input_mode="mouse_keyboard",
+        wait_until=lambda _: None,
+        clock=lambda: next(clock_value),
+    )
+    assert result[0] > 50.0
+
+
+def test_mouse_is_locked_while_any_keyboard_key_has_pressure():
+    slider = FakeSlider()
+    clock_value = iter([0.0, 0.0, 0.01, 0.02, 0.10])
+    result = run_slider_interaction(
+        slider=slider,
+        screen=FakeScreen(),
+        response_handler=FakeMouseResponse(
+            [(500.0, 0.0), (900.0, 0.0), (900.0, 0.0), (900.0, 0.0)],
+            clicks=False,
+        ),
+        control_reader=FakeInput([
+            SliderControls(),
+            SliderControls(increase=0.8),
+            SliderControls(),
+            SliderControls(confirm=0.8),
+        ]),
+        input_mode="mouse_keyboard",
+        wait_until=lambda _: None,
+        clock=lambda: next(clock_value),
+    )
+    assert 50.0 < result[0] < 60.0
+
+
+def test_mouse_keyboard_recenters_at_screen_edge():
+    slider = FakeSlider()
+    response = EdgeMouseResponse()
+    clock_value = iter([0.0, 0.0, 0.01, 0.10])
+    result = run_slider_interaction(
+        slider=slider,
+        screen=FakeScreen(),
+        response_handler=response,
+        control_reader=FakeInput([
+            SliderControls(),
+            SliderControls(),
+            SliderControls(confirm=0.8),
+        ]),
+        input_mode="mouse_keyboard",
+        wait_until=lambda _: None,
+        clock=lambda: next(clock_value),
+    )
+    assert result[0] == 100.0
+    assert response.recenters == [(500.0, 300.0)]