LinearMouse: a Mac utility for pointer acceleration, scroll and button behaviour

The problem: macOS gives you one pointer speed slider for every device

macOS exposes a single pointer speed slider and a single pointer acceleration setting. If you use a trackpad at the desk and an external mouse at the same time, both devices inherit the same curve. That is fine until you want the mouse to move linearly while the trackpad keeps the acceleration you are used to. The system preference pane offers no per-device override, and no way to express acceleration as a curve rather than a level.

LinearMouse exists to fill that gap. The README describes it as "The mouse and trackpad utility for Mac," and the repository topics list acceleration, cursor, sensitivity, scrolling and productivity. The credits section states that the way LinearMouse modifies pointer speed is inspired by Mac Mouse Fix, so the design lineage is explicit rather than hidden. The intended user is someone who has a mouse they like and a cursor response they dislike, and who is willing to grant a system permission to fix it.

How LinearMouse intercepts and rewrites pointer input

The repository layout shows the app is a Swift/Xcode project with a set of local Swift packages under Modules/. Four of them are named in the Makefile test targets: HIDPP, GestureKit, DockKit and PointerKit. HIDPP is the Logitech HID++ protocol; GestureKit, DockKit and PointerKit are the gesture, dock and pointer layers. Each has its own test target invoked through swift test --package-path, which means they are developed and tested independently of the app target.

The app target itself is LinearMouse.xcodeproj, built with xcodebuild archive and exported with ExportOptions.plist. Configuration is generated, not hand-written: Signing.xcconfig, Version.xcconfig and Release.xcconfig are produced by scripts under Scripts/. There is also a Documentation/Configuration.d.ts file that a package.json script turns into Documentation/Configuration.json with ts-json-schema-generator. That schema is the machine-readable description of the app's configuration format, and its existence tells you the configuration surface is treated as a contract rather than an internal detail.

What the public README does not describe is the interception mechanism itself. It points to https://linearmouse.app for getting started and says nothing about how events are captured or where settings are stored. The ACCESSIBILITY.md file at the repository root implies an accessibility permission is part of the setup, which is consistent with a utility that needs to observe and modify input events. Treat the exact event path as undocumented in the repository.

Installing LinearMouse and setting a first device rule

The README gives no install instructions. It says only: "Please visit https://linearmouse.app." That site is also listed as the project homepage, and the release badge in the README points at the latest GitHub release, whose download asset is named LinearMouse.dmg. If you prefer a package manager, the search data shows people look for "Linearmouse brew," but the repository does not document a Homebrew formula, so verify that yourself before relying on it.

The build path is documented in the Makefile, for anyone who wants to compile from source. The default target runs configure, clean, lint, test and package in sequence:

make

That target depends on generated configuration files. configure-code-signing and configure-version produce Signing.xcconfig and Version.xcconfig, and the pre-commit hook is copied into .git/hooks. The packaging step archives the app and builds a DMG with hdiutil:

make package
ls build/LinearMouse.dmg

If you only want to run the unit tests for the individual modules, the Makefile exposes them separately. This is useful when you are changing pointer behaviour and want a fast signal without a full app build:

make pointerkit-test
make hidpp-test

After installing, the first real task is to grant the permission the app needs. ACCESSIBILITY.md sits at the repository root as the project's own note on that requirement; read it before you start toggling settings, because a mouse utility that cannot observe input will appear to do nothing. The second task is to decide whether you want acceleration off entirely or merely reduced, and to apply that per device rather than globally. The repository does not document the settings UI, so the app itself is the reference for what each control does.

Where LinearMouse is the wrong tool

LinearMouse is macOS-only. The topics list mac and macos, the language is Swift, and the build is an Xcode archive exported to a DMG. The search data contains "Linear mouse for Windows" and "linearmouse windows," which are questions the project cannot answer. If your daily driver is Windows or Linux, this project is not a candidate at all.

The second limitation is release maturity. The three most recent releases listed are v0.12.0-beta.5, v0.12.0-beta.4 and v0.12.0-beta.3, dated 2026-09-12, 2026-08-09 and 2026-08-09. The current line is a beta line. The repository is not archived and the last push was on 2026-09-14, so development is ongoing, but anyone who needs a frozen, long-supported build should treat the beta channel as a real consideration rather than a footnote.

The third limitation is structural. A utility that modifies input events sits between your hardware and the system, and the repository's own ACCESSIBILITY.md signals that it needs an accessibility permission to do its job. When macOS changes its permission model or its input stack, this class of tool is affected first. The README does not document a rollback procedure or a safe mode, so if a setting makes the pointer unusable you are relying on the app's own UI to recover, not on a documented fallback.

LinearMouse compared with Mac Mouse Fix and Mos

The README credits Mac Mouse Fix directly: "The way to modify the pointer speed (sensitivity) is inspired by Mac Mouse Fix." That is an acknowledgement, not a feature comparison, and it tells you the two projects overlap on pointer speed. The difference visible in the repository is scope. LinearMouse ships separate modules for HID++ (Logitech's device protocol), gestures, dock behaviour and pointer handling, and it publishes a JSON schema for its configuration format. Mac Mouse Fix is described in the credits only as the inspiration for the sensitivity approach; nothing in this repository states what it does beyond that.

Mos is the other name that appears in the search data, as "linearmouse vs mos." The repository says nothing about Mos. What can be said from the repository here is that LinearMouse's configuration is schema-backed and generated from a TypeScript definition, which is a stronger commitment to a stable config surface than a project that only ships a settings window. If you need to script or version-control your pointer configuration, that schema is the concrete difference to check first. If you only want to flip acceleration off once and forget it, the extra structure buys you nothing.

Licence, maintenance and what an upgrade actually costs

LinearMouse is MIT licensed, per the LICENSE file and the badge in the README. MIT is permissive: you can use, modify and redistribute the code, including in closed products, provided the copyright notice and permission notice are retained. That is the general shape of the licence, not legal advice; read LICENSE yourself if you plan to redistribute.

Maintenance is visible but not frozen. The last push was on 2026-09-14, and the most recent release, v0.12.0-beta.5, was published on 2026-09-12. The Makefile encodes the full release pipeline, including a prepublish target that runs Scripts/sign-and-notarize, so signed and notarized builds are part of the normal flow rather than an afterthought.

The upgrade cost is mostly on the configuration side. Because Documentation/Configuration.json is generated from Documentation/Configuration.d.ts by a package.json script, any change to the configuration type flows into the published schema. If you keep a config file under version control, that schema is what you diff against when you upgrade. Building from source also requires the generated xcconfig files, so a fresh clone cannot go straight to xcodebuild without running the configure step first.

Editorial conclusion

Adopt LinearMouse if you use an external mouse on macOS and want to disable or tune pointer acceleration per device without patching the system. Skip it if you need a Windows build, or if you want a stable release rather than the 0.12.0 beta line. Before installing, check the accessibility permission requirement in ACCESSIBILITY.md and confirm the current release channel on the project's release page.

Frequently asked questions

Official sources

1. License: MIT
2. linearmouse/linearmouse on GitHub
3. Project website
4. README
5. Releases