PlayPort Runs Windows Games on Non-Jailbroken iPhones: Setup, JIT and Performance Limits

"Native" needs a footnote. These aren't iOS ports. They are Windows executables running through a stack of compatibility and translation layers, all on the phone's own CPU and GPU.

What PlayPort actually is​

PlayPort is an open-source, GPLv3 app. It lets you install a game from Steam, GOG or Epic Games, or bring your own, then play with a controller. Version 0.4 added the GOG, Epic and local-game support. The project's site says Steam titles bring cloud saves and achievements. Your own DRM-free games can be added from the iOS Files app, either as a folder or a .zip.

It builds on earlier work. The GitHub repository says PlayPort is built on Madeira, a research project that first ran Wine, FEX-Emu and DXMT as one process on iOS. Madeira proved it could be done, and PlayPort turns it into an app you can play with. So PlayPort is part of a fast-moving lineage rather than a lone miracle. Notebookcheck covered Madeira a few weeks ago.

How the stack works​

The layers are familiar to anyone who has followed Wine, Proton or Windows-on-Arm.

• Wine supplies the Windows API. Madeira's documentation says it is built for ARM64EC, so Wine itself runs natively and only the game's own code is translated. The PlayPort site lists WoW64 for 32-bit games and Proton 11 commits.
• FEX translates x86 and x86-64 code to ARM64 as the game runs.
• DXMT renders Direct3D 10 and 11 straight to Apple's Metal graphics API.
• KosmicKrisp, DXVK and vkd3d-proton form an experimental Vulkan route for Direct3D 9 and Direct3D 12. The project flags it as under active development.

The odd part is the single-process design. iOS allows no second process and no JIT without a debugger, so PlayPort runs Wine's multi-process design as threads of a single app. A bundled JIT helper attaches for every launch. The project claims more than 200 of its own patches on top of its dependencies. Those include a 32-bit runtime and faster FEX translation for Unity games.

The 32-bit trick​

32-bit games are a real problem on iOS. The project says iOS reserves the lowest 4 GB of memory, which is exactly where a 32-bit Windows game expects to live. PlayPort gives each 32-bit game its own 4 GB window higher up and translates memory accesses as it runs. Release notes say version 0.3.0 added the 32-bit runtime, with Direct3D 9 graphics on Apple's GPU. Portal 2 was the first 32-bit game to play.

Reported performance, and its limits​

All of these figures come from the developers, not independent testing.

The caveats come from the project itself:

• It was tested on one phone, an A19 Pro iPhone on iOS 27.0.
• Portal 2 is the only 32-bit game tested. Other 32-bit Direct3D 9 games take the same path, so expect rough edges.
• Heat matters. Long sessions warm the phone, and frame rates drop as it heats.

Installing it: not an App Store experience​

Windows Central summed up the setup as sideloading, Developer Mode and JIT. The project's current instructions are more specific.

• Get the IPA from the project's GitHub releases.
• Sideload it with your own Apple ID. The GitHub readme says PlayPort is not on the App Store, and a free Apple ID works. If the sideloader asks whether to keep app extensions, say yes. PlayPort's JIT helper is one.
• Pair the JIT helper. The site says that on iOS 27 you pair once, using a code in Developer Mode settings, and LocalDevVPN carries the connection on the phone itself. On iOS 26 you import a pairing file in the Setup check instead. People who already use StikDebug or LiveContainer can take JIT from them.
• Confirm memory and sign in. The in-app checklist verifies the memory entitlement and signs you in to Steam, GOG or Epic.

The GitHub readme's Developer Mode instruction and the site's per-version pairing instructions differ slightly. Follow the in-app checklist for your iOS version.

The memory-limit catch​

This is the detail most likely to trip people up. The game, the runtime and the JIT share one memory limit. With Increased Memory Limit, the developers' 12 GB test iPhone gives PlayPort 6 to 8 GB. Without it, an 8 GB iPhone gives about 3.3 GB, and PlayPort won't start a game known to need more.

The app requests the entitlement, but not every sideloader turns it on:

For SideStore users, the project's fix goes like this:

• Install PlayPort normally so its App ID exists.
• Sideload a utility called GetMoreRam and sign in with the same Apple ID.
• Refresh the App IDs page, tap PlayPort's App ID and add Increased Memory Limit.
• Reinstall PlayPort over itself. Games and saves stay.
• Check that Setup check shows Increased Memory Limit On.

The capability stays on the App ID through weekly refreshes. If the tick disappears, repeat the App ID and reinstall steps. GetMoreRam uses one of a free account's three app slots, so delete it afterwards.

The weekly refresh​

A free Apple ID signs apps for seven days. After that you refresh the app, and games and saves remain on the phone. PlayPort takes one of the account's three app slots. Its JIT helper uses one of the account's ten App IDs per week.

What it means​

Android has long had Windows-on-Arm emulation options, as Windows Central notes. iOS looked sealed by comparison, with no second process and JIT only under a debugger. PlayPort and Madeira show that a clever single-process design plus a debugger-attached helper can get around both limits. They do it without a jailbreak.

Skeptics have fair points:

• Sideloading, JIT pairing and weekly re-signing are far from mainstream.
• Results come from one phone.
• Windows Central itself raises the AI-assisted-code angle, noting Claude contributed. Open-source patches are reviewable either way.

The project's own compatibility list sorts games into working, playable with issues and broken. Treat it as a hobbyist compatibility layer, not a replacement for a handheld PC.

If you try it, check which iOS version you're on. Confirm the Memory step shows a tick, and expect a warm phone. If something breaks, the project asks you to use "Report a problem" on the game's page. That shares the logs as a .zip you can attach to a GitHub issue, along with your device, iOS version, PlayPort version and sideloader.

Correction (October 21, 2026): The performance table previously stated Hollow Knight reached "up to 120 fps at the full 2736×1260." The developers' own measured results (docs/evidence/2026-09-29-hk-gameplay-baseline.md) show up to ~120 fps at 720 rows and ~74–76 fps sustained at the full 2736×1260; the table has been corrected.