Parallels Desktop 20.2: Game-Changer for Apple Silicon Users with x86 Emulation

For Mac aficionados who also need to dip their digital toes into Windows or Linux, Parallels Desktop has long been the go-to choice for virtual machines (VMs). The latest major update, version 20.2, brings features users have been clamoring for, particularly in the Apple Silicon universe. This new update lets Apple Silicon hardware (think M-series chips) run x86-based virtual machines, including Windows 11 and various Linux distributions.
Here's everything you need to know about this groundbreaking update and what it means for you.

---

The Big Deal: x86 Virtualization on Apple Silicon​

For the uninitiated, Apple’s transition from Intel-based processors to its ARM-based M-series chips (Apple Silicon) has drastically improved the performance and efficiency of Mac computers. However, this has created complications for users who need to run software built for x86-based systems (Intel/AMD architectures). Historically, this limitation has made it challenging to run certain applications and operating systems natively.
Parallels Desktop 20.2 bridges this gap with its early technology preview of 64-bit x86 emulation. This is a monumental development in the virtualization world because it allows ARM-based devices to emulate Intel architecture within a VM, enabling key use cases like:

• Running full-fledged Windows 10 and Windows 11 environments.
• Testing and developing 32-bit Windows apps in a controlled, native-like environment.
• Hosting Linux virtual machines (VMs) without relying on workarounds like macOS’s built-in Rosetta 2.

What is x86 emulation?
To fully appreciate what Parallels has achieved, you need to understand emulation. x86 refers to the instruction set most commonly used by Intel and AMD processors. Emulating x86 on Apple Silicon means creating a software layer that mimics this instruction set. This allows ARM-powered Macs to run operating systems and apps previously reserved for Intel-based systems. Emulation typically incurs a performance penalty, but Parallels has optimized this using a proprietary engine to maximize compatibility and speed.

---

Limitations of the Tech Preview​

Great as it sounds, the x86 emulation in Parallels 20.2 is still a tech preview, meaning some features are rough around the edges:

• Performance Variability: Depending on the host hardware (whether you're rocking an M1, M2, or the latest M3 chip), performance could be slower compared to native applications.
• 64-Bit Support Only: Oddly, while the emulation is primarily 64-bit, you can still run 32-bit Windows apps. This could confuse some users expecting full 32-bit VM compatibility.
• No USB Device Support: Plug in a USB device intending to use it in your VM? Not happening right now. This could be a limitation for developers or power users with specialized needs.
• Parallels Hypervisor Incompatibility: You’ll need to rely on Apple's native virtualization stack, as Parallels Hypervisor is off the table for these emulated VMs.

Regardless of these drawbacks, early adopters and testers can get excited about the potential here. Apple Silicon users no longer have to sacrifice compatibility or carry a secondary Intel machine for native x86 workflows.

---

SSO and IT-Friendly Enhancements​

Shifting focus to enterprise users, Parallels Desktop 20.2 includes features designed with IT teams and corporate deployments in mind:

• Single Sign-On (SSO): Companies utilizing Microsoft Entra ID or Okta for identity management will find this integration handy. Employees can activate Parallels by logging in with their work credentials, simplifying onboarding.
• Parallels Management Portal Enhancements: IT admins can push tailored configurations to Macs, ensuring consistency across managed devices.
• Streamlined Licensing: Forget juggling custom license keys; corporate users can now manage licenses through their organization’s identity provider.

If you’re an IT admin dealing with cross-platform realities, these features make Parallels an easier sell for deploying mixed environments.

---

Apple Intelligence Meets Windows Apps​

One of Parallels’ standout features since version 20.1 has been making Apple Intelligence Writing Tools like grammar and spellcheck accessible within Windows environments. With 20.2, this has been further refined. Now, you can use these tools more seamlessly in Microsoft apps, such as PowerPoint, Word, and Outlook, thanks to a context menu integration, ensuring increased accessibility and ease of use.

---

Why This is a Game Changer​

Let’s face it: Apple Silicon is the future for Mac users. Until now, the lack of robust x86 application support had been holding some users back. With Parallels Desktop 20.2, Apple Silicon devices (like the MacBook Air, Mac Mini, and Mac Studio) can begin to fulfill the classic “one-machine-for-everything” promise. Here’s why this matters:

• Enterprise Compatibility: Many IT environments rely on Windows-exclusive apps. The ability to emulate x86 Windows on Apple Silicon bridges that gap, meaning businesses can more readily adopt Mac hardware without sacrificing software access.
• Developer-Ready: Need to test an application on multiple platforms? Parallels empowers developers by turning a single device into a multi-platform powerhouse.
• Linux Options Expand: Linux enthusiasts can experiment beyond Rosetta for a closer-to-native experience in emulated VMs.

Think of this as a “have your cake and eat it too” situation for professionals managing disparate workloads.

---

What Lies Ahead?​

While the inclusion of x86 emulation today is impressive, there’s plenty of room for improvement. Performance optimizations, expanded compatibility with 32-bit systems, and peripheral support (like USB devices) would make this a dream tool. The success of Parallels 20.2 could also push Microsoft and Linux distributions to lean even further into ARM compatibility, possibly reducing the need for emulation entirely.
For now, though, Parallels Desktop 20.2 is a must-try update for Apple Silicon users eyeing x86 virtualization. Whether you’re a pro developer, IT admin, or experimental tinkerer, the doors just opened to a world of possibilities—and Windows 11 is holding the keys.
What do you think about this major update? Share your thoughts below, and let’s geek out about the future of cross-platform computing!

---

Source: AppleInsider Parallels 20.2 trials x86 VMs on Apple Silicon, bringing Linux & Windows 11 support

 

[ChatGPT]

The sandboxed realms of Windows and Linux operating systems have long thrived on robust virtualization solutions. Among these is Parallels Desktop, a stalwart in the virtualization market for Mac users. Now, enthusiasts and developers alike, rejoice! Parallels Desktop has taken a monumental step, enabling 64-bit x86 Windows and Linux operating systems to operate on Apple Silicon Macs. This marks a massive leap in emulating the PC experience on ARM-based hardware, but—as with all great innovations—it comes wrapped in some compromises.
If you own an Apple Silicon Mac (M1, M2, M3, or the newer M4), here's the big scoop you’ve been waiting for. Parallels Desktop 20.2 introduces early support for x86 emulation, opening the door for traditional PC operating systems to thrive on ARM-based Macs. Still, as you uncork the champagne, remember to temper your expectations because there are trade-offs that may deter heavy-duty users. Let’s dive into the nitty-gritty of this feature, its technological underpinnings, limitations, and what it means for you.

---

Why x86 Support Is a Big Deal for Apple Silicon Macs​

Initially, Mac users had no trouble running x86 operating systems because older Macs used Intel’s x86 architecture. This meant Windows and Linux virtualization with minimal performance hurdles. However, Apple’s transition to ARM-based Apple Silicon, starting with the M1 chip, posed a significant problem. ARM processors run fundamentally different instruction sets than x86 processors, meaning virtualization was relegated to ARM-based operating systems (e.g., Windows 11 on ARM or ARM-specific Linux distributions).
The Parallels Desktop 20.2 update breaks down this architectural barrier using a proprietary emulation system. While earlier solutions like UTM (a QEMU-based emulator) existed for Apple Silicon, Parallels leverages Apple’s built-in hypervisor to streamline the virtualization experience. You’ll now be able to run legacy x86 operating systems on your sleek Apple Silicon machine, including Windows 10, Windows 11, Windows Server, and certain x86-compatible Linux distributions.

What Does the Magic?​

Parallels taps into emulation—a method through which one system mimics another platform’s CPU—but with notable speed penalties. Here’s how it works:

• Emulated environments decode x86 instructions and retranslate them into commands recognizable by ARM processors.
• The Parallels proprietary platform integrates this emulation technique while also piggybacking on Apple’s Hypervisor Framework, which manages virtualization directly from the macOS kernel.

The result is cutting-edge but also far from flawless. Keep that thought; we’ll discuss the limitations in just a moment.

---

The Power—and Pain—of Emulation​

Running a fully different architecture like x86 on ARM is no simple task. Imagine reading a book in one language while mentally translating every word into a completely different tongue—it takes effort, latency creeps in, and the experience might not be instant. Here’s what you gain and lose with Parallels’ new x86-emulation capabilities.

The Good​

• Expand Cross-Platform Compatibility: If certain applications or use cases previously forced reliance on traditional PCs, this breakthrough makes those tools accessible to Mac users with Apple Silicon.
• Support for Legacy Software: Many users have longstanding use for 32-bit Windows apps or “x86 Linux-only” utilities, and now they can run in virtualization layers.
• Improved R&D Scope: Developers can build, debug, and test cross-platform software entirely on one machine—an ideal solution if your workflow requires mingling codebases.

The (Really) Bad​

But before you get too giddy:

• Performance Woes:
• x86 instructions must be translated into ARM instructions in real time. Translation takes time and computing resources, leading to sluggish operations. On Parallels’ own admission, running x86 Windows will stretch boot times between 2–7 minutes, with general usability feeling lethargic.
• Expect non-optimal performance—it’s an emulation zone, not a native highway.
• Limited to 64-bit Architectures:
• Only 64-bit operating systems are supported. For enthusiasts running ultra-light OSs like FreeDOS, this feature won’t be of much use. However, you can run older 32-bit applications within these 64-bit OSs.
• No USB Device Integration:
• USB device passthrough is a dealbreaker for projects that rely on external devices like USB storage or dongles.
• Nested Virtualization Unavailable:
• Windows Subsystem for Linux (WSL2)—a crowd-favorite feature for developers—is disabled due to restrictions in Parallels’ emulator environment.
• General System Responsiveness:
• Reports suggest Windows responsiveness under this mode is “low.” Heavy multitasking? Forget about it.

---

How to Get Started​

For those eager to test this feature out:

• Update Parallels: Ensure you’re using Parallels Desktop 20.2 or higher.
• Enable x86 Emulation: This feature is not enabled out of the box. You’ll need to reference specific documentation as outlined by Parallels for enabling it in advanced settings.
• Trial UTM First?: If you’d rather avoid spending money on Parallels Desktop and first explore your options, UTM—a free, slower alternative—is worth trying. Just don’t expect the bells and whistles of Parallels’ polished UX.

---

A New Dawn in Virtualization, with Caveats​

What does this development mean in the grander scheme of virtualization? For starters, it makes Apple Silicon more versatile—something critics flagged when Apple dropped x86 compatibility. As daily workflows or development relies increasingly on blending operating systems, running both ARM-optimized OSs and legacy systems will become vital.
However, all this comes at a significant performance cost that casual users may find less than compelling. Developers may rejoice, but gamers? Probably not. When comparing deployment scenarios, the sluggish boot times and downgrades in system responsiveness mean emulated systems will serve as a Plan B, not a primary OS-viable option.

---

Is Emulation the Future?​

While Parallels’ latest move brings us closer to dissolving the x86/ARM divide, it raises larger questions about the virtualization industry. When does emulation actually make sense versus native support? Apple’s dominance over proprietary silicon (and its performance gains) are well-documented, but x86 is far from obsolete, especially in enterprise contexts. This development further bridges the gap while underscoring where ARM-based architecture still has growing pains.

---

Comments? Let’s Discuss!​

What do you think about Parallels Desktop's foray into x86 emulation? Is this a killer feature that laptop professionals have desperately needed, or just another compromise? Let us know your workflow challenges and successes in the comment thread below! Engage, debate, and share—after all, it's a brave new multi-OS world out there.
Stay tuned to WindowsForum.com for more in-depth analysis of tech breakthroughs that matter.

---

Source: How-To Geek Parallels Can Now Run x86 Windows and Linux on Apple Silicon Mac

 

[ChatGPT]

If you're a Mac user who has struggled with compatibility in a post-Intel world, Parallels might just have something special for you: starting with Parallels Desktop 20.2, x86 emulation support for Apple Silicon Macs is here. It’s a significant leap forward in the virtualization space, enabling new functionalities for users of the powerful yet notoriously compatibility-challenged M-series Macs. But hold on—this isn’t perfect just yet. Let’s break this down WindowsForum.com style and explore what this means for the community, including its limitations, the tech behind it, and what you can potentially achieve with it.

---

From Arm to x86: The Compatibility Challenge​

Apple's M1 and M2 chips are built on ARM architecture. While offering impressive power efficiency and performance, these chips created hurdles for users who relied on software developed for x86 architecture (think decades of Windows applications). Previously, Parallels Desktop offered virtualization for ARM-based Windows operating systems, which was a nice workaround but left many users wishing for x86 support. Why? Because ARM-based Windows has limited application support—it’s not even in the same league as the tried-and-true x86 version of Windows that developers, IT professionals, and gamers are used to.
This needed a fix. And Parallels has taken its swing with preliminary x86 emulation support to finally allow running full-fledged x86 64-bit operating systems and apps on Apple Silicon Macs.

---

What Exactly Just Changed?​

With the Parallels Desktop 20.2 release, users can now emulate x86 processors on M1 and M2 Mac hardware. Here’s what you get:

• Supported Operating Systems: Users can create and run x86 versions of Windows 10, Windows 11, and Windows Server. The update even supports contemporary editions like Windows 10 21H2 and Windows Server 2022.
• Linux Compatibility: Certain Linux distros in the x86 family are now possible within this environment.
• Wider App Compatibility: This update widens the roster of compatible Windows applications, including older apps and specific business software that doesn’t yet play nicely with ARM.
• Real-World Use Cases: IT administrators can run tools like Active Directory, developers can test apps in x86 environments, and regular users can run Windows-only software and games—well, potentially.

---

The Technical Guts: How Does x86 Emulation Work?​

x86 emulation essentially translates instructions meant for x86 processors (like Intel and AMD) into ARM-friendly commands that Apple Silicon can work with. Here’s a simplified breakdown:

• Dynamic Binary Translation: When you launch an x86 application, the emulator translates the x86 instructions into ARM equivalents, one chunk at a time, as the program executes. Think of it as a real-time interpreter.
• Performance Cost: This translation isn't free—there's a performance penalty because the emulator has to pause and rebuild these instructions constantly. The execution speed is much slower compared to running a native Intel-based Mac or an ARM-specific app.
• Selective Translation: Emulation doesn’t cover the entirety of the x86 instruction set yet. There may be gaps in feature availability depending on your software needs.

What does this mean practically? Boot times for virtual machines can range from 2 to 7 minutes, responsiveness is lower than expected, and heavy tasks (like gaming or advanced compilation) may be sluggish.

---

Caveats and Limitations: The Rocky Road Ahead​

Not all emulation glitters like a remake of gold—this "early access" solution comes with some notable restrictions. Here’s what you should keep in mind before you dive in:

• Performance Limitations:
• Booting an emulated x86 system can feel like waiting for Windows XP’s mythical ‘Welcome’ screen to load back in the early 2000s. Expect sluggishness with intensive apps, meaning lightweight tasks are your best bet for now.
• Lack of USB Support:
• Yep, no USB device integration yet. Want to connect your external storage or a USB printer? You’ll have to wait for a future update.
• No Nested Virtualization:
• Features like Windows Subsystem for Linux 2 (WSL2) or running VMware within your virtual machine are not supported. Tech enthusiasts and power users relying on nested virtualization will have to look elsewhere—at least for now.
• 64-Bit Operating Systems Only:
• Forget about running Windows 7 or other older 32-bit operating systems—this emulation is locked firmly into the modern x64 era.
• Hidden Experimental Feature:
• This isn’t on by default. You’ll need to enable the feature manually by right-clicking a virtual machine flagged ‘Not Compatible’ and selecting “Start Using Emulator”. Alternatively, it's accessible via the Parallels Command-Line Interface utility for the script-savvy among you.

---

Why Does This Matter in the Grand Scheme?​

For Mac users—especially those in the professional or enterprise spaces—this could mean liberation from the niche limitations of ARM-based environments. With x86 emulation:

• Development Freedom: Developers can finally test against the x86 Windows ecosystem without owning additional hardware.
• Greater App Ecosystem: Compatibility with legacy or specialized software reopens some hefty doors.
• Gaming Potential (But Not Yet): With better performance tuning in the future, running x86 games—plus mods or tools like Steam—on Apple Silicon might just be viable.

However, this launch isn’t just a victory lap yet. Early adopters will need to temper their expectations. Parallels’ x86 emulation feels more like a proof-of-concept so far rather than a polished product.

---

So, Is It Worth It?​

If you’ve been desperate for a new way to run x86 apps on an M1 or M2 Mac, yes, give it a shot. But know what you’re getting into—think of it as Beta software. More broadly, this step symbolizes a leap forward for virtualization on Apple Silicon, even if it’s not sprinting just yet.
For everyone else—especially gamers, developers using nested environments, or IT admins depending on advanced hardware acceleration—this is more of a “watch this space” moment. Future versions will iron out bugs, optimize performance, and likely deliver on the promise of a "one-size-fits-all" Mac-powered virtualization.

---

Final Thoughts​

Parallels Desktop 20.2 introduces a landmark feature with enormous implications for Mac users, but it’s also very much a work in progress. While the shiny banner of x86 emulation will turn heads, don’t expect flawless performance just yet. Still, it’s a glimpse into a future where Apple Silicon-powered Macs might just be as versatile as their Intel predecessors, and that’s a future worth cheering for.
Have you tried Parallels Desktop’s x86 emulation yet? Share your thoughts, challenges, or successes with the community. Let’s figure out this new frontier together!

---

Source: TechSpot Parallels introduces x86 emulation for Apple Silicon Macs

 

[ChatGPT]

If you've ever looked longingly at the sleek power of an Apple Silicon Mac and wondered if you could run your favorite x86 operating systems like Windows 11 or legacy Linux distributions on this hardware, buckle up—because it’s finally possible. Well, sort of. While it's not exactly the smooth-as-butter experience you might be used to, Parallels Desktop has taken a significant leap forward into uncharted territory, adding x86 emulation support for Apple Silicon Macs. This move has far-reaching implications for tech enthusiasts, developers, and regular users who need versatility from their hardware.
This is no small feat, considering Apple's shiny, efficient M1 and M2 processors are based on ARM architecture—leaving traditional x86 operating systems out in the cold. But before your inner geek throws a party, let’s break down what this exciting announcement means, its limitations, and whether it might actually be useful for you.

---

The Headline: x86 Emulation Arrives on Apple Silicon​

Parallels Desktop 20.2.0 introduces an innovative new feature: experimental support for x86_64 operating systems on Macs with Apple Silicon chips. Yes, that includes everything from Windows 10 and Windows 11 (x86 editions) to various Linux distributions. Users now have the option to install these x86 operating systems directly via the Parallels interface or through a more manual approach using its Command-Line Interface (CLI).
Why is this such a big deal? Prior to this release, Parallels only supported running ARM-based operating systems. While running Windows 11 on Apple Silicon has been possible since 2021, it was limited to Microsoft's ARM-based version, which often doesn't play well with legacy x86 software and apps. This new update bridges that gap, allowing users to explore the full range of x86 operating systems.

---

How Does It Work? Magic? Science? Or Both?​

To achieve x86 emulation, Parallels Desktop essentially acts as a translator between the ARM architecture of Mac processors and the x86 expectations of operating systems like Windows and Linux. This process involves dynamically converting x86 instructions into ARM-compatible instructions in real time.

Key Technology: The Apple Hypervisor​

• Instead of relying on custom virtualization solutions, Parallels leverages the Apple Hypervisor, a low-level functionality built into macOS. The Apple Hypervisor plays the essential role of managing system interactions and resource allocations between the virtual x86 operating system and the host Mac environment.
• By leaning on Apple's hypervisor, Parallels ensures a level of compatibility while reducing development overhead. However, this also imposes certain limitations, like an inability to use Parallels’ own hypervisor module, which has advanced virtualization features.

This dynamic emulation comes at a cost, though—it’s slow. Really slow. Windows boot times hover between 2–7 minutes, and once running, responsiveness is significantly hampered. This isn't going to win any races, but hey, the option is now there.

---

The Drawbacks: Is This Ready for Prime Time?​

Before you start dusting off your old x86 Windows installer ISOs, there are some hefty disclaimers you’ll want to consider. Here’s a quick primer on the known limitations:

1. Sluggish Performance​

If you're expecting snappy performance, think again. Parallels has been clear that this feature is still in the technology preview stage, meaning it’s mostly intended for developers or curious experimenters. Running x86 Windows on an M1 or M2 is currently more akin to watching paint dry than anything resembling "normal" Windows use.

2. No Support for Specific Hardware Features​

• USB Devices: USB pass-through doesn’t work. This means any hardware-dependent features (like accessing external drives via USB) are out of the question.
• Audio Output: Your virtual machine will remain stubbornly silent. No sound support is baked in yet.
• Peripheral Recognition: Plug-and-play devices like printers or webcams are also no-go.

3. Limited OS Compatibility​

While you can run 32-bit applications within an x86 operating system, 32-bit OS support isn’t available. This might be a dealbreaker for those clinging to 32-bit Linux distributions or legacy Windows versions.

---

Why Should You Care? The Broader Implications​

For Windows users, particularly developers and enterprise teams, this update is a significant step forward. Here are the critical takeaways:

1. Opening Doors for Cross-Platform Development​

If you’re a developer working on a Mac but need to test software on x86 Windows, you now have another path besides maintaining clunky, aging hardware or investing in cloud-based VM solutions. It’s a win, albeit a small one, given performance limitations.

2. Breaking the Apple Silicon Isolation​

Apple Silicon Macs have gained accolades for their performance and efficiency, but the lack of native x86 support has been a sticking point for many considering the switch. While Parallels' solution isn’t perfect, it demonstrates that x86 applications can live (if not thrive) in an Apple Silicon environment.

3. A Preview of Things to Come?​

Parallels itself has labeled the feature as experimental, providing a glimmer of hope that optimizations will improve. Consider this update a "proof of concept"—imperfect but full of potential. Who knows? In the coming years, as hardware and software improve, you may not even notice you’re running emulated x86 software on an ARM processor.

---

How Do You Enable This Wizardry on Your Mac?​

Ready to dive in? Keep your expectations managed, but here’s how to enable x86 emulation in Parallels Desktop 20.2.0:

• Update to the Latest Version: Ensure you have Parallels Desktop 20.2.0 or later. You’ll need a valid subscription to access the latest features.
• Activate Experimental Mode: Right-click on a “not compatible” target virtual machine in the interface, and select Start using Emulator.
• Command-Line Geeks Rejoice: Alternatively, you can use the Parallels CLI tool to launch the feature manually.

---

The Verdict: Experimentation Over Practicality (For Now)​

To say Parallels Desktop has pulled off an engineering marvel would not be overstating it. Porting x86 support to Apple Silicon isn't just a technical achievement—it’s a potential lifeline for users stuck between Windows x86 applications and the desire for Apple’s ARM-based hardware.
Still, the feature isn’t ready for mainstream adoption. Boot times are glacial, and usability hangs in a nebulous "proof-of-concept" territory. But make no mistake: this update cracks open the door for running legacy x86 software on modern Apple Silicon hardware—a previously thought-to-be-impossible task.
So, should you jump headfirst into this experimental version of Parallels Desktop? If you’re a curious tinkerer or a developer desperate for x86 compatibility, absolutely. For the everyday user looking for smooth performance? Best to keep an eye on future updates before diving in.
And who knows—this might just be the start of something great. Stay tuned, because the emulation game just got a whole lot more interesting.

---

Source: Tom's Hardware Parallels adds x86 OS support for Apple Silicon — you can now run x86 Windows and Linux distros