Location spoofing on iOS devices has always been a tricky problem for developers testing location-based apps. The usual options either require jailbreaking the device or installing a specialized app on the device itself — both of which have significant drawbacks. LocationSimulator takes a different route: it injects mock GPS coordinates directly into the iOS location services at the system level, without needing jailbreak or any app installation. This approach relies on Apple’s DeveloperDiskImage and the open-source libimobiledevice library, running from macOS.
How LocationSimulator spoofs iOS locations without jailbreak
LocationSimulator is a macOS application targeting macOS 10.15 and newer, written entirely in Swift. It supports spoofing location on physical iOS and iPadOS devices connected via USB or Wi-Fi, as well as the iPhoneSimulator for app testing.
At its core, it uses Apple’s DeveloperDiskImage feature, which is typically used by Xcode to enable developer tools on connected iOS devices. LocationSimulator cleverly uses this to inject mock GPS coordinates into the device’s location services subsystem. This injection happens at a low system level, bypassing the need for any app-level mock or jailbreak-based tweaks.
The project integrates libimobiledevice, an open-source cross-platform toolset for interacting with iOS devices. This library handles the communication with the device over USB or Wi-Fi, facilitating the DeveloperDiskImage injection and location service manipulation.
The repo is modularized into several Swift packages:
- LocationSpoofer: The backend responsible for injecting the mock location data.
- XCF: A low-level framework handling the complexities of interacting with Apple’s private frameworks and DeveloperDiskImage management.
- Localization: Handling language and region localization for the UI.
- UI: The user interface components built with SwiftUI, providing a clean and intuitive experience.
This modular package structure aids maintainability and separation of concerns, letting developers dive into specific parts like the low-level injection logic or UI independently.
What sets LocationSimulator’s approach apart
The main technical strength of LocationSimulator is its use of DeveloperDiskImage injection combined with libimobiledevice to spoof GPS data at the system level without jailbreaking. This is a non-trivial feat given Apple’s locked-down ecosystem.
Most tools for iOS location spoofing rely on either jailbreaking (which modifies the device’s system) or installing a mock location app on the device. Both approaches have downsides: jailbreaking voids warranties and is hard to maintain, while mock apps can be detected and require app-level support.
LocationSimulator avoids these by working entirely from macOS and injecting mock locations at a layer beneath user apps. This means it can spoof location for any app on the device transparently.
The code quality reflects this complexity — the project uses Swift 5.0+ and Swift Package Manager to organize a clean, modular codebase. The backend injection logic in LocationSpoofer and XCF is intricate, handling private APIs and binary format manipulations under the hood.
However, this method carries tradeoffs:
- Platform limitation: It only works on macOS 10.15 or newer, excluding Windows or Linux users.
- Device compatibility: It depends on Apple’s DeveloperDiskImage, so support may vary with iOS versions and device models.
- Complexity and maintenance: Interfacing with private Apple frameworks and using libimobiledevice means the project must keep pace with Apple’s internal changes, which can be brittle.
Additionally, the app features predefined movement profiles like walk, cycle, and drive, keyboard-controlled navigation for manual spoofing, and can parse GPX files to simulate routes — useful tools for realistic location testing.
Install and get started with LocationSimulator
To try LocationSimulator, you can either download the latest release build from GitHub or install it via Homebrew on macOS. The exact installation commands from the README are:
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install.sh)"
Then:
brew install locationsimulator
Requirements include:
- macOS 10.15 or later
- macOS 11.x+ SDK
- Swift 5.0 or newer
- Swift tools version 5.2 or newer
- Jekyll installed and symlinked to
/usr/local/bin/jekyll
Once installed, the UI guides you through connecting your device and starting location spoofing, including loading GPX routes or using manual controls.
Verdict: who should use LocationSimulator?
LocationSimulator solves a real pain point for iOS developers who need to test location-based features without jailbreaking or installing helper apps on devices. Its system-level injection method offers a transparent, versatile way to spoof locations.
It’s most relevant for developers with access to a macOS environment who want to perform robust, low-footprint location testing on physical iOS devices or simulators.
The approach is technically impressive but comes with limitations: it’s macOS-only, depends on Apple’s internal tools that may break with updates, and requires some familiarity with iOS development tooling.
For teams building location-aware apps or services, LocationSimulator can save a lot of time compared to more intrusive or less reliable methods. However, it’s less suited for casual users or cross-platform developers due to its macOS and Swift-centric ecosystem.
Overall, this repo is a solid example of reverse-engineering and system-level iOS tooling done right, with an honest tradeoff between power and complexity.
→ GitHub Repo: Schlaubischlump/LocationSimulator ⭐ 2,956 · Swift