Moonlight iOS/tvOS: building the GameStream client for Apple devices

Moonlight iOS/tvOS and its streaming target

Moonlight iOS/tvOS addresses a specific distribution problem: a person wants to access games and applications running on a more powerful desktop computer through an iOS device or Apple TV. The repository describes its subject as a GameStream client and identifies both Sunshine and NVIDIA GameStream as compatible sources. That places the project on the receiving side of a streaming setup rather than making it a game host, a general-purpose remote desktop, or a local game engine.

The primary language is C, which is consistent with the repository structure shown by directories such as `Limelight/`, `libs/`, `X1Kit/`, and `moonlight-common/`. The project includes separate native targets for mobile and living-room devices. The top-level `Moonlight.xcodeproj/` is shared by those targets, while `Moonlight TV/`, `iPhone.storyboard`, `iPad.storyboard`, and `Launch Screen.xib` reflect platform-specific application resources.

The intended audience is split across two groups. End users need a client that can pair their Apple hardware with a desktop streaming source, although the README does not document that runtime procedure. Developers and packagers need the source, Xcode project, signing workflow, and license. This review keeps those roles separate because the repository confirms build instructions much more clearly than it documents day-to-day operation.

Sunshine and GameStream data flow in Moonlight

The documented architecture is straightforward at the product level. A desktop computer hosts the games and applications. Sunshine or an NVIDIA GameStream source exposes that host to the network. Moonlight for iOS/tvOS receives the stream on an iPhone, iPad, or Apple TV and presents it through a native client application.

The repository layout suggests a shared implementation with platform-specific shells. The repository entries include `moonlight-common/`, while `Moonlight TV/` provides a distinct tvOS-oriented area and the Xcode project contains separate Moonlight and Moonlight TV signing targets. The presence of `Limelight/` also points toward a streaming-oriented core, but neither the README nor the listed files explains its internal APIs, packet handling, video decoder, input transport, or pairing sequence. This review does not infer those details.

This boundary matters when evaluating the client. The repository does not document whether an Apple device acts as the display, input source, or both. It also does not provide host discovery settings, port requirements, codec choices, latency controls, or a troubleshooting matrix for Sunshine. The Moonlight wiki is linked for detailed setup and troubleshooting, so those operational questions need to be answered there rather than assumed from the source tree.

Xcode clone and recursive submodule setup

The README starts with Xcode, which must be installed from its App Store page. The repository can then be cloned with its recursive submodule option. Using `--recursive` matters because the project includes `.gitmodules`; the README gives a separate recovery command for clones that were created without those dependencies.

The following command downloads the repository and initializes its declared submodules:

git clone --recursive https://github.com/moonlight-stream/moonlight-ios.git

After the command completes, open `Moonlight.xcodeproj` in Xcode. If the repository was already cloned without recursive initialization, the documented repair command is:

git submodule update --init --recursive

The README does not give a command-line build invocation, dependency version matrix, simulator procedure, or deployment configuration. It instead directs the reader into the Xcode project. This makes Xcode the authoritative build path described by the project, and it also means a reproducible command-line build cannot be claimed from the available documentation.

Signing and launching the iOS and tvOS targets

Running on physical Apple hardware requires local signing changes. In Xcode, select the Moonlight project in the left sidebar, open `Signing & Capabilities`, and select the `Moonlight` target for iOS or iPadOS or the `Moonlight TV` target for tvOS. The `Team` control must contain the developer's Apple account identity. The README notes that an account may need to be signed into Xcode before its name appears.

Each local build also needs a unique `Bundle Identifier`. The README suggests adding the developer's name or random letters to the existing identifier. After those changes, the developer can select an attached Apple device in Xcode's top bar and press the Play button. The expected result is a local run on that device.

The documentation does not specify App Groups, capabilities, entitlements, background modes, controller access, or network permission changes beyond pointing to `Signing & Capabilities`. It also does not explain how to connect the launched application to a Sunshine or GameStream host. The App Store badge indicates that Moonlight has an App Store distribution, but the build section does not claim that cloning the source reproduces that store build. Developers should treat account signing, device selection, and host-side streaming setup as separate requirements.

Release history and the cost of maintaining an Apple client

The repository is not archived, and its last push was on 2026-09-26. That is recent activity, but the available release history does not show a corresponding stream of published versions. The listed releases are v0.9.2 from 2015-07-16, v0.9.0 from 2015-04-06, and v0.4.1 from 2015-04-06.

This creates a maintenance question that cannot be answered by repository activity alone. A recent push can represent source, CI, documentation, or compatibility work without producing a new tagged release. The README includes a CI badge for the `ci.yml` workflow, but it does not describe its checks or whether releases are automated. No changelog, support policy, Apple platform compatibility matrix, migration guide, or upgrade procedure is included in the repository documentation.

Moonlight iOS/tvOS is licensed under GPL-3.0. An organization distributing a modified or compiled version needs to review the applicable GPL-3.0 source availability, notice, and license obligations. This is not legal advice. The practical upgrade cost also includes checking the Xcode target settings, submodules, signing configuration, and the host-side Sunshine or NVIDIA GameStream arrangement. The linked Moonlight wiki is the first documented place to look for current setup and troubleshooting information.

Where Moonlight differs from the PC and Android clients

The README names a PC client, `moonlight-qt`, and an Android client, `moonlight-android`. Their existence gives Moonlight iOS/tvOS a clear alternative within the same client family, but the available text does not compare rendering backends, input support, network settings, or release histories.

The actual difference visible here is platform packaging and target environment. Moonlight iOS/tvOS contains an Xcode project with separate `Moonlight` and `Moonlight TV` targets, and its build instructions require Apple code signing for physical hardware. A PC or Android build would use that platform's own application and distribution model, but the README does not give commands for those projects. It would be inaccurate to claim that this client has better performance, broader codec support, or simpler setup than either alternative.

Moonlight iOS/tvOS is the relevant choice when the receiving endpoint must be an iOS, iPadOS, or tvOS device and the developer accepts the Apple build environment. It is the wrong choice for an Android or desktop endpoint, or for a user who needs the repository to document a complete host setup without consulting external Moonlight documentation.

Editorial conclusion

Developers who need an open source Moonlight client for an iOS or tvOS Xcode target can use this repository, especially when the required Apple signing and device setup are already available. Users seeking current release guidance, controller documentation, network troubleshooting, or confirmation of compatibility should inspect the linked Moonlight wiki first. Adoption also requires checking the GPL-3.0 obligations and understanding that the newest release listed here is v0.9.2 from 2015.

Frequently asked questions

Official sources

1. Issues
2. License: GPL-3.0
3. moonlight-stream/moonlight-ios on GitHub
4. README
5. Releases