# Madeira on iPhone: Windows PC Games Through FEX-Emu and Wine

> Madeira packages FEX-Emu, Wine, DXMT and a Metal-based Direct3D 12 implementation into a sideloaded iOS app. It targets iPhone owners who want to run unmodified x86 or x86-64 Windows games, but its iOS 26, JIT and sideloading constraints make it a research project rather than a general App Store solution.

**willfaust/Madeira** — Run x86-64 Windows PC games on jailed iOS via FEX-Emu + Wine + DXMT

- Repository: https://github.com/willfaust/Madeira
- Stars: 2,710 · Forks: 341
- Language: C
- License: GPL-3.0
- Published: 2026-10-16 · Updated: 2026-10-16 · Language: en
- Canonical page: https://hysenlabs.com/projects/willfaust-madeira

## Why Madeira targets jailed iOS PC gaming

Madeira addresses a narrow but substantial hardware mismatch: iPhones use ARM processors, while many Windows PC games contain x86 or x86-64 instructions and expect a Windows graphics stack. Madeira places the compatibility layers inside one iOS application rather than requiring users to install a traditional Windows environment. Games run without binary modifications inside that app.

The intended user is already comfortable with sideloading and signing an IPA with an Apple ID. The README requires iOS 26 or later and says this is the only version on which Madeira currently runs reliably. It also requires JIT access, which iOS permits only while a debugger is attached. Those conditions exclude users who expect an ordinary App Store download, unattended setup or a simple one-time installation.

This is not a claim that every Windows title works. Madeira calls itself an active research project and warns that many games start, some play well, and both performance and compatibility vary by game. The README even uses the phrase "Expect rough edges," which is an unusually direct description of the project's present state.

## FEX-Emu, Wine and the two Direct3D paths

Madeira's execution path begins with FEX-Emu, which translates the game's x86 or x86-64 code to ARM64 while it runs. Wine 11.4 supplies the Windows environment above that translation layer. According to the README, Madeira builds Wine for ARM64EC so Wine itself runs natively on iOS and only the game's code needs translation. Supported 32-bit games take a different path through WoW64.

Graphics handling is divided by API generation. DXMT renders Direct3D 9, 10 and 11 through Metal. For Direct3D 12, Madeira includes its own `madeira-d3d12` implementation, which converts DXIL shaders at run time with Apple's Metal Shader Converter. This is important because there is no single graphics compatibility layer for every Windows game.

iOS also prevents an app from starting unrelated programs. Madeira therefore runs the entire stack in one process. Wine's server, normally a separate process, runs as a thread. FFmpeg, VideoToolbox and AudioToolbox handle the documented media path for video and audio, while XInput support and touch controls provide controller input. The repository layout reflects this division: `app/` contains the SwiftUI front end and Wine bridge, while `build/` contains component-specific scripts and iOS-side sources.

## Installing the Madeira IPA on an iPhone

For a first installation, use a signed release rather than attempting to build the multi-part source tree. The README directs users to download the IPA from the latest release, then sideload it with SideStore, AltStore, Sideloadly, Plume or a similar tool using their own Apple ID.

A free Apple account can sign the app, but its signing expires after seven days. Madeira must therefore be refreshed weekly. The README says games and saves are kept across reinstalls, but App Store users cannot use Madeira because its JIT requirement depends on an attached debugger.

After sideloading, open Madeira and enable JIT. Automatic mode uses StikDebug when that application is installed. If it is absent, Madeira guides the user through its built-in setup. The README also states that on iOS 27 the built-in helper can pair the iPhone itself without a computer. That does not remove the general debugger requirement.

In the application, open Settings and confirm that both `JIT` and `Memory+` have green checks. Madeira then displays `Ready to play`. This readiness screen is the concrete checkpoint for the documented installation path. A title may still require additional components, particularly a Microsoft Visual C++ runtime for some 64-bit games.

## Starting Steam through Madeira Dock

Madeira's first substantial use begins inside its game library. The app provides artwork, search and a Windows desktop session. For Steam, the documented flow uses Valve's own Windows Steam client through Madeira Dock, allowing users to sign in, browse owned games, install or update them, and start a selected game.

This approach preserves Steam as the source of the game library rather than replacing it with an iOS account system. It also means Madeira is responsible for presenting the Windows client and translating its execution needs inside the single-process iOS environment.

Before starting a game, Madeira attempts Steam Cloud synchronization. Saves sync when Madeira starts and before the game launches. If the same save changed on both sides, Madeira asks the user rather than silently replacing one version. Data replaced during synchronization is backed up. The in-game option `Upload saves and close Madeira` sends changes when play ends.

The README does not give a CLI command for adding or launching a game. In practice, the documented first use is graphical: install the IPA, establish JIT and `Memory+` readiness, open Madeira, sign into Steam through Madeira Dock, select a game and start it. Compatibility of the selected title must be treated as an open question rather than guaranteed by Steam installation succeeding.

## Direct3D coverage does not remove game-level constraints

The graphics stack covers recognizable Windows APIs, but API coverage is not equivalent to whole-game compatibility. Madeira can render Direct3D 9, 10 and 11 through DXMT and provides a separate Direct3D 12 implementation backed by Metal. Games can still fail for reasons involving instructions, libraries, anti-cheat behavior, input assumptions or other Windows components not described by the project.

The Visual C++ runtime is an explicit gap. The README states that some 64-bit games need Microsoft's runtime and that Madeira does not include it. The licensing documentation covers additional runtime distribution, but the installation guide does not claim that Madeira automatically supplies every dependency.

Apple hardware also introduces limits that compatibility layers cannot erase. Rendering and shader translation work on Metal, yet the README documents variable performance without naming a supported frame-rate target or a list of verified titles. It does not document rollback, per-game presets, anti-cheat compatibility or a compatibility database. Those omissions make broad claims about Madeira unsafe.

The project also targets a moving platform. The requirements name iOS 26 as the reliable baseline while separately discussing iOS 27, and the app depends on JIT behavior controlled by the operating system. A future system policy change could therefore affect setup even when Madeira's internal translation code remains unchanged.

## Madeira compared with native ports and remote execution

A native iOS port is a real alternative when a game developer has produced one. A port recompiles or reimplements the game for the target platform and ships an ordinary iOS application, removing the need to emulate x86 code and provide a Windows compatibility environment at run time. Its drawback is that it exists only when the rights holder has released it, and Madeira cannot claim the same library coverage because it attempts to load existing Windows builds.

Remote PC execution is another approach with a different boundary. Instead of translating a game and its dependencies on the iPhone, a remote application would stream the game from another computer. That shifts CPU, GPU and Windows compatibility costs to the host, but it also depends on a remote machine and network connection. The Madeira README discusses none of those remote requirements because Madeira is a local compatibility stack.

For someone who already owns a sideloading workflow and wants a selected PC game locally on an iPhone, Madeira offers a more direct route than waiting for a native port. For users without a remote PC, or without a willing rights holder, the alternatives may offer little practical choice.

## Maintenance, source builds and license boundaries

The repository is not archived, and its last push was on 2026-10-14. Recent tagged releases include `v0.1.1`, `v0.1.2` and `v0.1.3`, all dated in October 2026. That supports calling Madeira active, although its own README still characterizes it as research software with expected rough edges.

Building from source has a substantial cost. Madeira uses project-specific forks of FEX, Wine, DXMT and Madeira Dock as submodules. Upstream checkouts do not build in the expected arrangement. The build also includes Wine Unix libraries, ARM64EC Windows modules, FEX, DXMT and the iOS app, while some toolchain inputs are absent from the repository. The first source-build command documented in the README is:

```sh
git clone --recurse-submodules https://github.com/willfaust/Madeira.git
```

The `--recurse-submodules` option is required because the project points to its own forks. This command obtains the checkout, but it does not supply every missing build input or replace the process in `docs/BUILDING.md`.

Madeira is licensed under `GPL-3.0-or-later` with the Madeira Converter Exception, which adds permission for use with Apple's Metal Shader Converter. Component terms differ. The Wine fork is `LGPL-2.1-or-later`. FEX and DXMT retain MIT licensing for upstream code, while Madeira changes are `GPL-3.0-or-later` with the exception. The rpmalloc fork keeps its upstream terms. Distribution and modification therefore require attention to `LICENSE`, `LICENSE-EXCEPTION.md`, `LICENSES/` and `THIRD-PARTY-NOTICES.md`.

## Conclusion

Madeira is appropriate for an iPhone owner who already uses sideloading, accepts weekly resigning and has a specific PC game that appears compatible. It is a poor fit for someone who needs App Store distribution, unattended operation or predictable game compatibility. Before adopting it, verify that the target game starts on iOS 26, that its required Visual C++ runtime can be supplied, and that Steam Cloud conflicts will not interrupt play.

## FAQ

### Can Madeira run Windows games on an iPhone without jailbreak?

Yes. Madeira packages the Windows compatibility stack inside one iOS app, and the README explicitly says games run unmodified without a jailbreak.

### What does Madeira require before a game can start?

It requires an iPhone on iOS 26 or later, a working JIT setup, and green checks for `JIT` and `Memory+`. The app must show `Ready to play` before use.

### Does Madeira support Steam and Steam Cloud saves?

It runs Valve's Windows Steam client through Madeira Dock and supports installation, updates, launching, and save synchronization. Conflicting changes on both sides prompt the user rather than being overwritten silently.

## Sources

- [Issues](https://github.com/willfaust/Madeira/issues)
- [License: GPL-3.0](https://github.com/willfaust/Madeira/blob/main/LICENSE)
- [README](https://github.com/willfaust/Madeira/blob/main/README.md)
- [Releases](https://github.com/willfaust/Madeira/releases)
- [willfaust/Madeira on GitHub](https://github.com/willfaust/Madeira)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/willfaust-madeira