diff --git a/inputprofiles/M-VAVE-SMC-PAD.qxi b/inputprofiles/M-VAVE-SMC-PAD.qxi
index 5650753..1bae709 100644
--- a/inputprofiles/M-VAVE-SMC-PAD.qxi
+++ b/inputprofiles/M-VAVE-SMC-PAD.qxi
@@ -73,4 +73,100 @@
Knob 16
Knob
+
+ Pan FL
+ Knob
+
+
+ Pan FR
+ Knob
+
+
+ Pan BL
+ Knob
+
+
+ Pan BR
+ Knob
+
+
+ Tilt FL
+ Knob
+
+
+ Tilt FR
+ Knob
+
+
+ Tilt BL
+ Knob
+
+
+ Tilt BR
+ Knob
+
+
+ Pad 1
+ Button
+
+
+ Pad 2
+ Button
+
+
+ Pad 3
+ Button
+
+
+ Pad 4
+ Button
+
+
+ Pad 5
+ Button
+
+
+ Pad 6
+ Button
+
+
+ Pad 7
+ Button
+
+
+ Pad 8
+ Button
+
+
+ Pad 9
+ Button
+
+
+ Pad 10
+ Button
+
+
+ Pad 11
+ Button
+
+
+ Pad 12
+ Button
+
+
+ Pad 13
+ Button
+
+
+ Pad 14
+ Button
+
+
+ Pad 15
+ Button
+
+
+ Pad 16
+ Button
+
diff --git a/scripts/mover_offsets_midi.py b/scripts/mover_offsets_midi.py
new file mode 100644
index 0000000..e46c421
--- /dev/null
+++ b/scripts/mover_offsets_midi.py
@@ -0,0 +1,215 @@
+#!/usr/bin/env python3
+"""Keep each mover's pan and tilt correction when the knobs turn.
+
+Knob 9 (CC 38) and knob 10 (CC 39) are relative encoders, but QLC reads
+the CC as an absolute position. Every slider bound to that CC jumps to
+the same value, so the per-head offsets collapse.
+
+This sits between the SMC-PAD and QLC+. It forwards every message, and
+on CC 38/39 it also adds the encoder step to each head and sends that
+head's own position on CC 50–53 (pan) and 54–57 (tilt).
+
+ pipenv run python scripts/mover_offsets_midi.py
+
+Reload shows/twisted.qxw after it is running. Stopping this script puts
+the pad straight back onto QLC+.
+"""
+
+from __future__ import annotations
+
+import re
+import signal
+import subprocess
+import sys
+import threading
+import time
+import xml.etree.ElementTree as ET
+from pathlib import Path
+
+import mido
+
+ROOT = Path(__file__).resolve().parents[1]
+SHOW = ROOT / "shows" / "twisted.qxw"
+
+PAN_KNOB = 38
+TILT_KNOB = 39
+# FL, FR, BL, BR. These are the slider input channels in the show.
+PAN_CC = (50, 51, 52, 53)
+TILT_CC = (54, 55, 56, 57)
+HEADS = PAN_CC + TILT_CC
+
+NS = {"w": "http://www.qlcplus.org/Workspace"}
+CLIENT_RE = re.compile(r"^client (\d+): '([^']*)'")
+PORT_RE = re.compile(r"^\s+(\d+) '([^']*)'")
+
+
+def midi_to_dmx(midi: int) -> int:
+ """QLC+ MIDI2DMX: (value * 255) / 127."""
+ return (max(0, min(127, midi)) * 255) // 127
+
+
+_DMX_TO_MIDI = [
+ min(range(128), key=lambda midi, dmx=dmx: (abs(midi_to_dmx(midi) - dmx), midi))
+ for dmx in range(256)
+]
+
+
+def dmx_to_midi(dmx: int) -> int:
+ return _DMX_TO_MIDI[max(0, min(255, dmx))]
+
+
+def encoder_delta(value: int) -> int:
+ """1..63 clockwise, 65..127 counter-clockwise."""
+ if value <= 0 or value == 64 or value > 127:
+ return 0
+ if value < 64:
+ return value
+ return value - 128
+
+
+def load_positions(path: Path = SHOW) -> dict[int, int]:
+ """DMX value of each offset slider, keyed by its MIDI channel."""
+ positions = {cc: 0 for cc in HEADS}
+ root = ET.parse(path).getroot()
+ for slider in root.findall(".//w:Slider", NS):
+ source = slider.find("w:Input", NS)
+ level = slider.find("w:Level", NS)
+ if source is None or level is None:
+ continue
+ channel = source.get("Channel")
+ if channel is None or int(channel) not in positions:
+ continue
+ value = level.get("Value")
+ if value is not None:
+ positions[int(channel)] = int(value)
+ return positions
+
+
+def alsa_ports() -> list[tuple[int, int, str, str]]:
+ text = subprocess.check_output(["aconnect", "-l"], text=True)
+ client = 0
+ client_name = ""
+ found: list[tuple[int, int, str, str]] = []
+ for line in text.splitlines():
+ match = CLIENT_RE.match(line)
+ if match:
+ client = int(match.group(1))
+ client_name = match.group(2)
+ continue
+ match = PORT_RE.match(line)
+ if match:
+ found.append((client, int(match.group(1)), client_name, match.group(2).strip()))
+ return found
+
+
+def find_port(ports: list[tuple[int, int, str, str]], name: str) -> tuple[int, int]:
+ for client, port, client_name, port_name in ports:
+ if name in client_name or name in port_name:
+ return client, port
+ raise SystemExit(f"ALSA port {name!r} not found")
+
+
+def connect(src: tuple[int, int], dst: tuple[int, int]) -> None:
+ subprocess.check_call(["aconnect", f"{src[0]}:{src[1]}", f"{dst[0]}:{dst[1]}"])
+
+
+def disconnect(src: tuple[int, int], dst: tuple[int, int]) -> None:
+ subprocess.call(["aconnect", "-d", f"{src[0]}:{src[1]}", f"{dst[0]}:{dst[1]}"])
+
+
+def main() -> None:
+ positions = load_positions()
+ print(
+ "pan "
+ + " ".join(str(positions[cc]) for cc in PAN_CC)
+ + " tilt "
+ + " ".join(str(positions[cc]) for cc in TILT_CC),
+ flush=True,
+ )
+
+ pad = find_port(alsa_ports(), "SMC-PAD Bluetooth")
+ qlc = find_port(alsa_ports(), "qlcplus")
+
+ pad_in = mido.open_input("mover-offset-in", virtual=True)
+ qlc_out = mido.open_output("mover-offset-out", virtual=True)
+ feedback = mido.open_input("mover-offset-fb", virtual=True)
+ time.sleep(0.2)
+ ports = alsa_ports()
+ bridge_in = find_port(ports, "mover-offset-in")
+ bridge_out = find_port(ports, "mover-offset-out")
+ bridge_fb = find_port(ports, "mover-offset-fb")
+
+ lock = threading.Lock()
+ ignore_until: dict[int, float] = {}
+
+ def on_feedback(msg: mido.Message) -> None:
+ if msg.type != "control_change" or msg.control not in positions:
+ return
+ if time.monotonic() < ignore_until.get(msg.control, 0):
+ return
+ with lock:
+ positions[msg.control] = midi_to_dmx(msg.value)
+
+ feedback.callback = on_feedback
+
+ def fan(ccs: tuple[int, ...], channel: int, delta: int) -> None:
+ if delta == 0:
+ return
+ with lock:
+ for cc in ccs:
+ nxt = max(0, min(255, positions[cc] + delta))
+ midi = dmx_to_midi(nxt)
+ positions[cc] = midi_to_dmx(midi)
+ ignore_until[cc] = time.monotonic() + 0.05
+ qlc_out.send(
+ mido.Message(
+ "control_change", channel=channel, control=cc, value=midi
+ )
+ )
+
+ wired = False
+
+ def restore(*_args: object) -> None:
+ nonlocal wired
+ if not wired:
+ return
+ wired = False
+ feedback.callback = None
+ disconnect(pad, bridge_in)
+ disconnect(bridge_out, qlc)
+ disconnect(qlc, bridge_fb)
+ connect(pad, qlc)
+ print("pad connected straight to QLC+", flush=True)
+
+ def stop(*_args: object) -> None:
+ restore()
+ sys.exit(0)
+
+ signal.signal(signal.SIGINT, stop)
+ signal.signal(signal.SIGTERM, stop)
+
+ disconnect(pad, qlc)
+ connect(pad, bridge_in)
+ connect(bridge_out, qlc)
+ connect(qlc, bridge_fb)
+ wired = True
+ print(
+ f"SMC-PAD {pad[0]}:{pad[1]} → offsets → QLC+ {qlc[0]}:{qlc[1]}",
+ flush=True,
+ )
+
+ try:
+ for msg in pad_in:
+ qlc_out.send(msg)
+ if msg.type != "control_change":
+ continue
+ if msg.control == PAN_KNOB:
+ fan(PAN_CC, msg.channel, encoder_delta(msg.value))
+ elif msg.control == TILT_KNOB:
+ fan(TILT_CC, msg.channel, encoder_delta(msg.value))
+ finally:
+ restore()
+
+
+if __name__ == "__main__":
+ main()