Who touchHLE is for#
Retro gaming enthusiasts replaying delisted early iOS titles
touchHLE gives players access to early iPhone games removed from the App Store when Apple dropped 32-bit support in iOS 11. If you legally own a .ipa file and want to run it on a modern PC or Android device rather than aging hardware, touchHLE is the primary open source tool capable of running it.
Skip if:
If the title you want to play was updated to a 64-bit build or requires iOS 5 or later features, touchHLE cannot run it. Check the appdb.touchhle.org compatibility database for your specific app version before investing time in setup.
Software preservation researchers studying early iOS applications
Researchers studying the history of early iOS application design, game mechanics, or system framework behavior can run original .ipa binaries on desktop hardware without maintaining aging physical devices. The open source codebase also documents exactly which system framework calls each app makes.
Skip if:
If your preservation work requires apps beyond iOS 4.0.x, or if you need visibility below the framework layer (kernel, drivers, hardware), touchHLE's HLE approach is not the right fit: it does not simulate hardware and has no low-level inspection capability.
Developers studying early iPhone OS app architecture
touchHLE's open HLE implementation documents which APIs early iOS apps called and how they behaved, which is informative for developers studying the evolution of iOS frameworks. Running the original binary alongside the touchHLE source reveals what Foundation or UIKit behavior the app depended on across specific OS versions.
Skip if:
If you need to develop or test a current iOS app rather than study historical behavior, Xcode's iOS Simulator on a Mac is the appropriate tool. touchHLE is not a development environment and does not support current iOS versions.
Android users accessing historically iPhone-exclusive early titles
A subset of early iOS games never appeared on Android. touchHLE's AArch64 Android release lets Android users run these historically iPhone-exclusive titles directly from their phone, using the built-in app picker and native touch input, without needing a PC or any Apple hardware.
Skip if:
App compatibility is limited across all platforms. Verify the specific title and version in the appdb.touchhle.org database before acquiring the .ipa file. Most early iOS apps do not yet run correctly in touchHLE on any platform.
The problem it solves#
Early iPhone OS games and apps from 2008 to 2011 are effectively inaccessible on modern hardware. The physical devices that ran them are either dead, battery-depleted, or require specific aging iOS versions to function. Apple dropped 32-bit app support when iOS 11 shipped in 2017, and the App Store no longer carries these titles. Neither Apple's Simulator nor any modern iPhone can run them.
For preservation researchers and retro gaming enthusiasts, the workarounds are unsatisfying. Hunting down a functional iPod touch means paying elevated prices for aging hardware, and the device still needs a sufficiently old iOS version installed. Cloud-based iOS testing services exist, but they target developer QA on current iOS versions, not decade-old 32-bit titles. There is no commercial platform that covers this gap.
How it solves it#
High-Level Emulation of iOS System Frameworks
Rather than simulating iPhone hardware and running iOS inside a VM, touchHLE implements the iOS system frameworks directly: Foundation, UIKit, OpenGL ES, and OpenAL. The app binary and a handful of bundled libraries run on the dynarmic ARM emulation core, with touchHLE acting in place of iOS. This approach targets a specific set of early titles more practically than full low-level hardware simulation.
Binary Releases for Windows, macOS, and Android
Pre-built binaries ship for x64 Windows, x64 macOS, and AArch64 Android. Apple Silicon Mac users can run the x64 release through Rosetta. Linux users on x64 or AArch64 can build from the Rust source. No iOS device, Mac, or development environment is required on Windows or Android to get started.
Crowdsourced App Compatibility Database
The touchHLE app compatibility database at appdb.touchhle.org tracks which versions of which apps are known to work. Anyone can contribute test results. It is the first place to check before spending time locating and decrypting a specific .ipa file, since the vast majority of early iOS apps do not yet run correctly.
Multiple Input Methods Including Game Controller Support
Simulated touch input works via mouse (left-click to tap, hold, or drag), game controller virtual cursor (right analog stick with shoulder button), button-to-touch mapping, or real touch input on a touch-screen device. Accelerometer input is simulated via the left analog stick or right mouse button. Real device accelerometers work on Android.
Local Wi-Fi Multiplayer for Supported Titles
Some titles support local multiplayer over Wi-Fi between two or more devices running touchHLE on the same network. Asphalt 4 and N.O.V.A. are confirmed examples. Real iOS devices on the same network can also join or host these sessions. Network access must be enabled in Quick Options and touchHLE must be whitelisted in the OS firewall.
Built-in App Picker with Persistent Save Data
The graphical app picker lists all .ipa files and .app bundles placed in the touchHLE_apps directory. On Android, this is the only available interface. Game saves and app data are stored separately in the touchHLE_sandbox folder, so progress persists across sessions. Options are configured via the touchHLE_options.txt file.
Strengths and trade-offs#
Strengths
- No Apple Hardware or Account RequiredtouchHLE runs on Windows, macOS, and Android without any Apple device, active Apple developer account, or Xcode installation. The target audience for retro iOS preservation has no need to maintain expensive aging hardware or a subscription-dependent development environment. Binary releases are available free from the GitHub releases page.
- OSI-Approved Licensing with No Per-Use FeesSource code is licensed under Mozilla Public License 2.0, which allows integration with both proprietary and open source projects. Compiled binaries ship under GPL-3.0 or later due to dependency license compatibility. Both licenses are OSI-approved. There are no per-use fees, usage caps, or restrictions on running the emulator for personal preservation use.
- Active Development with Growing Contributor BaseStarted as a solo project in December 2022, the codebase has attracted multiple volunteer contributors. The GitHub repository shows continued commits (latest push October 2026) and has accumulated nearly 4,000 stars. Compatibility improves incrementally as contributors add support for the specific frameworks needed by target games.
- Open Compatibility Tracking Anyone Can ExtendRather than maintaining a private compatibility list, touchHLE runs an open crowdsourced database at appdb.touchhle.org where anyone can submit test results. This extends the testing surface well beyond what the small contributor team can cover alone, and gives users a way to verify whether a specific app version is known to work before investing time in setup.
Trade-offs
- -Very Limited App CompatibilityThe README is explicit: the vast majority of iPhone OS 2.x, 3.x, and iOS 4.x apps do not currently work in touchHLE. Of those that do, almost all are games; productivity apps and other non-game categories are lower priority for contributors. The compatibility database at appdb.touchhle.org should be checked before attempting to run any specific title.
- -64-Bit iOS Is Permanently Out of ScopeThe project has explicitly stated in GitHub issue #181 that 64-bit iOS support is not planned. This means touchHLE permanently tops out at early 32-bit iPhone OS and iOS 4.0.x titles. Any app requiring a device running iOS 7 or later on modern hardware is outside this project's remit and will never be addressed.
- -No Guaranteed Release CadenceThe project has had only a handful of releases since its February 2023 launch and relies entirely on volunteer contributions. The README explicitly states no promises about the future. Users who need support for a specific title may wait months or longer for the required framework features to be implemented, if they are implemented at all.
- -Certain Overlay Tools Break EmulationTools that inject into processes, such as the Steam overlay, Discord overlay, and RivaTuner Statistics Server, are known to interfere with touchHLE on Windows. RivaTuner is the only currently confirmed cause of crashes, but the README warns that any process-injecting overlay may cause immediate failures. Disabling overlays before running touchHLE is the current workaround.
touchHLE vs alternatives#
touchHLE vs Appetize.io
touchHLE and Appetize.io both let you run iOS apps without a physical Apple device, but they target entirely different use cases and iOS generations.
| Feature | touchHLE | Appetize.io |
|---|---|---|
| License | MPL-2.0 (source) / GPL-3.0 (binaries) | Proprietary, SaaS |
| Hosting | Self-hosted, runs locally | Cloud-only, no self-hosting |
| iOS versions | iPhone OS 2.x, 3.x, iOS 4.0.x (32-bit) | Current iOS (modern versions) |
| Pricing | Free | Paid commercial tiers |
| Primary use case | Preservation and retro gaming | Developer QA and app testing |
| App compatibility | Limited, focused on early games | Current App Store apps |
| Platform | Windows, macOS, Android | Web browser |
Appetize.io is the better choice when you need to test or demonstrate a current iOS app in a browser without requiring users to install anything. It streams a live iOS session from cloud infrastructure and works with modern App Store apps. The paid tiers are aimed at development teams running automated testing pipelines or sharing app previews with clients.
touchHLE serves a different need: running historically preserved early iPhone titles that no longer run on any modern Apple device or official simulator. Apple dropped 32-bit app support in iOS 11 (2017), making a specific category of App Store games from the platform's first few years inaccessible through any commercial channel. touchHLE's locally executed approach means no monthly fees, no data leaving your machine, and no dependency on a third-party service's uptime.
touchHLE falls short when your iOS version requirement extends past iOS 4.0.x, or when you need the majority of apps to run reliably. In those cases, Appetize.io for current iOS testing, or a physical device running a compatible iOS version, is the more reliable path.
Quick start#
Install touchHLE by downloading a binary release from the GitHub releases page for Windows, macOS, or Android, or build from the source repository using the Rust toolchain.
```bash
git clone https://github.com/touchHLE/touchHLE
./touchHLE YourApp.ipa
```What it's built on#
- Languages
- C++Objective-CRust
FAQ#
Which iOS versions does touchHLE support?
touchHLE supports apps targeting iPhone OS 2.x, iPhone OS 3.x, and iOS 4.0.x for 32-bit iPhone and iPod touch hardware. iPad apps for these early OS versions are also within scope. 64-bit iOS (iOS 7 and above on modern Apple hardware) is permanently out of scope. Retina Display and newer iOS 4.x versions beyond 4.0.x are listed as longer-term goals with no published timeline.
Does touchHLE run on Linux?
Linux is not officially supported with pre-built binaries, but x64 Linux and AArch64 Linux are expected to work if you build from source. Build instructions are in the dev-docs/building.md file in the repository. Official binary releases exist only for x64 Windows, x64 macOS, and AArch64 Android. Apple Silicon Mac users can run the x64 macOS release through Rosetta.
Can I run any early iOS app in touchHLE?
No. The vast majority of iPhone OS 2.x, 3.x, and iOS 4.x apps do not currently run in touchHLE. Compatibility is highest for games using OpenGL ES and OpenAL, which are the most complete framework implementations. UIKit, which non-game apps rely on heavily, is described in the README as hacky and incomplete. The crowdsourced compatibility database at appdb.touchhle.org lists which specific app versions are known to work.
Is it legal to use touchHLE?
touchHLE itself is MPL-2.0 licensed open source software and legal to use. Whether you can legally run a specific app depends on how you obtained it. The project README states clearly: only use touchHLE to emulate software you have obtained legally. The app binary must also be decrypted before touchHLE can run it. touchHLE is not affiliated with or endorsed by Apple Inc.
What input devices does touchHLE support?
Simulated touch input works via mouse or trackpad (left-click to tap, hold, or drag), game controller virtual cursor using the right analog stick, button-to-touch coordinate mapping, or real touch input on a touch-screen device. Accelerometer simulation is supported via game controller left analog stick or right mouse button hold. Real device accelerometers work on Android phones and tablets.
Similar open-source tools#
Parson
Self-hosted music server. Folder in, music everywhere.
Flutter
One codebase for mobile, web, and desktop. Native performance.
Madeira
Windows PC games on non-jailbroken iPhone via Wine and FEX-Emu
mobile-mcp
MCP server that gives AI agents hands on iOS and Android devices
BrewUI
Homebrew's official macOS GUI for package management
iloader
Free open-source iOS sideloader for Windows, Mac, and Linux