LinearMouse: a Swift mouse and trackpad utility for Mac, shipped as a DMG and built from four internal modules

One DMG from GitHub releases is the install path

LinearMouse calls itself the mouse and trackpad utility for Mac, and getting it means downloading a disk image. The download link points at https://github.com/linearmouse/linearmouse/releases/latest/download/LinearMouse.dmg, and the project's site at https://linearmouse.app is the other place it sends new users.

The Makefile shows what is inside that image. After the app is exported, the package target copies LinearMouse.app into build/target, creates a symlink to /Applications next to it, and compresses the folder with hdiutil:

hdiutil create -format UDBZ -srcfolder '$(TARGET_DIR)/' -volname LinearMouse '$(TARGET_DMG)'

The /Applications symlink is the familiar drag-to-install layout. Everything in this pipeline is macOS tooling, from xcodebuild to hdiutil, so there is nothing here for Windows users: the app is built as a Mac application from LinearMouse.xcodeproj and packaged only as a DMG.

The 0.13 line exists only as betas so far

The three newest releases are all prereleases of the same version. v0.13.0-beta.3 was published on 2026-10-05, v0.13.0-beta.4 on 2026-10-11 and v0.13.0-beta.5 on 2026-11-01. The last push to the repository came on 2026-11-02, the day after beta.5, so work on this line was still landing at that point.

The consequence for users is simple: none of these is a final 0.13.0. Anyone who wants the changes in the 0.13 line is running beta software on the machine where their pointer behavior depends on it. If you install LinearMouse on a work computer, check which version the DMG you downloaded actually contains before you settle on it, and read the release entry for that tag. If a beta misbehaves, the project takes bug reports through GitHub, with the contributing guide in CONTRIBUTING.md.

HIDPP, GestureKit, DockKit and PointerKit live as separate Swift packages

The app is not one monolithic target. Modules/ holds four Swift packages, and the Makefile tests each one on its own before running the app's test scheme:

swift test --package-path Modules/HIDPP
swift test --package-path Modules/GestureKit
swift test --package-path Modules/DockKit
swift test --package-path Modules/PointerKit

The test target then runs the Xcode scheme:

xcodebuild test -project LinearMouse.xcodeproj -scheme LinearMouse $(XCODEBUILD_ARGS)

LinearMouseUnitTests/ holds the app-level tests that scheme picks up. The split matters for contributors. A change confined to one module can be checked with a single swift test call against that package path, without building the whole application. A change to the app itself needs Xcode and the LinearMouse scheme. XCODEBUILD_ARGS is empty by default and is the hook for passing extra flags to every xcodebuild call in the Makefile.

make all stops at lint without swiftformat and swiftlint

The default Makefile target chains five steps: configure, clean, lint, test and package. The lint step runs two external tools that are not part of Xcode:

swiftformat --lint .
swiftlint .

Their settings sit at the top of the repository in .swiftformat and .swiftlint.yml, and .swift-version pins the Swift version the project expects. A machine without swiftformat or swiftlint installed will fail at lint, before any tests or packaging run, so a first build from a fresh clone needs those tools in place.

The configure step also touches your checkout in a way worth knowing about. It copies Scripts/pre-commit into .git/hooks/pre-commit, so running make installs a git hook in your clone. If you already keep your own pre-commit hook in that repository, it gets replaced. Inspect Scripts/pre-commit before running make the first time.

A shareable build needs your own signing and the notarize script

Several configuration files are generated rather than committed. Signing.xcconfig comes from Scripts/configure-code-signing, with Signing.xcconfig.tpl as the template in the repository. Version.xcconfig comes from Scripts/configure-version, and the configure-release target adds Release.xcconfig from Scripts/configure-release. Config.xcconfig is the committed base.

The release app is produced in two xcodebuild calls, an archive and an export that reads ExportOptions.plist:

xcodebuild archive -project LinearMouse.xcodeproj -scheme LinearMouse -archivePath '$(ARCHIVE_PATH)' $(XCODEBUILD_ARGS)
xcodebuild -exportArchive -archivePath '$(ARCHIVE_PATH)' -exportOptionsPlist ExportOptions.plist -exportPath '$(BUILD_DIR)/Release'

The prepublish target then runs Scripts/sign-and-notarize after packaging. The consequence is that a DMG you build locally is not the same artifact as the one on the releases page. Handing your own build to other people means supplying your own signing identity and going through notarization yourself.

Settings are defined by a TypeScript type, not a page of prose

The shape of LinearMouse's configuration lives in Documentation/Configuration.d.ts. package.json turns that type into a JSON Schema with one script, generate:json-schema:

ts-json-schema-generator --path 'Documentation/Configuration.d.ts' --type Configuration > Documentation/Configuration.json

The result, Documentation/Configuration.json, is the machine-readable description of what a configuration can contain. For someone wondering which settings exist and what values they accept, those two files are the authoritative reference in the repository; the front page of the project on GitHub carries only download, contribution, translation and sponsor links. Running the generator needs Node and the dev dependencies from package.json, including ts-json-schema-generator ^1.0.0 and @types/node pinned to 18.11.18 through both devDependencies and overrides. Anyone editing the type by hand should regenerate the JSON so the two do not drift apart.

Translations arrive through Crowdin or a pasted agent prompt

LinearMouse offers two routes for fixing its translations. One is Crowdin, configured by crowdin.yml in the repository root. The other is a ready-made prompt you paste into a coding agent, adding the language and the problem:

Fix the translation issues below in https://github.com/linearmouse/linearmouse.
Check where the text is used in the app, make the corrections, and open a pull request.

[Describe the language and translation issues here.]

The repository is set up for that kind of contributor. AGENTS.md, CLAUDE.md, a .codex/ directory and .coderabbit.yaml all sit at the top level, and package.json carries a translate:xcstrings script that runs node Scripts/translate-xcstrings.mjs, with the openai ^4.104.0 package among its dependencies. The cost is on the review side: an agent-written pull request still has to be checked by a human who knows the language. Contributors without an agent can use Crowdin instead.

MIT code, third-party notices and three funding channels

The code is under the MIT License, in LICENSE at the top level. LinearMouse builds on other projects, and their names and licenses are collected in LinearMouse/ThirdPartyNotices, which is the file to read if you are checking what ships inside the app. ACCESSIBILITY.md and CODE_OF_CONDUCT.md sit beside the contributing guide.

There is no paid tier in the repository. Support comes through GitHub Sponsors, Open Collective or Ko-fi. For a utility that sits between your hardware and every app you use, the open license is the practical safeguard: the Swift source, the build scripts and the signing steps are all in the repository, so anyone with doubts about a release can read the code or build their own copy, at the cost of handling signing themselves.

Editorial conclusion

LinearMouse suits Mac users who want an open source, MIT-licensed mouse and trackpad utility they can download as a DMG or build themselves with Xcode. It is not for Windows users, since the whole build runs on xcodebuild and hdiutil. Before installing, check whether the build you are getting is a v0.13.0 beta or a final release, and if you plan to build from source, have swiftformat, swiftlint and your own code signing setup ready.

Frequently asked questions

Official sources

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