MacCheck: a local macOS hardware check for buying a used Mac

The used-Mac problem MacCheck is built around

A private sale of a Mac has a specific shape: the seller is in front of you, the machine boots, and you have a few minutes to decide. The information that matters is scattered. Battery cycle count sits in System Settings, storage wear is invisible, MDM enrolment and activation lock are not obvious from the desktop, and the keyboard, microphone and camera need someone to actually press and speak and look. MacCheck gathers those checks into one window and produces a report you can keep. The README frames it for three audiences: second-hand Mac transactions, store inspections, and personal self-checks. That framing matters, because a tool built for a transaction has to finish quickly and leave an artifact. The export step (PDF or PNG long image, plus a saved history snapshot for later comparison) is the part that turns a pile of readings into something a buyer or a shop can file.

What the app reads automatically and what it asks you to do

MacCheck splits its work in two. The automatic pass reads model, chip, memory, macOS version, serial number and model year, then battery cycle count and health, storage space, network, Bluetooth and ports. It also surfaces the items that decide used-Mac deals: MDM enrolment, Apple ID and activation lock, and the security chip. Those are flagged in an overview area, and the README says red items should be confirmed first. The second half is interactive. Keyboard keys light up one by one as you press them, the screen cycles through solid colours, greyscale and checkerboard patterns, and audio, microphone, camera, Touch ID and trackpad each have their own test. There is also a disk read/write speed test, a performance stress test, and a per-port check for the physical interfaces. The README notes that some checks depend on system permissions, machine capability or attached devices, and will show as unsupported or skipped when the environment does not allow them. That is an honest design: a test that cannot run reports as skipped rather than passing silently.

Installing MacCheck from the DMG

The README's quick install path is the release DMG rather than a package manager. Download MacCheck-1.2.dmg from GitHub Releases, open it, and drag MacCheck.app into Applications. On first launch, if Gatekeeper complains, the documented workaround is to right-click the app and choose Open. Camera, microphone and Bluetooth items request system permissions as they are needed.

sudo xattr -rd com.apple.quarantine /Applications/MacCheck.app

The README gives this command for the case where macOS reports the app as damaged, which it attributes to the download quarantine attribute. It says to confirm the app is already in /Applications before running it. A separate command in the same section, sudo spctl --master-disable, turns on the Anywhere option in Privacy & Security; the README explicitly warns that it lowers Gatekeeper protection and should only be used when the app's source is trusted. Treat that one as a last resort, not a setup step.

Once open, the flow is: wait for the home screen to finish its automatic detection, read the overview and major-issues area, work through the hardware test items on the left, click Save to History to keep a snapshot, then click Export Report and pick PNG or PDF.

Building MacCheck from source and packaging a DMG

Source builds need macOS 14.0 or later, Xcode 16 or later, and optionally xcodegen for regenerating the project from project.yml. The README's build command disables code signing, which is fine for a local run and not fine for distribution.

git clone https://github.com/andyhuo520/MacCheck.git
cd MacCheck
xcodegen generate
xcodebuild \
  -project MacCheck.xcodeproj \
  -scheme MacCheck \
  -configuration Release \
  -derivedDataPath build_release \
  CODE_SIGN_IDENTITY="-" \
  CODE_SIGNING_REQUIRED=NO

The product lands at build_release/Build/Products/Release/MacCheck.app. For a DMG, the repository ships scripts/build_and_notarize.sh, which regenerates the project if xcodegen is present, builds Release, checks for a Developer ID Application certificate, and then either signs with hardened runtime, notarizes and staples, or produces an ad-hoc DMG that runs locally. The default output is ~/Desktop/MacCheck-1.2.dmg. To distribute properly you set MACCHECK_SIGN_ID and MACCHECK_NOTARY_PROFILE and store notarization credentials with xcrun notarytool store-credentials, per Apple's process. The README's own verification steps are xcodebuild, hdiutil verify on the DMG, and codesign -dv --verbose=2 on the app.

Where MacCheck stops, and why that is deliberate

The README's notes section draws a boundary the app cannot cross: activation lock and warranty status depend on Apple's servers, so the user has to confirm them on Apple's website. MacCheck can flag that these are high-risk items for a second-hand deal, but it cannot settle them. The same applies to the tool's overall role. It is described as an aid to inspection, not a replacement for Apple warranty or after-sales diagnostics, which means a clean report is not a guarantee of a healthy machine. There are environmental limits too: permission-dependent checks, machine capability, and external devices all affect whether a test runs, and results can come back as unsupported or skipped. Anyone treating a skipped microphone test as a passed one is reading the report wrong. Finally, the README warns that screenshots and reports should be desensitized before sharing, because serial numbers, device names and personal information appear in them. The app runs locally and does not upload serial numbers, results or report contents, but an exported PNG is a file you hand to someone else, and that is where the leak happens.

How MacCheck differs from Apple's own tools and from repair-shop diagnostics

Apple's built-in route is System Information plus Battery settings plus Apple Diagnostics. That combination is authoritative for what Apple tracks and needs no install, but it does not produce a single shareable report, does not walk you through a per-key keyboard test or a checkerboard screen pattern, and does not save snapshots you can compare later. MacCheck's difference is the guided sequence plus the artifact: press every key, look at the screen patterns, speak into the microphone, and end with a PDF or PNG that records what was checked. The other common alternative is a repair shop's diagnostic bench, which can open the machine and test components MacCheck cannot reach, but it is not something a buyer runs in a cafe before paying. MacCheck also adds a feature neither of those has: an estimate of which local AI models fit in the machine's memory, based on the installed RAM. That is a niche addition, and it is the kind of thing a buyer of a used Apple Silicon Mac might actually care about, but it is advice rather than a measurement.

Maintenance, licence and what an adopter is taking on

The last push to the repository was on 2026-07-15, the same day v1.2 was released, following v1.1 and v1.0 earlier in July 2026. The repository is not archived. That is a short release history, and three versions inside two days suggests a burst of work rather than a long maintenance record; the README does not document a deprecation policy, a support window, or a rollback path for the DMG. The repository does not state a licence, which is the first thing to resolve before shipping MacCheck inside a shop's workflow or bundling it into another product. Without a licence file, the default position is that no rights are granted, so treat internal use as something to clarify with the author rather than assume. Upgrade cost is low in one sense: the app is a self-contained bundle and the source builds with Xcode 16, so a rebuild is a git pull plus the xcodebuild line above. It is higher in another: every distributed build needs a Developer ID certificate and a stored notarization profile, and macOS version requirements move with the Xcode toolchain, so the project's build instructions age alongside Apple's releases.

Editorial conclusion

MacCheck fits a buyer or a store that needs one pass over a used Mac before money changes hands: it reads hardware, battery, storage, network and security state, runs the keyboard, screen, audio, microphone, camera, Touch ID and trackpad tests, and exports a PDF or PNG report. It does not fit anyone who wants a signed, notarized build without configuring a Developer ID certificate, since the release script falls back to an ad-hoc DMG. Before relying on it, verify the licence (the repository does not state one), confirm that macOS 14.0 or later is available on the machine being checked, and remember that the README says activation lock and warranty status must be confirmed on Apple's site rather than in the app.

Frequently asked questions

Official sources

1. andyhuo520/MacCheck on GitHub
2. Issues
3. README
4. Releases