diff --git a/gpui/js/controls.ts b/gpui/js/controls.ts
index ed0ac68..ee0b1a6 100644
--- a/gpui/js/controls.ts
+++ b/gpui/js/controls.ts
@@ -400,6 +400,114 @@ const GENERIC: GenericSpec[] = [
 
 const titleCase = (value: string) => value.charAt(0).toUpperCase() + value.slice(1);
 
+/**
+ * Hall-effect primary buttons (G-Wolves, Lamzu): where the click registers,
+ * rapid trigger, and which switch each button uses. `mag.<field>.<button>`,
+ * with button 0 the left and 1 the right.
+ */
+function magneticControls(s: any): Section[] {
+  const m = s.magneticButtons;
+  if (!m || !Array.isArray(m.buttons) || m.buttons.length === 0) return [];
+  const rtUnit = m.rapidTriggerUnit === "ms" ? "ms" : undefined;
+  return m.buttons.map((b: any, i: number): Section => {
+    const controls: Control[] = [];
+    if (m.canChooseSwitchType && b.switchType) {
+      controls.push({
+        id: `mag.switch.${i}`,
+        label: "Switch",
+        description: "Magnetic needs a calibrated mouse.",
+        kind: "choice",
+        options: [{ value: "magnetic", label: "Magnetic" }, { value: "optical", label: "Optical" }],
+        current: b.switchType,
+      });
+    }
+    if (b.triggerPoint != null && m.triggerPointRange) {
+      controls.push({
+        id: `mag.trigger.${i}`,
+        label: "Trigger point",
+        description: "How far the button travels before it clicks. Lower is lighter.",
+        kind: "number",
+        min: m.triggerPointRange.min,
+        max: m.triggerPointRange.max,
+        step: 1,
+        current: b.triggerPoint,
+      });
+    }
+    if (m.releasePointRange) {
+      controls.push({
+        id: `mag.release.${i}`,
+        label: "Release point",
+        description: "How far the button travels back before it releases.",
+        kind: "number",
+        min: m.releasePointRange.min,
+        max: m.releasePointRange.max,
+        step: 1,
+        current: b.releasePoint ?? b.triggerPoint ?? m.releasePointRange.min,
+      });
+    }
+    if (m.rapidTriggerRange) {
+      const on = b.rapidTriggerEnabled ?? (b.rapidTrigger != null && b.rapidTrigger > 0);
+      controls.push({ id: `mag.rtOn.${i}`, label: "Rapid trigger", description: "Re-clicks the moment the button moves back up.", kind: "toggle", current: Boolean(on) });
+      if (on) {
+        controls.push({
+          id: `mag.rt.${i}`,
+          label: "Rapid trigger sensitivity",
+          kind: "number",
+          min: m.rapidTriggerRange.min,
+          max: m.rapidTriggerRange.max,
+          step: 1,
+          unit: rtUnit,
+          current: b.rapidTrigger ?? m.rapidTriggerRange.min,
+        });
+      }
+    } else if (m.rapidTriggerSwitch === false || b.rapidTrigger != null) {
+      controls.push({ id: `mag.info.rt${i}`, label: "Rapid trigger", description: "Can only be changed with the mouse on its cable.", kind: "info", current: b.rapidTriggerEnabled ? "On" : "Off" });
+    }
+    return { title: m.buttons.length === 2 ? `${i === 0 ? "Left" : "Right"} button` : `Button ${i + 1}`, controls };
+  }).filter((section: Section) => section.controls.length > 0);
+}
+
+/** Writes one magnetic control; the driver confirms by reading the value back. */
+async function writeMagnetic(info: HidInterfaceInfo, status: any, id: string, value: any) {
+  const [, field, rawButton] = id.split(".");
+  const button = Number(rawButton) as 0 | 1;
+  const m = status.magneticButtons;
+  const b = m?.buttons?.[button];
+  if (!m || !b) throw new Error("This mouse's button settings aren't loaded yet.");
+  const min = m.rapidTriggerRange?.min ?? 1;
+  switch (field) {
+    case "trigger":
+      await callClientMethod(info, "setMagneticTriggerPoint", button, Math.round(Number(value)));
+      b.triggerPoint = Math.round(Number(value));
+      return;
+    case "release":
+      await callClientMethod(info, "setMagneticReleasePoint", button, Math.round(Number(value)));
+      b.releasePoint = Math.round(Number(value));
+      return;
+    case "rtOn": {
+      const level = b.rapidTrigger != null && b.rapidTrigger >= min ? b.rapidTrigger : min;
+      await callClientMethod(info, "setMagneticRapidTrigger", button, Boolean(value), level);
+      b.rapidTriggerEnabled = Boolean(value);
+      b.rapidTrigger = level;
+      return;
+    }
+    case "rt":
+      await callClientMethod(info, "setMagneticRapidTrigger", button, true, Math.round(Number(value)));
+      b.rapidTriggerEnabled = true;
+      b.rapidTrigger = Math.round(Number(value));
+      return;
+    case "switch": {
+      const types = m.buttons.map((x: any) => x.switchType);
+      types[button] = String(value);
+      await callClientMethod(info, "setMagneticSwitchTypes", types);
+      b.switchType = String(value);
+      return;
+    }
+    default:
+      throw new Error(`Unknown magnetic control ${id}`);
+  }
+}
+
 function genericFeatures(status: any): Section[] {
   const sections = new Map<string, Control[]>();
   for (const spec of GENERIC) {
@@ -470,7 +578,14 @@ function withCurrent(steps: readonly number[], current: number | null | undefine
  * field the driver reports, minus whatever the driver's own `ui` hints hide — and
  * all of them apply immediately, as they do there.
  */
-function performanceExtras(status: any, caps: DeviceCapabilities): Section[] {
+/** Brands whose drivers implement `setAngleTuning` (the others only report the angle). */
+const ANGLE_TUNING_WRITERS = new Set(["MCHOSE", "Pulsar", "WLMouse"]);
+
+function canWriteAngleTuning(brand: string, status: any): boolean {
+  return ANGLE_TUNING_WRITERS.has(brand) || status.mockAngleTuningWritable === true;
+}
+
+function performanceExtras(brand: string, status: any, caps: DeviceCapabilities): Section[] {
   const ui = status.ui ?? {};
   const c: Control[] = [];
 
@@ -500,6 +615,22 @@ function performanceExtras(status: any, caps: DeviceCapabilities): Section[] {
     }
   }
 
+  // Rotates the sensor's idea of "straight", in whole degrees; the driver checks
+  // its own limits when written. Only some drivers that report it can write it.
+  if (typeof status.angleTuning === "number" && canWriteAngleTuning(brand, status)) {
+    c.push({
+      id: "perf.angleTuning",
+      label: "Angle tuning",
+      description: "Rotates the sensor to correct for how you hold the mouse. 0° is off.",
+      kind: "number",
+      min: -30,
+      max: 30,
+      step: 1,
+      unit: "°",
+      current: status.angleTuning,
+    });
+  }
+
   if (Array.isArray(status.dpiStages) && status.dpiStages.length > 1) {
     c.push({
       id: "perf.dpiStage",
@@ -590,8 +721,8 @@ function performanceExtras(status: any, caps: DeviceCapabilities): Section[] {
 export function describeControls(brand: string, status: any, caps: DeviceCapabilities) {
   return {
     buttons: [...razerAndEgg(brand, status), ...genericButtons(status)],
-    advanced: [...advanced(status, brand), ...hits(status, brand), ...extras(status), ...genericFeatures(status), ...deviceInfo(status)],
-    performance: performanceExtras(status, caps),
+    advanced: [...advanced(status, brand), ...hits(status, brand), ...magneticControls(status), ...extras(status), ...genericFeatures(status), ...deviceInfo(status)],
+    performance: performanceExtras(brand, status, caps),
     lighting: status.lighting ?? null,
   };
 }
@@ -637,6 +768,7 @@ export async function writeControl(info: HidInterfaceInfo, status: any, id: stri
   // The shared remapper: the button's display label is the part after the slash.
   if (id.startsWith("gen.button/")) return w.setButtonMapping(info, id.slice("gen.button/".length), value);
   if (id.startsWith("hits.")) return writeHits(info, status, id, value);
+  if (id.startsWith("mag.") && !id.startsWith("mag.info.")) return writeMagnetic(info, status, id, value);
   // Table-driven generic setting: `gen.set/<field>/<method>`.
   if (id.startsWith("gen.set/")) return callClientMethod(info, id.split("/")[2], value);
   const [family, kind, rest] = id.split(".");
@@ -723,6 +855,7 @@ export async function writeControl(info: HidInterfaceInfo, status: any, id: stri
     case "perf.sleep": return w.setSleepTimeout(info, Number(value));
     case "perf.motionSync": return w.setMotionSync(info, Boolean(value));
     case "perf.angleSnapping": return w.setAngleSnapping(info, Boolean(value));
+    case "perf.angleTuning": await callClientMethod(info, "setAngleTuning", Math.round(Number(value))); status.angleTuning = Math.round(Number(value)); return;
     case "perf.rippleControl": return w.setRippleControl(info, Boolean(value));
     case "perf.performanceMode": return w.setPerformanceMode(info, Boolean(value));
     case "perf.dpiStage": return w.setActiveDpiStage(info, Number(value));
diff --git a/gpui/js/entry.ts b/gpui/js/entry.ts
index 2905057..c94cd23 100644
--- a/gpui/js/entry.ts
+++ b/gpui/js/entry.ts
@@ -146,9 +146,10 @@ const mockWanted = (): string => String((globalThis as any).__mock ?? "");
       const status = lastStatus.get(key) ?? {};
       const id = action.slice("control:".length);
       await writeControl(info, status, id, value);
-      // A few controls decide which others are shown (an Starlight X switch in
-      // TMR mode gains its analog settings); their write returns the new layout.
-      if (id.startsWith("slx.mode") || id === "slx.link" || id === "hits.link") return JSON.stringify({ tabs: describeControls(brand, status, lastCaps.get(key)) });
+      // A few controls decide which others are shown (a Starlight X switch in
+      // TMR mode gains its analog settings, a magnetic button's rapid trigger its
+      // sensitivity); their write returns the new layout.
+      if (id.startsWith("slx.mode") || id === "slx.link" || id === "hits.link" || id.startsWith("mag.rtOn.")) return JSON.stringify({ tabs: describeControls(brand, status, lastCaps.get(key)) });
       return JSON.stringify(value);
     }
     if (action === "lighting") {
diff --git a/gpui/js/mock.ts b/gpui/js/mock.ts
index 4b1bb9b..3dfe0ab 100644
--- a/gpui/js/mock.ts
+++ b/gpui/js/mock.ts
@@ -1,5 +1,5 @@
 // A fake Finalmouse Starlight X for looking at the UI without hardware
-// (OPENMOUSE_MOCK=slx, ulx or x3; a trailing "!" hides the real devices). Nothing here talks to a device: writes are accepted
+// (OPENMOUSE_MOCK=slx, ulx, x3 or mag; a trailing "!" hides the real devices). Nothing here talks to a device: writes are accepted
 // and only the in-memory status changes.
 
 export const isMockKey = (key: string) => key.startsWith("mock:");
@@ -14,15 +14,19 @@ export const mockCandidates = (wanted: string) => [
     info: { key: "mock:ulx", vendorId: 0x361d, productId: 0x0100, productString: "Finalmouse UltralightX (mock)", manufacturerString: "Finalmouse", collections: [] },
     brands: ["Finalmouse"],
   }] : []),
+  ...(wanted.includes("mag") ? [{
+    info: { key: "mock:mag", vendorId: 0x373b, productId: 0x1000, productString: "Magnetic mouse (mock)", manufacturerString: "Lamzu", collections: [] },
+    brands: ["Lamzu"],
+  }] : []),
   ...(wanted.includes("x3") ? [{
     info: { key: "mock:x3", vendorId: 0x046d, productId: 0xc0a9, productString: "PRO X 3 Superstrike (mock)", manufacturerString: "Logitech", collections: [] },
     brands: ["Logitech"],
   }] : []),
 ];
 
-export const mockBrand = (key: string) => (key === "mock:x3" ? "Logitech" : "Finalmouse");
+export const mockBrand = (key: string) => (key === "mock:x3" ? "Logitech" : key === "mock:mag" ? "Lamzu" : "Finalmouse");
 
-export const mockStatus = (key: string) => (key === "mock:x3" ? mockX3() : key === "mock:ulx" ? mockUlx() : mockSlx());
+export const mockStatus = (key: string) => (key === "mock:x3" ? mockX3() : key === "mock:mag" ? mockMag() : key === "mock:ulx" ? mockUlx() : mockSlx());
 
 // Ultralight X as FinalmouseHidClient.readStatus() reports it: the whole
 // polling ladder and Motion Sync are adjustable, lift-off is the legacy 1/2 mm
@@ -53,6 +57,37 @@ const mockUlx = () => ({
   firmware: ["Mouse 1.0.8", "Dongle RF 1.0.3", "Dongle USB 1.0.5"],
 });
 
+// A Hall-effect mouse as the Lamzu driver reports it: per-button trigger and
+// release travel, rapid trigger in ms with no switch of its own, selectable
+// switch type, and a sensor angle.
+const mockMag = () => ({
+  brand: "Lamzu",
+  name: "Magnetic mouse",
+  batteryPercent: 77,
+  batteryState: "Discharging",
+  connectionType: "Wireless",
+  dpi: 1600,
+  pollingRateHz: 1000,
+  supportedPollingRates: [500, 1000, 2000, 4000],
+  activeProfile: 1,
+  angleTuning: 5,
+  mockAngleTuningWritable: true,
+  magneticButtons: {
+    buttons: [
+      { switchType: "magnetic", triggerPoint: 3, releasePoint: 3, rapidTrigger: 4, rapidTriggerEnabled: true },
+      { switchType: "magnetic", triggerPoint: 5, releasePoint: null, rapidTrigger: null, rapidTriggerEnabled: false },
+    ],
+    triggerPointRange: { min: 1, max: 10 },
+    releasePointRange: { min: 1, max: 10 },
+    rapidTriggerRange: { min: 1, max: 15 },
+    rapidTriggerUnit: "ms",
+    rapidTriggerSwitch: false,
+    canChooseSwitchType: true,
+    calibration: "calibrated",
+    liveDepth: false,
+  },
+});
+
 const mockX3 = () => ({
   brand: "Logitech",
   name: "PRO X 3 Superstrike",