You bought an M-series MacBook three years ago. Almost everything you use is now ARM-native. But every time you check Activity Monitor, there are still half a dozen processes labeled Intel, several of them are CLI tools you didn’t know weren’t native, and Rosetta 2 is silently translating x86_64 instructions for them in the background. Battery life is fine, performance feels fine, but you’re not 100% sure you actually need Rosetta installed anymore.
It’s 2026. The macOS / Apple Silicon transition started in 2020. Almost every major application has shipped an ARM build. So when can you finally remove Rosetta — and how do you know which of your tools would break if you did?
What Rosetta 2 actually does
Rosetta 2 is a binary translator: it converts x86_64 machine code to ARM64 instructions on the fly (mostly at install time, with a fast JIT for runtime cases). Apple ships it as an optional component you install once, and after that any x86_64 binary you launch transparently runs through it. The translation is good — you typically lose 15–30% of native ARM performance, which on an M2/M3 chip means most x86 apps still feel snappier than they did on the Intel Macs they replaced.
The catch in 2026: Apple has announced Rosetta will be deprecated in a future macOS, with the explicit message that developers should ship ARM-native builds. Knowing what’s running through Rosetta on your machine is now a maintenance question, not a curiosity.
Detect: which CLI tools are silently x86_64?
Activity Monitor’s “Architecture” column shows GUI apps clearly. CLI tools are harder because they don’t always appear there. The tool you want is file:
file $(which docker)
# Mach-O 64-bit executable arm64 ← native
# Mach-O 64-bit executable x86_64 ← Intel (Rosetta)
# Mach-O universal binary with 2 architectures: [arm64] [x86_64] ← fat binary, picks per-launchTo audit your whole $PATH at once:
# Show the architecture of every executable in the directories on your PATH
echo "$PATH" | tr ':' '\n' | while read -r d; do
[ -d "$d" ] || continue
find "$d" -maxdepth 1 -type f -perm +111 2>/dev/null
done | xargs file 2>/dev/null | grep -v 'arm64' | grep 'Mach-O'That command dumps every binary that is not ARM-only. The output is usually surprising: ten or twenty Homebrew tools you installed under Rosetta in 2021 and never re-installed; a bundled aws CLI that’s still x86_64; a kubectl from a manual install; a gpg from an outdated installer.
Detect: which running processes use Rosetta right now
# All currently-running x86_64 processes
ps -axo pid,comm,args | while read -r pid comm args; do
[ -z "$pid" ] && continue
arch=$(/usr/sbin/sysctl -n sysctl.proc_translated -p $pid 2>/dev/null)
[ "$arch" = "1" ] && echo "$pid $comm $args"
donesysctl.proc_translated is Apple’s way of telling you whether a given PID was launched as x86_64-via-Rosetta. The flag is 1 when yes, 0 when native. The script above prints every translated process with its command line, which is the surest way to find the half-dozen “I forgot this was Intel” tools you have running.
Fix: re-install Homebrew formulas as ARM
If brew config shows HOMEBREW_PREFIX: /usr/local, you have an x86_64 Homebrew installation in addition to (or instead of) the ARM one at /opt/homebrew. Most people want only the ARM one in 2026.
# See what's installed in the x86 brew
arch -x86_64 /usr/local/bin/brew list
# Install ARM brew if you don't have it
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
# (the installer detects ARM and sets up /opt/homebrew on its own)
# Install your formulas in the ARM brew
/opt/homebrew/bin/brew install <list of packages from arch -x86_64 brew list>
# Once everything works under ARM brew, remove the Intel one
/usr/local/bin/brew remove --force $(arch -x86_64 /usr/local/bin/brew list)
sudo rm -rf /usr/local/Homebrew /usr/local/Cellar /usr/local/CaskroomMake sure your shell config has /opt/homebrew/bin ahead of /usr/local/bin in $PATH before you start, otherwise you’ll keep accidentally invoking the Intel binary even after the ARM one is installed.
When you still genuinely need Rosetta
- One specific niche app that has no ARM build. The list is shrinking fast in 2026, but if your work depends on a vendor tool stuck on x86_64, keep Rosetta until that tool ships native. Tools like older Adobe plugins, some CAD packages, and certain audio plugins are still slow movers.
- Docker images you didn’t build for ARM. If you’re running x86_64 Docker images that don’t have
linux/arm64manifests, you need Rosetta + Docker’s emulation. The cleanest fix is rebuilding those images (docker buildx build --platform linux/arm64,linux/amd64) but it’s not always your repo to rebuild. - Some games via Steam. Steam itself is now native ARM but most older games are not, and Apple’s Game Porting Toolkit relies on Rosetta + Wine + DXVK to run Windows x86 binaries on Mac.
How to disable Rosetta
If your audit shows zero remaining x86_64 dependencies, you can fully remove Rosetta:
# Removes Rosetta — requires a reboot afterwards
sudo /usr/sbin/softwareupdate --remove-rosetta
# Verify it's gone
arch -x86_64 echo "this should error" 2>&1
# Expected: arch: posix_spawn execvp: : Bad CPU type in executable If you want to keep Rosetta installed but stop a specific app from running through it, right-click the app in Finder → Get Info → uncheck “Open using Rosetta.” For CLI tools, prefix invocations with arch -arm64 to force the native code path on a fat binary.
The pragmatic 2026 stance
Audit your $PATH with the file trick once. Replace anything that’s still Intel with ARM-native versions. Keep Rosetta installed if any single tool you depend on hasn’t shipped native — Apple’s deprecation timeline gives you years, not weeks. But run the audit. The handful of x86_64 binaries lingering in your $PATH are quietly burning a few percent of CPU on every invocation, and they’re easy to fix once you can see them.
Photo: MacBook Pro side profile with port layout by dlxmedia hu on Pexels.