Dawn Stream getting started

Run a local Dawn Stream loop: signaling → GameLauncher streamer → reference browser player. No level components are required; enable the Gem and the system component activates automatically.

Prerequisites

Project has the DawnStream Gem enabled (Project Manager or project.json / gem.json dependency).
Node.js ≥ 22.6 for the reference signaling server (Gems/DawnStream/Signaling).
For real video (not just signaling/input): a profile/release build with Route A or Route B CMake gates—see Building for real media. Default builds use the stub adapter.
Tokens injected via environment variables (never on the CLI or committed to git).

Three-step loop

1 Start signaling → 2 Launch streamer → 3 Open reference player

1. Start signaling

cd Gems/DawnStream/Signaling
node src/main.ts --port 8090

Health check: open http://127.0.0.1:8090/healthz (expect a healthy JSON response). Ready probe: /readyz.

Set signaling-side tokens before (or when) starting the process:

$env:PS_STREAMER_TOKEN = "<streamer-token>"
$env:PS_VIEWER_TOKEN = "<viewer-token>"

More flags and embedded mode: Signaling.

2. Enable the Gem and start the streamer

Enable DawnStream for the project, then set the streamer token and launch:

$env:DAWNSTREAM_AUTH_TOKEN = "<streamer-token>"

MyProject.GameLauncher.exe --dawnstream-enabled --dawnstream-mode AlwaysStreaming `
 --dawnstream-signaling-url ws://127.0.0.1:8090 `
 --dawnstream-width 1280 --dawnstream-height 720 --dawnstream-fps 30

Notes:

Prefer 720p / 30 fps for demos (--dawnstream-width/height/fps or setreg).
OnDemand mode: start with --dawnstream-mode OnDemand, then run console ps_startStreaming when ready.
Persistent settings live under /Dawn Engine/DawnStream/ (defaults: Gems/DawnStream/Registry/dawnstream.setreg). Full tables: Configuration.
Auth tokens are not accepted via --dawnstream-* CLI for the streamer secret; use DAWNSTREAM_AUTH_TOKEN (or Signaling.AuthTokenEnv).

3. Open the reference player

cd Gems/DawnStream/Frontend
npm install && npm run build
# Serve the build folder with any static file server, then open:
# http://localhost:<port>/player.html?signaling=ws://127.0.0.1:8090&token=<viewer-token>

Minimal URL params: signaling, token. Optional: streamer, autoConnect, hideUI, forceTurn, preferredCodec. Full list: Browser and input.

Acceptance checklist

Check	Stub build	Real-media build
Signaling `/healthz` OK	Required	Required
Streamer connects / registers	Required	Required
Player joins session	Required	Required
Video visible in browser	No (black / no track is expected)	Yes
Mouse / keyboard moves the game	Yes (if focused Input Owner)	Yes
`ps_dumpStats` shows session / input counters	Yes	Yes; also non-zero `capFps` / `sendFps`

Console: ps_dumpStats (see Diagnostics). On success with real media you should see capture and send FPS climbing; with stub, media FPS stay at zero while input accept counters can still increase.

Behavior without real media (stub)

If LY_DAWNSTREAM_LIBWEBRTC_ENABLED and LY_DAWNSTREAM_WEBRTC_NATIVE_ENABLED are both off (the default), the engine loads StubWebRtcPeerAdapter:

Auth, register, join, SDP/ICE plumbing, DataChannel, and remote input still run.
No encoded video frames are produced—suitable for protocol and integration debugging.
To see pixels, follow Building for real media and rebuild.

Optional: Editor and embedded signaling

Editor can set Editor.StartOnLaunch=true and use in-process signaling when Editor.UseRemoteSignaling=false (default). Details: Signaling and Configuration.
GameLauncher demos usually use the standalone Node signaling process above.

Next steps

Building for real media — enable Route A or B and confirm video.
Signaling — WSS, tokens, embedded vs standalone.
Configuration — setreg / CLI reference.
Diagnostics — if the loop fails.