NowPlaying.iOS

A native App*eMusic-style Now Playing client for legacy iOS devices.

한국어 · NowPlaying.NET server

NowPlaying.iOS turns an older iPad into a dedicated full-screen Now Playing display for media playing on a Windows PC. It connects to NowPlaying.NET, receives track metadata, artwork, playback state, and timeline data, and renders them through a native UIKit interface designed for iOS 9-era hardware.

The project is developed separately from the Windows server. NowPlaying.NET must be running on a PC on the same network for this client to operate.

Highlights

• Native client for iOS 9 and later, with the iPad 3 as the primary target
• App*eMusic-inspired full-screen player interface
• Track title, artist, album, artwork, playback state, and timeline display
• Local progress interpolation between server updates
• GPU-accelerated animated background using GLKit and OpenGL ES 2.0
• Artwork texture updates only when the current track changes
• Smooth GPU crossfade on artwork changes
• Runtime-configurable NowPlaying.NET server address
• No CocoaPods or third-party runtime dependencies
• Built specifically to remain usable on legacy 32-bit iOS hardware

Relationship with NowPlaying.NET

The two repositories form one client-server system:

Windows media application
        │
        ▼
Windows GSMTC
        │
        ▼
NowPlaying.NET server
  http://PC-IP:9864
        │
        ├── Web browser client
        │
        └── NowPlaying.iOS native client
                │
                ▼
          iOS 9 iPad / iPhone

NowPlaying.NET reads the active Windows media session through GSMTC and exposes the current state over its HTTP API. NowPlaying.iOS polls that API, renders the player locally, and interpolates the playback timeline between responses.

This repository contains only the iOS client. Download and run the server from the separate NowPlaying.NET repository.

Requirements

iOS device

• iOS 9.0 or later
• Primary target: iPad 3 with Retina display
• A network connection to the PC running NowPlaying.NET

Build environment

• macOS capable of running a compatible Xcode version (macOS Monterey 12.7.6 for Xcode 13.4.1)
• Xcode 13.4.1 or earlier with armv7 support
• An Apple signing identity, or an alternative installation method for unsigned applications

Modern Xcode releases no longer support building armv7 applications for iOS 9. Use a compatible legacy Xcode environment when targeting 32-bit devices such as the iPad 3.

Getting started

1. Start the Windows server

Install and launch NowPlaying.NET on the Windows PC that plays the media.

Verify that the server is reachable from the local network:

http://PC-IP:9864/api/v1/health

Replace PC-IP with the LAN address of the Windows PC, for example:

http://192.168.11.20:9864/api/v1/health

Windows Defender Firewall may need an inbound TCP rule for port 9864 on private networks.

2. Open the Xcode project

Open the project file included in this repository:

NowPlaying.iOS.xcodeproj

Select the application scheme and an iOS device or Generic iOS Device destination.

3. Configure signing

The project may be distributed with signing disabled. Configure your own development team and signing identity in Xcode when installing through the standard development workflow.

For jailbroken or otherwise externally managed legacy devices, use the installation method appropriate to that environment.

4. Configure the server address

Set the address of the PC running NowPlaying.NET from the settings control in the upper-right corner of the player.

Use the complete base URL:

http://192.168.11.20:9864

The selected address is stored locally with NSUserDefaults and reused on the next launch.

The device and server should normally be connected to the same trusted LAN. Do not expose the unauthenticated NowPlaying.NET control API directly to the public internet.

Building

Build the Release configuration from Xcode, or use the included command-line build script when available:

./scripts/build-unsigned-ipa.sh

A normal device build produces the application under Xcode's Derived Data directory:

~/Library/Developer/Xcode/DerivedData/.../Build/Products/Release-iphoneos/

The unsigned IPA script wraps the generated .app in the standard Payload directory structure. It does not provide code signing or install the application on a device.

Rendering architecture

NowPlaying.iOS separates the animated background from the high-resolution player controls to remain practical on the iPad 3 GPU.

• Background: one opaque GLKView rendered with OpenGL ES 2.0
• Background frame rate: 60 fps by default
• Background drawable: 1024 × 768 through contentScaleFactor = 1.0
• Player UI and artwork: native Retina UIKit layers
• Artwork texture: 128 × 128, uploaded only when artwork changes
• Background motion: continuously updated texture transforms without a visible keyframe loop boundary
• Track transition: GPU texture crossfade
• Networking: periodic /api/v1/state polling with local timeline interpolation

This hybrid approach keeps text and controls sharp while reducing fill-rate and memory-bandwidth pressure from the animated background.

Performance tuning

Important visual and performance constants are centralized in the project constants header. Typical options include:

NPBackgroundFrameInterval
NPBackgroundContentScale
NPArtworkTextureSize
NPBackgroundMotionSpeed
NPBackgroundSaturation
NPBackgroundBrightness
NPBackgroundVignette
NPArtworkCrossfadeDuration
NPPlayerWidthByHeight
NPPlayerMaxWidthByScreen
NPTopMarginByHeight
NPBottomMarginByHeight

For an iPad 3, the recommended starting point is:

Background: 60 fps
Background content scale: 1.0
Artwork texture: 128 × 128

Rendering the animated background at full Retina resolution or 60 fps substantially increases GPU fill-rate and memory-bandwidth requirements.

Server API usage

The client primarily consumes the versioned NowPlaying.NET endpoints:

GET /api/v1/health
GET /api/v1/state
GET /api/v1/artwork

The server remains the source of truth for track metadata and playback state. The client locally advances the displayed timeline between successful state responses to avoid visibly stepping progress updates.

Troubleshooting

The app cannot connect to the server

• Confirm that NowPlaying.NET is running.
• Open /api/v1/health from another device on the same network.
• Verify the PC's LAN address and port 9864.
• Allow TCP port 9864 through Windows Defender Firewall for private networks.
• Check whether client isolation is enabled on the wireless access point.
• Avoid entering localhost; on the iOS device, localhost refers to the device itself.

The project does not build in a recent Xcode release

The deployment target and armv7 architecture require an older toolchain. Build with Xcode 10.3 or another compatible Xcode version that still supports 32-bit iOS targets.

Background animation is slow

Keep the background at 30 fps and a content scale of 1.0. Do not raise both frame rate and drawable resolution on your device unless the performance impact has been measured.

Artwork or metadata does not update

Verify the NowPlaying.NET web player first. If the server does not show the current media session, the issue is on the Windows/GSMTC side rather than in the iOS renderer.

Security

NowPlaying.NET is intended for trusted local networks and exposes media information and playback controls without user authentication. Use NowPlaying.iOS only over a trusted LAN or a private VPN.

Do not directly port-forward the server to the public internet.

Related project

• NowPlaying.NET — Windows GSMTC server and browser-based player

License

NowPlaying.iOS is distributed under the MIT License.