Rosetta Check MDM Guide

MDM Configuration Guide

Deploy and manage Rosetta Check across your Mac fleet using standard macOS configuration profiles. Available from v1.20.

Get a private fleet dashboard in 4 steps

Free · no sign-up · no email · no identifying data

Start here

See every Intel app across your Mac fleet on a single dashboard at a private URL — without giving us a name, an email or any identifying detail about your organisation. Ideal for driving an Apple Silicon migration or proving readiness ahead of macOS 28 dropping Rosetta.

  1. 1
    Generate a GUID

    Click Generate below. We mint a random fleet ID. Bookmark the dashboard URL it shows you.

  2. 2
    Download the profile

    One click gives you a ready-to-deploy .mobileconfig with your GUID baked in.

  3. 3
    Deploy via MDM

    Push the profile (and optional helper script) through Jamf, Intune, Mosyle, Iru (Kandji), Addigy, etc.

  4. 4
    Watch your dashboard

    As Macs scan, your private URL fills with the Intel apps still in use across your estate.

🔍

Finding Rosetta Check in Apple Business Manager

Searching by name in ABM can be unreliable. Search using the App Store ID id6759349750 instead — this will find it immediately.

Section 01

Build & deploy your profile

How the managed-preferences mechanism works, and the ready-to-deploy .mobileconfig + helper script you can push through your MDM today.

How It Works

Rosetta Check reads managed preferences from the com.neiljohn.rosettacheck preference domain using Apple's standard UserDefaults managed configuration mechanism. Deploy a .mobileconfig profile through your MDM solution to centrally control app behaviour.

When a key is set via a configuration profile, it overrides the user's local setting and the corresponding toggle in the app's Settings window is locked with a 🔒 icon. The app uses objectIsForced(forKey:) to detect managed keys — no special entitlements are required.

1. Create Profile

Download the example .mobileconfig and customise the keys you want to manage.

2. Deploy via MDM

Upload to Jamf, Intune, Mosyle, Iru (Kandji), Addigy, or any MDM that supports custom profiles.

3. Verify

Managed settings show a 🔒 lock icon in the app. Users cannot override them.

Example Configuration Profile

Download a complete, working .mobileconfig file with all available keys. Edit it to include only the keys you want to manage — keys omitted from the profile remain under user control.

RosettaCheck-MDM.mobileconfig
Apple Configuration Profile · XML
Download

Ready to deploy — payload UUIDs are pre-filled with fresh values on every download. Edit the PayloadIdentifier and PayloadOrganization values to match your organisation if you wish.

First-Launch Helper Script

When Rosetta Check is pushed to a Mac via MDM, macOS installs the app bundle but does not launch it. Until the user opens the app for the first time, none of the managed behaviours kick in — no background monitoring, no scan on launch, no auto-export, and crucially no login item registration. On a fleet where users may never click the app icon, this means the deployment effectively does nothing until they do.

The script below performs that first launch silently in the user's session. Once it has run, the app is registered as a login item via SMAppService (locked on by the configuration profile), the first scan completes, and from the next login onwards the app starts automatically — no user interaction required.

mdm-script.sh
Shell Script · zsh
Download

Deploy as a user-context shell script (Intune: Run script as signed-in user = Yes; Jamf: launch agent or User level policy; Iru (Kandji)/Mosyle: equivalent user-scoped script payload). Set the frequency to once after install.

Idempotent

Exits immediately if Rosetta Check is already running, so it's safe to re-run.

Race-tolerant

Waits for the Dock first (never fires during Setup Assistant), then up to 5 minutes for the App Store install to finish.

Silent

Launches via AppleScript launch (no activate) so it never steals focus, with open --background --hide as a fallback.

Verified

Confirms the app actually stayed running after launch and logs every step to the unified log (tag rosettacheck-launcher).

mdm-script.sh
#!/bin/zsh
APP="/Applications/RosettaCheck.app"
BIN="$APP/Contents/MacOS/RosettaCheck"

# Wait for the Dock so we never launch during Setup Assistant (cap 30 min).
elapsed=0
while ! /usr/bin/pgrep -x Dock > /dev/null; do
    (( elapsed >= 1800 )) && { echo "Timed out waiting for Dock" >&2; exit 1; }
    sleep 5; (( elapsed += 5 ))
done

# Already running? Nothing to do.
/usr/bin/pgrep -f "$BIN" > /dev/null && exit 0

# Wait up to 5 minutes for the App Store install to land.
elapsed=0
while [[ ! -d "$APP" ]]; do
    (( elapsed >= 300 )) && { echo "Timed out waiting for $APP" >&2; exit 1; }
    sleep 5; (( elapsed += 5 ))
done

# Launch WITHOUT stealing focus: AppleScript 'launch' (not 'activate'),
# falling back to open --background --hide.
/usr/bin/osascript -e 'tell application "RosettaCheck" to launch' \
    || /usr/bin/open --background --hide "$APP"

# Verify it actually stayed up — open/launch return 0 even if the app
# crashes on launch (the silent-failure mode from v1.0).
sleep 3
if /usr/bin/pgrep -f "$BIN" > /dev/null; then
    echo "RosettaCheck is running. Done."
    exit 0
else
    echo "RosettaCheck did not stay running — check the unified log." >&2
    exit 1
fi

Shown condensed. The downloadable v1.2 script adds unified logging (search the macOS unified log for the rosettacheck-launcher tag) and fuller diagnostics.

Section 02

Managed-preferences reference

Every key Rosetta Check reads from the com.neiljohn.rosettacheck preference domain — what it does, accepted values, and defaults.

Preference Domain

com.neiljohn.rosettacheck

Managed Keys Reference

Every key supported by Rosetta Check's managed configuration. All keys are optional — include only those you want to control centrally.

Key Type Default Description
backgroundMonitoringEnabled Bool true Run a live Spotlight query in the background to detect new app installations and removals in real time. Disable to prevent any background activity.
notificationsEnabled Bool true Send macOS system notifications for flagged app alerts, app removal alerts, and readiness milestones. Set to false to suppress all notifications.
communityEnabled Bool false Share anonymised Intel app metadata with the community. No personal or device-identifying information is transmitted. Set to false to prevent any data leaving the device.
scanOnLaunch Bool true Automatically scan all installed applications when Rosetta Check launches. Disable to trigger scans manually or via the menu bar only.
launchAtLogin Bool false Register as a login item so Rosetta Check starts automatically at user login. Recommended for enterprise deployments.
autoExportEnabled Bool false Automatically export scan results to a local file after each scan. Essential for fleet-wide compliance reporting — IT tools can collect the export from each machine.
autoExportFormat String "csv" Export format — "csv" or "json". CSV suits spreadsheet analysis; JSON is better for programmatic ingestion.
promptForLaunchAtLogin Bool true Show the first-launch "Launch at Login?" prompt. Set to false to suppress. Use launchAtLogin to control the setting itself.
promptForCommunitySharing Bool true Show community sharing prompts and AI-powered feature UI. Set to false to suppress the community confirmation sheet, first-scan upload prompt, "Get AI Recommendations" card, AI change notification banner, and "Share Results" button.
enterpriseGuid String v1.24+ Anonymous fleet identifier (UUID v4). When set, every community upload from this Mac is tagged with this GUID and the device's apps appear at /enterprise/<guid>. Generate one below. Requires Rosetta Check v1.24 or later — ignored by older clients.
Section 03

Get a private fleet dashboard

The recommended path: an anonymous fleet GUID gives you a private URL listing every Intel app reported across your estate — with no accounts, emails, or identifying data.

Get a Private Fleet Dashboard

Free · No sign-up

See every Intel app across your Mac fleet on a single dashboard — without giving us a name, an email, or a single piece of identifying information about your organisation. We generate a random ID, you push it to your Macs via MDM, and you get a private URL that lists which apps are still Intel-only and which Macs are reporting them.

Use it to drive an Apple Silicon migration, prove readiness ahead of macOS 28 dropping Rosetta, or just get visibility into the long tail of legacy software across your estate.

Requires Rosetta Check v1.24

v1.24 was submitted to the Mac App Store for review on 24 April 2026 and should be available shortly. The enterpriseGuid managed preference is read by v1.24 and later — earlier versions silently ignore the key, so you can safely deploy the profile now and uploads will start being tagged as soon as your fleet updates.

Privacy — what we do and don't see

We only ever receive

  • Intel-only apps — bundle ID, name, version. Nothing else from each Mac.
  • The fleet GUID you chose to deploy.
  • Issuance and last-activity timestamps for the GUID.

We never receive or store

  • Apple Silicon or Universal apps — they're filtered out client-side.
  • Hostnames, serial numbers, MAC addresses, usernames, or any device identifier.
  • Your name, email, organisation name, or any contact details.
  • Any link between an upload and your IP address — uploads are not stored alongside the IP they came from.

There is no account, no login, and no telemetry beyond the Intel-app inventory itself. Two Macs in the same fleet are completely indistinguishable to us — the dashboard groups apps, not devices. The only way back to your data is the URL we give you.

  • The URL is the secret. Anyone with the dashboard URL can see the data. Treat it like a password.
  • Not recoverable. If you lose the URL we cannot help you find it — there is nothing tying it to you.
Alternative: CSV export & MDM-side collection

For air-gapped fleets, regulated environments, or anyone who cannot use the hosted dashboard. Pulls a CSV from each Mac via your MDM's script runner.

Export File Location

The auto-export file is written to the app's sandboxed Application Support directory and overwrites on every scan, so the file always contains the latest results:

~/Library/Containers/com.neiljohn.rosettacheck/Data/Library/Application Support/RosettaCheck/exports/rosetta-check-latest.csv

Or rosetta-check-latest.json if the format is set to JSON. The predictable filename means collection scripts never need to search for the newest file.

CSV Export Fields

Column Description
NameApplication display name
Bundle Identifiere.g. com.example.app
VersionCFBundleShortVersionString
ArchitectureIntel, Universal, Apple Silicon, or Unknown
Needs RosettaYes or No
SizeHuman-readable disk size (e.g. 142 MB)
Last UsedDate the app was last opened
First DetectedDate Rosetta Check first saw the app
App StoreYes if installed from the Mac App Store
Min macOSLSMinimumSystemVersion from the app's Info.plist
Impact Score0–100 score combining recency, size, and distribution source
CategoryApp category from LSApplicationCategoryType
PathFull filesystem path to the .app bundle

Collection Script

Deploy this script via your MDM to retrieve Intel app data from managed Macs. It runs as root, determines the currently logged-in console user, and reads their Rosetta Check export file. The output is written to STDOUT so MDM platforms like Intune, Jamf, and Iru (Kandji) can capture it directly as a custom attribute or extension attribute.

rosetta-check-inventory.sh
Shell Script · Bash
Download

Deploy via Intune (Devices → macOS → Shell scripts), Jamf (Extension Attributes), or any MDM that supports custom scripts. Run as root.

rosetta-check-inventory.sh
#!/bin/bash
#
# Rosetta Check - Intel App Inventory Script
# Designed to run as root via MDM (Intune, Jamf, Iru, etc.)
# Outputs Intel app names and versions from the console user's export file.
#

# Determine the currently logged-in console user
console_user=$(/usr/bin/stat -f%Su /dev/console 2>/dev/null)

if [[ -z "$console_user" || "$console_user" == "root" || "$console_user" == "loginwindow" ]]; then
    echo "No console user logged in"
    exit 0
fi

# Resolve the console user's home directory
user_home=$(/usr/bin/dscl . -read "/Users/$console_user" NFSHomeDirectory 2>/dev/null | awk '{print $2}')

if [[ -z "$user_home" ]]; then
    echo "Unable to resolve home directory for $console_user"
    exit 0
fi

# Path to the Rosetta Check auto-export file
export_file="${user_home}/Library/Containers/com.neiljohn.rosettacheck/Data/Library/Application Support/RosettaCheck/exports/rosetta-check-latest.csv"

if [[ ! -f "$export_file" ]]; then
    echo "No Rosetta Check export found"
    exit 0
fi

# Extract Intel app names and versions
intel=$(grep ",Intel," "$export_file" | awk -F',' '{print $1" ("$3")"}')

if [[ -n "$intel" ]]; then
    echo "$intel"
else
    echo "No Intel apps found"
fi

Example output:

foobar2000 (2.6.6)
Uninstall Global Secure Access Client (1.1.25111702)
Section 04

Optional extras & verification

Suppress Apple's Rosetta warning pop-up on macOS 26.4+, confirm your profile is applied on a test Mac, and review supported MDM platforms.

Rosetta Usage Awareness (macOS 26.4+)

Starting with macOS 26.4, Apple shows a pop-up dialog each time an Intel app is launched, warning the user that Rosetta will be removed. This can be suppressed via an MDM Restrictions policy using the com.apple.applicationaccess payload. See Apple's device management schema for the full specification.

Deploy a Restrictions profile in your MDM with the following key:

MDM Restrictions — com.apple.applicationaccess
<key>allowRosettaUsageAwareness</key>
<false/>

Rosetta Check detects this setting and displays the current status in the Settings window under "Rosetta Transition". The downloadable example profile includes a commented-out section for this restriction.

Verifying Deployment

On a managed Mac, open Rosetta Check → Settings. Managed settings display a 🔒 lock icon and cannot be changed by the user. A "Management" banner appears when any keys are being managed.

You can also verify from Terminal:

bash
# Check if any keys are managed
defaults read com.neiljohn.rosettacheck

# Check a specific key
defaults read com.neiljohn.rosettacheck autoExportEnabled

Requirements

  • macOS 13 (Ventura) or later
  • Apple Silicon Mac
  • Rosetta Check v1.20+ installed from the Mac App Store
  • MDM solution capable of deploying custom configuration profiles

Questions? Contact [email protected]