Rosetta 2: Prepare Intel Apps for Changes After macOS 27

macOSTahoe ·
Rosetta 2: Prepare Intel Apps for Changes After macOS 27

Rosetta supports Intel apps through macOS 27. Check app architecture, update components, and plan for the limited game-only support starting in macOS 28.

Documentation review: October 15, 2026. The corrections below use Apple’s Rosetta guidance, published September 21, 2026. This is a targeted documentation review, not hands-on testing or a complete factual review of every legacy example in this article.

Rosetta remains available for general Intel-app translation on Apple silicon with macOS 27 or earlier. Starting with macOS 28, Apple limits Rosetta to certain older, unmaintained games that depend on Intel-based frameworks. This is neither the removal of all Rosetta functionality nor a guarantee that every old game will work.

Apple says an Intel app or one of its components may display a notification about incompatibility with macOS 28. Its current documentation does not establish that every app warns on every launch, or provide the exact future error-dialog wording.

Intel application compatibility and the macOS 28 Rosetta changes

Prioritize essential Intel-only apps, export data while they still run, and ask the developer for a Universal or Apple silicon version. Plan around the macOS version boundary rather than an unconfirmed release date or a countdown measured from the original publication date.

What Is Rosetta 2 and Why Does It Matter?

The Technical Foundation

Rosetta 2 is Apple's dynamic binary translator — a sophisticated piece of system software that intercepts Intel x86_64 machine code instructions and translates them in real-time into ARM64 instructions that Apple Silicon chips can execute natively. Apple introduced it in November 2020 alongside the first Apple Silicon Macs, giving developers time to port their applications while users could still run their existing software.

The name "Rosetta 2" is a reference to the original Rosetta, which Apple used during its 2005-2006 transition from PowerPC to Intel processors. Apple removed the original Rosetta with OS X Lion in 2011, approximately five years after the Intel transition began. If the pattern holds, Rosetta 2 — introduced in 2020 — is on a similar trajectory.

Apple Silicon chip architecture — the foundation of every Mac since 2020, replacing Intel's x86_64 processors

How Rosetta 2 Actually Works

Unlike a traditional emulator, Rosetta 2 uses a two-stage translation approach:

Stage 1 — Ahead-of-Time (AOT) Translation: When you first launch an Intel app on Apple Silicon, Rosetta 2 translates the entire binary and caches the ARM64 version on disk. This translation happens once, and subsequent launches use the cached version.

Stage 2 — Just-in-Time (JIT) Translation: For code that cannot be pre-translated — such as dynamically generated code in JavaScript engines or certain plugin architectures — Rosetta 2 translates instructions on-the-fly during execution.

The Performance Reality

Performance depends on the app, workload and Mac. This article has no reproducible benchmark supporting a fixed translation penalty or percentage of native performance; those numerical claims have been removed. Current speed does not establish future compatibility.

The Complete Rosetta 2 Deprecation Timeline

Understanding the timeline is essential for planning. Here is what we know with high confidence and what remains speculative.

Official Timeline: What We Know

MilestoneStatusImpact
macOS 27Apple siliconRosetta remains available for general Intel-app translation on Apple silicon with macOS 27 or earlier.
macOS 28Apple siliconStarting with macOS 28, Apple limits Rosetta to certain older, unmaintained games that depend on Intel-based frameworks.

Historical Precedent: The 32-Bit App Removal

Apple's deprecation of 32-bit app support provides the best precedent for understanding how Rosetta 2 removal will unfold:

  • 2017 (macOS High Sierra): Apple started warning that 32-bit apps would not be supported "without updates from their developers"
  • 2018 (macOS Mojave): Warnings became more prominent; "last macOS to run 32-bit apps"
  • 2019 (macOS Catalina): 32-bit apps stopped working entirely, with zero exceptions

How to Check Intel Apps: Coverage and Limits

Treat this as a partial inventory and cross-check it with Finder and vendor documentation. A list of installed apps does not show which are currently running, and neither this list nor a command scanning one folder proves that all plug-ins, command-line tools or custom installation paths are covered.

Using Terminal and developer tools to audit app architectures on your Mac — identifying Intel-only apps before Rosetta 2 is removed

System Settings and Finder: A Bounded App Inventory

Step-by-Step:

On macOS 27 or later, open System Settings → General → About → macOS → Intel-based Apps → Details. Apple says this list covers recently used apps and apps in common locations; it is not a complete disk or plug-in inventory. On earlier versions, use Finder to inspect individual apps.

In Finder, select the app and press Command-I. Read Kind: Application (Intel) needs Rosetta on Apple silicon; Application (Universal) contains Intel and Apple silicon support; Application (Apple silicon) is native. A generic Application label alone does not establish architecture. Check plug-ins, extensions and updaters separately.

Method 2: Activity Monitor (Running Apps Only)

Activity Monitor shows you the architecture of applications currently running, which is useful for identifying Rosetta-dependent processes that may not appear as top-level applications — including helper processes, menu bar utilities, and background agents.

Step-by-Step:

  1. Open Activity Monitor from Applications > Utilities, or search for it in Spotlight (Command-Space, then type "Activity Monitor")
  2. Go to View menu in the menu bar
  3. Select Columns, then enable the Kind column
  4. The Kind column now shows "Intel" or "Apple" next to each process
  5. Sort by Kind to group all Intel processes together

What to Look For: Pay special attention to processes that are not obviously apps — names like "helper," "agent," "daemon," or process names without obvious app associations. These are often background components of apps whose main window appears native, but whose backend processes still use Intel code.

Method 3: Get Info on Individual Apps

For a quick check on a single app without opening System Information:

Step-by-Step:

  1. Open Finder
  2. Navigate to your Applications folder
  3. Right-click (or Control-click) on any app
  4. Select Get Info from the context menu
  5. Look for the Kind field in the info panel

In Finder, select the app and press Command-I. Read Kind: Application (Intel) needs Rosetta on Apple silicon; Application (Universal) contains Intel and Apple silicon support; Application (Apple silicon) is native. A generic Application label alone does not establish architecture. Check plug-ins, extensions and updaters separately.

Important Note: If you see a checkbox labeled "Open using Rosetta" in the Get Info panel, that means the app is a Universal Binary but you (or some installer) previously chose to force it to run in Intel mode. Unchecking this box makes it run natively.

Method 4: Terminal Commands (Most Detailed)

Basic Check for a Single App:

file "/path/to/App.app/Contents/MacOS/Executable"

These are read-only command examples. Replace the quoted placeholder with the actual Mach-O executable path, not the app or framework directory. Neither command is a complete dependency audit, and no example was executed during this review.

lipo -archs "/System/Applications/Mail.app/Contents/MacOS/Mail"

Understanding the Output:

The following output is illustrative, not a transcript from a tested Mac. Architecture labels describe the executable; arm64e does not mean that a file has a newer or valid code signature.

# Illustrative output, not measured on a test Mac.
# Native arm64 executable:
/path/to/executable: Mach-O 64-bit executable arm64

# arm64e is an architecture label, not a code-signing verdict:
/path/to/executable: Mach-O 64-bit executable arm64e

# Intel executable:
/path/to/executable: Mach-O 64-bit executable x86_64

# Universal executable; dependencies still need separate checks:
/path/to/executable: Mach-O universal binary with 2 architectures: [x86_64] [arm64]

How to Check Intel Apps: Coverage and Limits

Treat this as a partial inventory and cross-check it with Finder and vendor documentation. A list of installed apps does not show which are currently running, and neither this list nor a command scanning one folder proves that all plug-ins, command-line tools or custom installation paths are covered.

The former batch scans have been withdrawn: they assumed that bundle and executable names match or selected the first file found, which can misclassify apps and plug-ins. Apple identifies the executable using CFBundleExecutable. Locate the actual executable and inspect it with the read-only commands below; this does not inventory every dependency.

Check with lipo for Even More Detail:

lipo -info "/path/to/App.app/Contents/MacOS/Executable"

This is the low-level tool that produces output like:

Architectures in the fat file: /path/to/executable are: x86_64 arm64

or for Intel-only apps:

Non-fat file: /path/to/executable is architecture: x86_64

Which Apps Are Safe and Which Need Action

Major Apps That Have Gone Native (You Are Safe)

The vast majority of mainstream consumer software made the transition to Apple Silicon native years ago. If you are only running popular, actively maintained apps, you are likely in good shape.

App / SuiteNative SinceArchitectureStatus
Adobe PhotoshopJanuary 2022UniversalSafe
Adobe Premiere ProApril 2022UniversalSafe
Adobe IllustratorMarch 2022UniversalSafe
Adobe LightroomNovember 2020UniversalSafe
Microsoft WordNovember 2020UniversalSafe
Microsoft ExcelNovember 2020UniversalSafe
Microsoft PowerPointNovember 2020UniversalSafe
Microsoft OutlookNovember 2020UniversalSafe
Google ChromeMarch 2021UniversalSafe
Mozilla FirefoxNovember 2020UniversalSafe
SlackMarch 2021UniversalSafe
ZoomApril 2021UniversalSafe
Microsoft TeamsMarch 2022UniversalSafe
VS CodeMarch 2021UniversalSafe
JetBrains IDEs2021UniversalSafe
Figma2021UniversalSafe
Dropbox2021UniversalSafe
1PasswordNovember 2020UniversalSafe
Spotify2021UniversalSafe
VLC Media Player2021UniversalSafe
Final Cut ProNovember 2020Native ARMSafe
Logic ProNovember 2020Native ARMSafe
XcodeNovember 2020Native ARMSafe

Categories That May Still Require Rosetta 2

Not all software moves at the same pace. The categories most likely to still have Intel-only components in 2026 are:

Audio Production Plugins (Highest Risk)

This is the single highest-risk category. Audio Unit (AU) and VST plugins are often small, specialized tools maintained by small development teams or solo developers. Many of these plugins have not been updated in years, and some developers have abandoned active maintenance.

The former batch scans have been withdrawn: they assumed that bundle and executable names match or selected the first file found, which can misclassify apps and plug-ins. Apple identifies the executable using CFBundleExecutable. Locate the actual executable and inspect it with the read-only commands below; this does not inventory every dependency.

Scientific and Research Software

Many scientific computing applications, academic software tools, and research instruments have Intel-only versions that are rarely updated due to small user bases, academic funding cycles, or institutional purchasing constraints. Examples include:

  • Specialized data analysis tools (some MATLAB toolboxes, R packages with compiled extensions)
  • Geographic Information System (GIS) tools
  • Laboratory instrument control software
  • Legacy data processing pipelines with compiled components

Industrial and Enterprise Applications

Enterprise software moves slowly. Line-of-business applications, ERP connectors, VPN clients for older corporate infrastructure, and specialized hardware interface software frequently remain on Intel architectures long past when consumer software has transitioned.

Older Games and Gaming Platform Clients

Rosetta remains available for general Intel-app translation on Apple silicon with macOS 27 or earlier. Starting with macOS 28, Apple limits Rosetta to certain older, unmaintained games that depend on Intel-based frameworks. This is neither the removal of all Rosetta functionality nor a guarantee that every old game will work.

Legacy Creative Tools

Older versions of professional creative software — versions that predated Apple Silicon, purchased as perpetual licenses rather than subscriptions — may still be Intel-only. If you are running an old version of Final Cut Pro 7, or a legacy version of any audio/video tool, verify its architecture.

Intel application compatibility and the macOS 28 Rosetta changes

What Actually Happens When Rosetta 2 Is Removed

The macOS 27 Scenario (Fall 2026)

When macOS 27 ships in fall 2026, two things happen simultaneously:

  1. Intel Mac owners cannot upgrade (their hardware is no longer supported)
  2. Apple Silicon Mac owners can upgrade, and Rosetta 2 remains in macOS 27

The macOS 28 Scenario (Fall 2027): When Apps Stop Working

Rosetta remains available for general Intel-app translation on Apple silicon with macOS 27 or earlier. Starting with macOS 28, Apple limits Rosetta to certain older, unmaintained games that depend on Intel-based frameworks. This is neither the removal of all Rosetta functionality nor a guarantee that every old game will work.

Architecture alone does not guarantee compatibility:

  • Universal Binary apps — the native main executable does not need Rosetta; verify dependencies and the vendor’s OS requirements.
  • Native Apple silicon apps — the main executable does not need Rosetta; separately check components and OS compatibility.
  • Web apps and Progressive Web Apps (PWAs) — unaffected
  • Apps running inside virtual machines — depends on the virtualization solution

Transition Options When the Deadline Arrives

If you find yourself with Intel-only apps that have no native Apple Silicon alternative by fall 2027, your options are:

Option 1: Stay on macOS 27

Keeping a compatible Mac on an older macOS may preserve a legacy workflow, but does not guarantee continued security updates, licensing, peripheral support or indefinite operation. Intel Macs run Intel apps directly; Rosetta concerns Apple silicon. Do not install an OS unsupported by that Mac.

Option 2: Virtual Machines

A virtual machine is a possible fallback to evaluate, not a verified guarantee. Confirm the exact host macOS, guest macOS, Rosetta availability, application licence and device requirements with the virtualization vendor, then test the workflow before upgrading. This review did not test a macOS 28 host or any VM configuration.

Option 3: Keep a Legacy Mac

Some organizations and professionals keep an older Intel Mac (or an early Apple Silicon Mac running an older macOS) specifically for running legacy software. This is viable for occasional access to legacy tools but requires maintaining aging hardware.

Option 4: Find Native Alternatives

In most cases, the best long-term strategy is finding a native Apple Silicon alternative to any Intel-only app you depend on. Five years into the Apple Silicon era, the native app ecosystem is rich, and for most software categories there are compelling alternatives.

Apple Silicon: Understanding the Architecture

MacBook with Apple Silicon — native ARM64 apps run with full performance, no Rosetta 2 translation needed

What "Universal Binary" Means and Why It Matters

Apple introduced Universal Binary 2 with Apple Silicon to allow developers to ship a single app package that runs natively on both Intel and Apple Silicon Macs. When you look at the "Kind" column in System Information and see "Universal", you are seeing this technology at work.

A Universal Binary contains two complete copies of the compiled application code:

  • One compiled for Intel x86_64
  • One compiled for Apple Silicon ARM64

macOS automatically selects the appropriate version for the hardware it is running on. Universal Binaries are the ideal solution for developers who need to support both platforms — but they result in larger app bundle sizes (roughly double the binary size, though assets are shared).

Universal and Apple silicon builds avoid relying on Intel translation for their native executable. That does not guarantee indefinite compatibility: separately installed plug-ins, extensions, updaters and the vendor’s OS requirements still need checking.

Architecture Type Reference

ArchitecturemacOS TermTerminal OutputMain executable needs Rosetta?Compatibility with macOS 28
ARM64Applearm64 or arm64eNoDepends on dependencies and OS requirements
x86_64Intelx86_64RosettaRosetta remains available for general Intel-app translation on Apple silicon with macOS 27 or earlier. Starting with macOS 28, Apple limits Rosetta to certain older, unmaintained games that depend on Intel-based frameworks. This is neither the removal of all Rosetta functionality nor a guarantee that every old game will work.
ARM64 + x86_64Universaluniversal binaryNoDepends on dependencies and OS requirements
ARM64eApple siliconarm64eNoDepends on dependencies and OS requirements

Action Plan: What You Should Do Right Now

Immediate Steps (This Week)

Step 1: Run the Architecture Audit

Treat this as a partial inventory and cross-check it with Finder and vendor documentation. A list of installed apps does not show which are currently running, and neither this list nor a command scanning one folder proves that all plug-ins, command-line tools or custom installation paths are covered.

Step 2: Categorize Your Intel Apps

For each Intel app you find, categorize it into one of three buckets:

  • Critical: You use it daily or weekly, and your work depends on it
  • Important: You use it monthly, and alternatives would require significant workflow changes
  • Legacy: You rarely use it, or could easily find an alternative

Step 3: Research Each Critical and Important App

For each app in the Critical and Important categories, determine:

  1. Does a native Apple Silicon version already exist? (Download it immediately if so)
  2. Has the developer announced an Apple Silicon version in development?
  3. Is the developer still active, or has the product been abandoned?
  4. Are there mature native alternatives?

Step 4: Contact Developers

For apps you depend on that have no native version and no announced plans, contact the developer directly. Customer pressure works. A surge of support tickets about Apple Silicon compatibility — especially citing the macOS 26.4 warning dialogs — sends a clear market signal.

Medium-Term Steps (Next 6 Months)

Build Your Migration Roadmap

Create a simple spreadsheet or list:

App NameCurrent StatusNative Version?ReplacementPriorityTarget Date
[App]Intel onlyIn developmentN/ACriticalBefore upgrading macOS
[App]Intel onlyNo[Alternative]ImportantBefore upgrading macOS

Test Alternatives Early

Do not wait until macOS 28 ships to try alternative apps. Testing and transitioning workflows takes time, especially for professional tools. If you identify an app today that will need replacing, start testing alternatives now when there is no urgency.

Evaluate Your Plugin Situation

If you use digital audio workstations, photo editing plugins, or any other plugin-based creative software, audit your plugins separately. Plugins often have independent update cycles from their host apps.

Developer Notes: Verify the App and Its Dependencies

Apple’s universal binary guide specifies Xcode 12.2 or later and recommends Standard Architectures. Check every compiled component, including plug-ins, frameworks and helper tools, rather than only the main app. This documentation review did not build or test a project.

Developer building Universal Binary — Xcode makes it straightforward to compile apps for both Intel x86_64 and Apple Silicon ARM64

Inspect a Built Executable

These are read-only command examples. Replace the quoted placeholder with the actual Mach-O executable path, not the app or framework directory. Neither command is a complete dependency audit, and no example was executed during this review.

# Read-only inspection; replace this placeholder with an actual executable.
file "/path/to/executable"
lipo -archs "/path/to/executable"

Conditional Compilation Is Not Runtime Detection

The Swift example selects code at compile time for a binary slice. It does not identify the physical Mac or determine whether a running process is translated by Rosetta. For that separate question, follow Apple’s guidance linked from its universal binary documentation.

// Compile-time architecture selection for the binary slice.
// This does not detect the physical Mac or Rosetta translation at runtime.
#if arch(arm64)
  print("Compiled for arm64")
#elseif arch(x86_64)
  print("Compiled for x86_64")
#endif

Project-Specific Builds and Distribution

The previous generic build, SIMD conversion, dependency-installation, signing and notarization recipes have been removed because their project settings, paths, semantics and credentials were not validated. Follow Apple’s build guidance for the actual project and its signing and notarization requirements for distribution. Test the resulting slices and dependencies before shipping; this article provides no tested build or signing recipe.

Frequently Asked Questions

Q: I am on an Intel Mac. Does any of this affect me?

Keeping a compatible Mac on an older macOS may preserve a legacy workflow, but does not guarantee continued security updates, licensing, peripheral support or indefinite operation. Intel Macs run Intel apps directly; Rosetta concerns Apple silicon. Do not install an OS unsupported by that Mac.

Q: My Intel app runs faster than some native apps I have tried. Why upgrade?

Performance depends on the app, workload and Mac. This article has no reproducible benchmark supporting a fixed translation penalty or percentage of native performance; those numerical claims have been removed. Current speed does not establish future compatibility.

Q: Can I turn off the warning dialogs in macOS 26.4?

Apple says an Intel app or one of its components may display a notification about incompatibility with macOS 28. Its current documentation does not establish that every app warns on every launch, or provide the exact future error-dialog wording.

Q: What if a developer says they will never release an Apple Silicon native version?

Prioritize essential Intel-only apps, export data while they still run, and ask the developer for a Universal or Apple silicon version. Plan around the macOS version boundary rather than an unconfirmed release date or a countdown measured from the original publication date.

Q: Are plugins (audio plugins, Photoshop plugins, etc.) separate from the host app?

Universal and Apple silicon builds avoid relying on Intel translation for their native executable. That does not guarantee indefinite compatibility: separately installed plug-ins, extensions, updaters and the vendor’s OS requirements still need checking.

Q: What about apps I only use occasionally? Should I rush to replace them?

Prioritize essential Intel-only apps, export data while they still run, and ask the developer for a Universal or Apple silicon version. Plan around the macOS version boundary rather than an unconfirmed release date or a countdown measured from the original publication date.

Q: How do I check whether an installed app is native?

In Finder, select the app and press Command-I. Read Kind: Application (Intel) needs Rosetta on Apple silicon; Application (Universal) contains Intel and Apple silicon support; Application (Apple silicon) is native. A generic Application label alone does not establish architecture. Check plug-ins, extensions and updaters separately.

Q: Is Rosetta 2 really being removed, or is this just speculation?

Rosetta remains available for general Intel-app translation on Apple silicon with macOS 27 or earlier. Starting with macOS 28, Apple limits Rosetta to certain older, unmaintained games that depend on Intel-based frameworks. This is neither the removal of all Rosetta functionality nor a guarantee that every old game will work.

Q: What is Universal Binary 2 and how is it different from the original Universal Binary?

A: The original Universal Binary (from the 2005-2006 PowerPC to Intel transition) combined PowerPC and Intel code in a single package. Universal Binary 2 (introduced in 2020) combines Intel x86_64 and Apple Silicon ARM64 code in a single package. The underlying technology (a "fat binary" using Apple's Mach-O format) is similar, but the architectures are different. Universal Binary 2 is what developers need to ship today to support both Intel and Apple Silicon Mac users.

Planning Your Personal Transition Timeline

Here is a practical checklist to work through over the coming months:

Prioritize essential Intel-only apps, export data while they still run, and ask the developer for a Universal or Apple silicon version. Plan around the macOS version boundary rather than an unconfirmed release date or a countdown measured from the original publication date.

The Bigger Picture: Apple Silicon Five Years In

The macOS 26.4 Beta warning dialogs mark a meaningful moment in Apple Silicon's history. Five years after the M1 launch in November 2020, Apple is signaling the formal end of the compatibility bridge that made the transition feel seamless for most users.

The transition has been remarkably smooth by historical standards. The original PowerPC-to-Intel transition disrupted workflows significantly for many professional users. The Apple Silicon transition, thanks to Rosetta 2's performance and the rapid pace of native app development, was largely invisible to most Mac users. Developers ported their apps quickly, Apple Silicon's performance advantages were significant, and within two years of the M1 launch, most mainstream software was running natively.

Apple Silicon — five years into the transition, the Mac platform is faster, more efficient, and more capable than ever

Prioritize essential Intel-only apps, export data while they still run, and ask the developer for a Universal or Apple silicon version. Plan around the macOS version boundary rather than an unconfirmed release date or a countdown measured from the original publication date.

For more information on macOS Tahoe and the transition to Apple Silicon-only computing: