How do I run Unreal Engine Pixel Streaming on a cloud GPU?
Written by the CloudGPU team. CloudGPU is an independent GPU rental service and is not affiliated with Epic Games. Port numbers and script names change between Pixel Streaming versions, so check them against Epic’s documentation for your Unreal Engine version.
Short answer: Package a build with the Pixel Streaming plugin enabled, upload it to an RTX 4090 or RTX 5090 instance (both have NVENC), start the Pixel Streaming signalling server, launch the build with -RenderOffscreen pointing at it, and make sure viewers can reach both the web page and the WebRTC media path (directly or through TURN). This is for prototypes and small demos.
What Pixel Streaming is
Pixel Streaming runs your packaged Unreal application on a GPU machine, encodes the frames with the GPU’s hardware encoder, and sends them to a browser over WebRTC. Input from the browser (mouse, keyboard, touch) goes back to the app. Your viewer needs nothing but a browser.
A rented GPU makes sense when you want a stakeholder, client or playtester to try a build without installing anything, and you don’t want to leave your own workstation on and exposed.
Scope: prototypes and small demos
This guide covers one GPU, one app instance, a handful of viewers: product configurators, architectural walkthroughs, pitch demos, review sessions. Large public launches need matchmaking, multiple instances and a selective forwarding unit (SFU). That is beyond this guide, and not something we position a single rented card for.
Requirements
- NVIDIA GPU with NVENC. Pixel Streaming uses hardware encoding; the RTX 4090 and RTX 5090 tiers on /deploy include NVENC.
- A packaged Linux build with the Pixel Streaming plugin enabled.
- Your own Unreal Engine install/account to package the build (usually on your own machine).
- The Pixel Streaming infrastructure (signalling server and web frontend) matching your UE version, distributed by Epic through its Pixel Streaming infrastructure repository.
- Node.js on the instance for the signalling server.
Package the build
On your machine:
- Edit → Plugins → enable Pixel Streaming (newer engine versions also ship Pixel Streaming 2; use the one your UE version documents). Restart the editor.
- Optional but recommended: in Project Settings, set a sensible default resolution and frame-rate cap for streaming (for example 1920×1080, 30–60 fps).
- Platforms → Linux → Package Project.
- Archive the packaged folder.
Open a GPU and upload
Open an RTX 4090 or RTX 5090 instance from /deploy (card or USDT; see /payments). Then:
rsync -avz --progress ./PackagedBuild/ user@<instance-host>:~/ps/app/
ssh user@<instance-host>
nvidia-smi # confirm the GPU and driver are visible
Clone or copy the Pixel Streaming infrastructure for your UE version into ~/ps/infra/.
Start the signalling server
From the infrastructure folder, use the platform start script (names vary by version):
cd ~/ps/infra/SignallingWebServer/platform_scripts/bash
./start.sh
By default the signalling/web server listens on an HTTP port for viewers (commonly 80) and a streamer port the UE app connects to (commonly 8888). Check the startup log or config for the actual values in your version.
Run it in tmux so it survives SSH disconnects.
Launch the build headless and connect it
In a second tmux pane:
cd ~/ps/app/Linux
./MyProject.sh \
-RenderOffscreen \
-PixelStreamingURL=ws://127.0.0.1:8888 \
-ResX=1920 -ResY=1080 -ForceRes \
-Unattended -log
-RenderOffscreen: no display needed.-PixelStreamingURL: where the app finds the signalling server (older versions used-PixelStreamingIP/-PixelStreamingPort).
The signalling server log should show a streamer connecting.
Ports and networking
This is where many cloud Pixel Streaming setups break. Pixel Streaming uses several kinds of traffic:
| Traffic | Typical port / protocol | Who needs to reach it |
|---|---|---|
| Web page + signalling for viewers | HTTP/HTTPS, commonly 80 / 443 (TCP) | Viewers’ browsers |
| Streamer ↔ signalling | commonly 8888 (TCP, WebSocket) | Only the UE app; keep it on localhost |
| SFU (if used) | commonly 8889 (TCP) | Only internal components |
| WebRTC media | UDP, dynamic range negotiated via ICE | Viewers’ browsers (directly, or via TURN) |
| STUN / TURN | 3478 (UDP/TCP), TURN over TLS on 443 | Viewers’ browsers |
What you can do depends on which ports your instance exposes. Check the instance details on the dashboard for the ports available to you.
- Ports are exposed to viewers: open only the viewer HTTP(S) port and the UDP range or TURN port you need. Keep 8888 bound to localhost.
- Only SSH is reachable: an SSH tunnel (
ssh -L 8080:127.0.0.1:80 user@<instance-host>) can carry the web page and signalling for your own testing, but WebRTC media still needs a reachable path. Run a TURN server (for example coturn) on a port the instance exposes, and point the infrastructure’s peer connection config at it. - Viewers behind strict corporate networks: TURN over TCP/TLS on 443 is a common fallback.
Latency depends on the network distance between the GPU and your viewers. Test from where your viewers actually are before a live demo.
Security
A Pixel Streaming URL gives anyone who opens it control of your app’s input.
- Don’t publish the raw URL; share it only with invited reviewers.
- Put the web frontend behind basic authentication or a reverse proxy with auth.
- Use HTTPS/WSS for anything beyond your own testing.
- Never expose the streamer port (8888) publicly.
- Don’t store credentials, API keys or TURN secrets in the packaged build or in the frontend JavaScript.
- Destroy the instance when the demo ends.
Test from a browser
Open http://<instance-host>/ (or your tunnelled http://localhost:8080/), click to start, and check:
- The stream starts and input works
- Resolution and frame rate hold under interaction
chrome://webrtc-internalsshows the candidate type (host/srflx/relay) and bitratenvidia-smishows the encoder busy and VRAM headroom
If it doesn’t work
| Symptom | Likely fix |
|---|---|
| Page loads, stream never starts | Media path blocked: open the UDP range or configure TURN |
| “No streamer” in the frontend | App not connected; check -PixelStreamingURL and the signalling log |
| App crashes on start | Missing -RenderOffscreen, a driver issue, or missing Linux dependencies |
| Encoder errors | Confirm NVENC is visible to the app; check the driver version against your UE version’s requirements |
| Laggy input | Network distance or relay through TURN; lower resolution/bitrate; test closer to viewers |
| Works for you, not for the client | Their network blocks UDP; use TURN over TCP/TLS 443 |
Destroy the instance; next steps
Destroy the instance when the review is over. Billing is per minute and stops when the instance is destroyed.
- Final frames instead of live: Movie Render Queue on a rented CloudGPU
- Overview: Cloud GPU for Unreal Engine
- AI previs and film pipeline: Cloud GPU for AI video production
Open a GPU · Card or USDT; see /payments.