SlamX is an experimental native macOS utility that reads the built-in Apple SPU accelerometer, detects sharp impact spikes, increments a counter, and plays local sound feedback.

Motion data stays on the Mac. SlamX does not use the microphone, does not request microphone access, and does not provide audio-based fallback detection for unsupported Macs.

SlamX is a technical preview for supported MacBooks. Use light taps for calibration and testing; Johannes is not responsible for hardware damage caused by excessive force.

Onboarding	Calibration	Live Dashboard

• SlamX
  • Showcase
  • Contents
  • Highlights
  • Compatibility
  • Why This Exists
  • Current Workflow
  • Tech Stack
  • Requirements
  • Quick Start
  • Usage
  • Privacy & Trust
  • Release & Distribution Status
  • CI & Repository Health
  • Development
  • Research Notes
  • Roadmap
  • License

Unsupported Mac means unsupported live detection. SlamX is sensor-only by design.

MacBooks contain internal motion hardware, but Apple does not expose a clean public Core Motion API for MacBook accelerometer data. The practical route for this experiment is the HID stream exposed by AppleSPUHIDDevice.

SlamX wraps that low-level stream in a small native app with visible telemetry, calibration, and local audio feedback so tuning is observable instead of guesswork.

The stable app path uses direct local HID access. Historical or pre-release admin-helper builds may exist for compatibility experiments, but they are not the normal stable-flow expectation.

1. Start SlamX.
2. Complete the sensor availability check.
3. Verify live detection with one light tap during onboarding.
4. Open the monitor and start listening from the toolbar, menu bar, or Command-R.
5. Watch live impact, peak, sample rate, axes, and raw report telemetry.
6. Tune the threshold manually or use the calibration wizard.
7. Select a bundled or custom local sound.

If no accessible Apple SPU accelerometer is found, SlamX explains that the Mac is unsupported and blocks live detection.

• macOS 14 or newer
• Supported MacBook with an accessible Apple SPU accelerometer
• Xcode for app packaging through SlamX.xcodeproj
• Swift 6 compatible toolchain for package builds and tests
• Node.js/npm available for DMG generation through npx create-dmg

Run tests:

DEVELOPER_DIR=/Applications/Xcode.app/Contents/Developer swift test

Run the app from SwiftPM:

DEVELOPER_DIR=/Applications/Xcode.app/Contents/Developer swift run SlamX

Open the native Xcode project for signing, app icon work, archives, and normal macOS app development:

open SlamX.xcodeproj

Build a local .app bundle:

./scripts/package-app.sh <version> <build-number>
open .build/xcode-release/Release/SlamX.app

Example:

./scripts/package-app.sh 0.3.4 8

• On first launch, complete the availability check and sound-test onboarding with one light tap.
• Start or stop monitoring from the toolbar, menu bar extra, or Command-R.
• Use the threshold slider or calibration wizard to tune detection.
• Choose Slap, Air Pop, Alert, or Snap; enable bonus sounds in Settings to unlock Spotlight.
• Add custom MP3 files from the Monitor sound control, then select or remove them from the Custom MP3s menu.
• Use Command-T to test the selected sound.
• Use Command-Shift-M to mute or unmute sounds globally.
• Use Command-0 to reset the counter.
• Use Command-U to check for updates.

• SlamX reads local Apple SPU accelerometer reports through IOKit.
• SlamX is sensor-only and does not request microphone access.
• Motion samples, raw HID bytes, counters, thresholds, and selected sounds are not uploaded.
• Custom MP3 files are copied into local Application Support storage only after the user chooses them.
• Sparkle contacts the public update feed configured in Resources/Info.plist.
• Unsupported Macs do not fall back to microphone or audio-based detection.

SlamX is public-source friendly and publishes release assets, but it is still a technical preview until Developer ID signing and notarization are in place.

Create the full local release asset set:

./scripts/create-release-assets.sh <version> <build-number>

Use curated human release notes when preparing a public release:

RELEASE_NOTES_FILE=/path/to/release-notes.html ./scripts/create-release-assets.sh <version> <build-number>

For a release tag that differs from the numeric app version:

RELEASE_TAG=v0.3.4-fix ./scripts/create-release-assets.sh 0.3.4 8

Upload these generated assets for a complete release:

Do not present a local DMG as a polished public binary until it is Developer-ID signed, notarized, stapled, and tested on a Gatekeeper-enabled Mac.

Current CI is intentionally small but useful: it protects the testable Swift core, scans for leaked secrets, scans dependency risk, and keeps dependencies visible.

Run the test suite:

DEVELOPER_DIR=/Applications/Xcode.app/Contents/Developer swift test

Run the app in debug mode:

DEVELOPER_DIR=/Applications/Xcode.app/Contents/Developer swift run SlamX

Build through Xcode:

DEVELOPER_DIR=/Applications/Xcode.app/Contents/Developer xcodebuild \
  -project SlamX.xcodeproj \
  -scheme SlamX \
  -configuration Debug \
  -destination 'platform=macOS' \
  CODE_SIGNING_ALLOWED=NO \
  build

Package a local release app:

./scripts/package-app.sh <version> <build-number>

Build a local DMG and checksum:

./scripts/create-dmg.sh <version> <build-number>

Generate a Sparkle appcast from existing DMG assets:

./scripts/generate-appcast.sh .build/dmg

Prepare the full release asset set:

./scripts/create-release-assets.sh <version> <build-number>

Detailed Sparkle release notes live in docs/sparkle-updates.md.

• Apple documents Core Motion primarily for platforms with a public CMMotionManager path, but that is not the MacBook accelerometer interface SlamX uses.
• Apple documents the HID APIs used here through IOKit, including IOHIDDeviceRegisterInputReportCallback.
• The local IORegistry exposes the relevant MacBook stream as AppleSPUHIDDevice with usage page 0xFF00 and usage 0x03.
• Recent Apple SPU drivers may need driver/reporting state to be awake before accelerometer reports appear.
• The parser stays isolated because Apple can change private report layout details between hardware generations.

MIT