OpenParsec: an open source Parsec client for iPhone and iPad

Why a third party client exists at all

OpenParsec is described as a simple, open-source Parsec client for iOS and iPadOS written in Swift using the SwiftUI framework and the Parsec SDK. The repository description adds the reason for its existence in one line: this repo implements mouse, keyboard and touch screen support.

That is the whole motivation. Parsec is a remote gaming and low latency streaming service, and its own iOS client is built around touch input, since the platform's primary use case is streaming games to a phone. A Mac user with a Bluetooth keyboard and mouse, or an iPad user who wants to work rather than play, needs input the official client does not surface. OpenParsec exists to add that layer.

So this is a companion client rather than a replacement for the service. The Parsec account, the host machine and the networking are all Parsec's; what changes is the client on the iOS side.

The author is direct about the state of the project. It is still a major WIP, with apologies for the currently lackluster documentation, and the author adds that they are very new to both Swift and SwiftUI and expects there are many places for improvement. That framing is useful to a reader deciding whether to try it, because it sets expectations correctly: this is a working experiment with a real feature set, not a product with documentation and support.

The project ships both an English and a Simplified Chinese readme, and the repository is under the hugeBlack organisation with the project named OpenParsec.

Installation by sideloading, not the App Store

There is no App Store listing, and the installation route explains why.

The readme offers two download paths through the AltStore ecosystem, an Add AltSource badge and a direct download of OpenParsec.ipa from the nightly release, both pointing at the releases/download/nightly paths.

That sideloading requirement is not a stylistic choice, it is what makes the app possible. Apple does not permit an app with this kind of input handling to distribute through the App Store, so a nightly build is the only channel. The trade-off for the user is that the app is not auto-updating from the App Store, and sideloading has a seven day expiry under AltStore unless it is re-signed, which is why the project publishes a nightly build rather than periodic App Store releases.

The repository supports this with an altstore.json file at the root and an update_json.py script alongside it, which is the standard pairing for an AltStore source: the JSON describes where the newest build lives and what to check against, and the script generates it.

For developers, the build requirement is explicit. Before building, make sure you have the Parsec SDK framework symlinked or copied into the Frameworks folder. The Frameworks/ directory is at the repository root and the .gitmodules file is there to pull in the SDK as a submodule, since the SDK binary is not something you can redistribute from the repository itself.

The readme notes that builds were tested on Xcode Version 12.5, which is an old toolchain by current standards and tells you something about the vintage of the code.

The top level entries are consistent with an Xcode project: OpenParsec.xcodeproj/ and the OpenParsec/ source directory containing the app and its asset catalogue, alongside the Frameworks/ directory for the SDK.

Two touch modes and a three finger keyboard

The touch control section is the most substantive part of the documentation, and it describes two distinct models rather than one.

You can set the touch mode you want to use in settings, and both touchpad mode and direct touch mode are supported. The distinction is the difference between a virtual trackpad that moves a relative pointer and a mapping where a touch is a click at that screen position. For a desktop or a game that expects absolute pointing, direct touch is the right mode; for a game with its own on-screen controls layered over the stream, touchpad is less intrusive.

Two gestures layer on top. When streaming, you can tap with three fingers to bring up the on-screen keyboard. And you can toggle whether two fingers scroll or zoom in the overlay menu.

The three finger keyboard gesture is the kind of thing that only becomes obvious once you have used it, and it solves a real problem. The alternative on iOS is to bring up the system keyboard, which covers the bottom of the screen and in a game means losing the controls you need to play.

Mouse and keyboard support is listed separately and simply: USB mouse and keyboard are supported. Given the SwiftUI and Parsec SDK basis, the implementation is presumably a virtual input device, which is the standard technique for this on iOS, but the readme does not describe the mechanism in detail.

The overlay menu is what those two finger gestures act on, and it is worth noting that it is a separate layer from the streamed content. That is how a client can offer its own settings, a virtual keyboard and a resolution or bitrate control without those controls appearing in the host machine's display.

Game controllers work, but the host has to cooperate

Game controller support comes with an explicit caveat that tells you exactly how much of the work is on your side.

When streaming, pressing any trigger button in your controller and parsec will recognize it. But you have to configure the host properly, and the readme names the requirement, install virtual USB driver etc.

That is the real cost of game controller support over a network client. The client can forward button presses, but the host has to believe a controller was plugged in, and on Windows that means a virtual USB driver presenting the device. Without it the input arrives at the host as an unknown device.

The consequence is that controller support is a two machine configuration rather than a client setting. You configure the host once, and the client then works. It is a reasonable design, since the alternative, emulating a controller entirely in the client, would be much harder to get right across the range of pads people own.

The readme also lists what the project does not cover for controllers, by implication: it is about button recognition, not about the per game profile mapping that a console client would provide.

Combined with the touch modes, this makes OpenParsec a client aimed at someone who is trying to play or work on a PC from an iOS device with peripherals, and who is willing to configure the host once.

The lag section is really a networking section

The troubleshooting section for lag is short and honest, and it does not blame the app.

If you encounter lags from nowhere, or your bitrate hardly goes over 10 Mbps, the advice is to download Steam Link and do a network test. If you see a constant lag spike in the graph, then it is a problem with Apple and there is little that can be done about it, with a link to a discussion on the moonlight-ios issue tracker.

That last part is worth sitting with. The author of an alternative client is telling you that some of the problems you will have are Apple's, and pointing you at the Moonlight iOS issue tracker where that is discussed, rather than at their own code. It is the correct attribution, because the bitrate and the frame pacing are decided by the system and the network path, not by the client layer.

There is also a piece of personal experience in the readme that is genuinely useful. If you cannot change your wireless router's channel to 149, the suggestion is to power off the device you are streaming from and any nearby Apple devices, especially Mac, then power on only the streaming device and repeat the network test. If you turn the other devices back on and the lag spikes return, it may sustain for a couple of hours or days.

That is a wireless interference diagnosis, and the fact that it is in the readme at all tells you the project has been field-tested against real network problems. It also tells you the client cannot fix a congested 2.4 GHz or crowded 5 GHz environment.

The last irony is worth naming. The documentation for the lag problem points you at Steam Link, which is the other major remote streaming client, as a diagnostic tool.

Where OpenParsec is the wrong choice

Three cases, and the first one decides most of them.

If you want an iOS streaming client that just works and updates itself, this is the wrong project. There is no App Store release, the build comes from a nightly, and the sideloading renewal cycle means you will be reinstalling it. The App Store version of Parsec exists, is supported, and if your use is touch based gaming it is likely sufficient.

The second case is when you need reliability more than input flexibility. The project describes itself as a major WIP with lackluster documentation from an author new to Swift and SwiftUI. That is a reasonable person being honest, and it means bugs will surface in ways the App Store client will not, and that you are the person who reports and diagnoses them.

The third case is if you are on Android or another platform. The project is iOS and iPadOS only, and the repository language is Swift. If your streaming device is an Android phone, this is not an option.

The alternatives differ in what they change. The official Parsec iOS client is the supported route and is what most people should use; OpenParsec exists because of a gap in it, and if the gap does not affect you the gap is the only reason to switch. Moonlight iOS is the open source client in the same space, and the link to its issue tracker in this readme is an acknowledgement that it is the reference point for network troubleshooting on the platform. And a streaming setup that avoids the iOS client entirely, a host on wired ethernet with a Steam Link or a dedicated client on another device, sidesteps the question of which iOS client to install.

What OpenParsec actually adds is the input layer. Mouse, keyboard, touchscreen with a proper touchpad or direct model, and controllers, on hardware Apple does not want to run that kind of client from the App Store.

Editorial conclusion

OpenParsec suits an iPhone or iPad owner who streams a PC through Parsec and needs mouse and keyboard control that the official iOS client lacks, and the touch control modes and game controller support are the features that justify sideloading. It does not suit anyone who wants a stable App Store release, since it is distributed through AltStore with a nightly build and the author describes it as a major work in progress with lackluster documentation. Before installing, read the network section, because the documented lag advice points at wireless interference and Apple's own client as the usual culprits rather than at the app.

Frequently asked questions

Official sources

1. hugeBlack/OpenParsec on GitHub
2. Issues
3. License: GPL-3.0
4. README
5. Releases