Quick Answer: You can control iPhone from Linux with phoneuse, an open-source project that receives the iPhone's screen over AirPlay and sends taps and keystrokes back as a Bluetooth mouse and keyboard. It needs no jailbreak, no developer account, no cable and no app on the phone. It relies on Screen Mirroring and AssistiveTouch, two features every iPhone already has.

Most people assume controlling a locked-down phone from a desktop means jailbreaking it or installing a vendor app. The phoneuse project on GitHub takes a different route. It uses the same two features Apple ships for mirroring and accessibility, so the phone never knows it's being driven by a computer. The author calls it a technology demo, and it's worth reading that label seriously before you build anything on top of it. Here's how it works, what it takes to set up, and where it breaks.

How the two channels fit together

phoneuse runs on two separate channels, and it helps to keep them apart in your head. The video channel is one-way: the iPhone sends its screen to the PC over AirPlay, and the PC decodes the H.264 stream with GStreamer and shows it in a GTK 4 window. The project uses UxPlay as its AirPlay receiver. The control channel runs the other way: the PC pretends to be a Bluetooth mouse and keyboard, and the iPhone accepts it through its normal Bluetooth stack.

That split explains most of the design. The iPhone never receives a special app or protocol. It sees a Screen Mirroring session and a Bluetooth pointing device, and it treats both as ordinary. The cost is that every input has to go through iOS's pointer logic, which is built for people with motor impairments, not for automation. You'll see that tension again below.

Setup: the parts that matter

The tested stack is narrow: an iPhone 17 Pro on iOS 26, Arch Linux with BlueZ 5.87, Hyprland 0.56, UxPlay 1.73.7, and an NVIDIA GPU. The README is clear that other setups will likely need fixes. If you're on a different distro or compositor, budget time for debugging.

Here's the install sequence from the project:

  1. Clone the repo and link the binary into your path, then run phoneuse install with sudo. This sets up the HID daemon as a phoneuse-hid service.
  2. Run phoneuse up, then on the iPhone open Control Center, tap Screen Mirroring and choose PhoneUse.
  3. Pair the phone's Bluetooth with the PC, or with a bridge (covered below).
  4. Turn on the pointer through AssistiveTouch.

Step 1 has a side effect most guides wouldn't mention. The install turns off bluetoothd's input plugin, which means your PC stops accepting Bluetooth keyboards and mice for itself. That's the intended behaviour, since the PC needs to act as a peripheral rather than a host, but it will surprise you if you pair your usual keyboard afterwards and wonder why nothing happens. To undo it, run sudo scripts/install.sh --uninstall.

The network side needs care too. The phone and PC must share a network, and a firewall needs these open:

  • TCP 7000, 7001 and 7100 for AirPlay
  • UDP 6000, 6001 and 7011 for AirPlay
  • UDP 47700 for the bridge
  • TCP 8778 for the companion app

If AirPlay connects but the picture never appears, a blocked UDP port is the usual culprit.

Turning on the pointer, and why calibration exists

The pointer comes from AssistiveTouch, and you can enable it two ways. Running phoneuse cursor on makes phoneuse play a spoken request through the PC's speakers and ask Siri to switch it on. Or you can open Settings › Accessibility › Touch › AssistiveTouch on the phone yourself.

Here's the part that trips people up. Dwell Control must stay off. When it's on, iOS taps wherever the pointer happens to stop, so a drag you intended as a swipe becomes a series of accidental taps. Most people stop here and assume the mouse just works. It doesn't, quite.

The first time you enable a phone's pointer, phoneuse spends about 13 seconds measuring how far the phone moves the pointer for each mouse report. Pointer acceleration and display scaling don't map linearly, so without this measurement, drags land in the wrong place. The project uses the measured ratio for drags. If you change your pointer speed on the phone, run phoneuse calibrate again. That's a cause-and-effect relationship worth remembering: change the phone's sensitivity, and your drags drift until you recalibrate.

Direct Bluetooth or the ESP32 bridge

You have two ways to connect the input channel, and the choice matters more than the README's brief mention suggests.

Direct mode uses the PC's own Bluetooth adapter. It's the simplest path: open Settings › Bluetooth on the iPhone and tap PhoneUse. The downside is physical. The PC has to stay in Bluetooth range of the phone, and the adapter is then busy with the iPhone link.

Bridge mode puts an ESP32 board next to the phone. The iPhone pairs with the bridge as its keyboard and mouse, and phoneuse sends commands to the bridge over Wi-Fi. The bridge is a LilyGO T-Display running ESP-IDF v6.1, and it can sit on a battery or charger beside the phone. The PC's Bluetooth stays idle.

FactorDirect PC BluetoothESP32 bridge
Setup effortPair once from iPhone settingsFlash over USB with ESP-IDF, then configure over the browser mirror
Hardware neededExisting PC Bluetooth adapterLilyGO T-Display (ESP32) plus ESP-IDF toolchain
Range constraintPhone must stay near the PC's adapterBridge sits beside the phone; PC only needs Wi-Fi reach
Reconnect behaviourPC-side pairing managementBridge reconnects to the phone by itself after a disconnect
Status visibilityStandard BlueZ toolingphoneuse bridge status reports address, connected phone, and round-trip message time

My practical advice: start with direct mode to confirm the whole chain works. Move to the bridge only when you need the PC in another room or want the phone's Bluetooth link to outlive your desktop session. The bridge adds a flashing step, a Wi-Fi dependency, and a second piece of hardware to debug. Those are real costs, and they're justified only if the portability matters to you.

Driving the phone from an agent

Beyond the mirror window, phoneuse exposes each action as a shell subcommand, and phoneuse --help lists them. A typical agent session looks like this:

phoneuse open Settings
phoneuse text
phoneuse tap-on "Wi-Fi"
phoneuse screenshot shot.png
phoneuse done

The text command prints the screen contents with positions, which is the piece that makes agent control practical. An agent reads the layout as text, picks an element by description, and taps it. The tap-on command resolves that description to coordinates, so the agent doesn't have to guess pixels.

The MCP server offers the same actions. After each action, it waits for the screen to stop changing before it returns. That detail matters more than it sounds: iOS animations would otherwise hand the agent a half-rendered frame, and it would act on a screen that's already gone.

There's one safety feature worth understanding. When an agent runs phoneuse unlock, phoneuse asks you first, with a banner in the browser mirror and a desktop notification. It types your saved passcode only after you approve. Here's the reasoning: an agent that can unlock your phone unattended can also read your messages, so the consent gate is the difference between a useful tool and a liability. Keep it on.

The browser mirror at http://localhost:8777 is only reachable from the machine itself. It's where you save the passcode, set up the bridge, and keep the screen awake.

Limits, failure modes, and what isn't tested

The honest picture is that this project has been run on one setup. The author's test matrix is one iPhone model, one iOS version, one Linux distribution, and one compositor. Anything outside that is an unknown until you test it. If your BlueZ version differs, the input plugin change and HID behaviour may differ too.

Three caveats deserve attention before you rely on it:

  • Gesture fidelity is limited by iOS. Edge swipes, such as dragging up from the bottom bezel to reach the home screen, work by pressing the bezel and dragging. The project documents which gestures work and why in docs/RECIPES.md. Don't assume a gesture works until you've checked that list.
  • Pointer sensitivity drifts. Calibration fixes the current ratio, not a permanent one. Change the phone's pointer speed without recalibrating and your drags will miss.
  • Bridge latency is measurable, not zero. The status command reports round-trip time for a message. Check it on your own Wi-Fi before trusting timed interactions like games or fast typing.

These are the kinds of limits you only find by running the thing. Plan for them rather than discovering them mid-task.

Frequently Asked Questions

can you control iPhone from Linux without jailbreak?

Yes. phoneuse uses AirPlay Screen Mirroring to see the iPhone's screen and the built-in AssistiveTouch pointer, with Bluetooth HID for input. It needs no jailbreak, developer account, cable or app on the phone. It's tested on iPhone 17 Pro with iOS 26 and Arch Linux, so other setups may need fixes.

what is phoneuse?

phoneuse is an open-source project that lets a Linux PC view and operate an unmodified iPhone. The iPhone streams its screen over AirPlay, and the PC sends taps and keystrokes back as a Bluetooth mouse and keyboard. It also provides a command-line interface and an MCP server so AI agents can drive the phone.

how do I stop the iPhone pointer from tapping by accident?

Keep Dwell Control off in AssistiveTouch settings. With Dwell Control on, iOS taps wherever the pointer stops, which turns drags into stray taps. If drags still land in the wrong place, run phoneuse calibrate to re-measure how far the phone moves per mouse report.

why does my iPhone pointer drift after I change its speed?

Calibration measures the ratio between mouse reports and pointer movement at one sensitivity setting. Change the phone's pointer speed and that ratio no longer holds, so drags miss their targets. Rerun phoneuse calibrate after any sensitivity change.

Control iPhone from Linux is practical today for people who are willing to tinker, and the design is clever: it works because the iPhone's accessibility features were built for pointer input. Start with a direct Bluetooth connection on a setup close to the author's, and confirm each step before adding the bridge. Then try phoneuse open Settings and phoneuse text this week, and note how closely the printed screen matches what you see in the mirror. Pass this to anyone wrestling with an iPhone they can't script from their desktop.