Documentation

Put the Player on your screen

Install the screenRIG Player on the screen, keep it running, and let your agent publish the content. The same Player shows ordinary content and paid advertising for accounts that opt in; buyers pair nothing.

Which Players are available?

Players: the Player web app (PWA), Android on Google Play, Amazon Signage Stick, Apple TV, macOS, iPhone and iPad, Windows, Linux and Raspberry Pi packages, LG webOS Signage, BrightSign, and Samsung Smart Signage (Tizen). Install a native Player for the fastest, most reliable playback.

The Player web app (PWA) at play.screenrig.ai/player/ runs on any screen with a modern browser: a smart TV or commercial display with a built-in browser, a managed ChromeOS device in kiosk mode, a tablet, or a computer plugged into the screen.

Every Player shows a pairing code. Give it to your agent, and it takes it from there.

Every Player except Windows also shows a QR code on its pairing screen. Scan it with a phone signed in to the dashboard and confirm Pair screen.

Every Player's own text follows the device language: English, Canadian French, Spanish, German, Brazilian Portuguese, Italian, Japanese or Simplified Chinese.

Primitive support by platform

Compare the six content primitives across Player platforms.

Six content types, compared across Player platforms
Player platformImageVideoStreamIframeApplicationCard
Web / PWAYesYesHLSYesYesYes
Android (standard)YesYesHLS + RTSP + multicast¹YesYesYes
Android (amazon flavor)YesYesHLS + RTSP + multicast¹YesYesYes
Linux (Qt, x86_64 artifact)YesYesHLS + RTSP + multicast¹YesYesYes
macOSYesYesHLSYesYesYes
Apple TV / tvOSYesYesHLSNoNoYes
WindowsYesYesHLSYesYesYes
Samsung Smart Signage (Tizen)YesYesHLSYesYesYes
LG webOS SignageYesYesHLSYesYesYes
BrightSignYesYesHLSYesYesYes

¹ Direct UDP/MPEG-TS multicast is optional and must be enabled on Android or Qt. It requires a network that carries the multicast group to the Player. Other Players use HLS; a multicast source can include an HLS alternative.

The Raspberry Pi package is the same Qt Player (Linux aarch64) and has the Linux row's support. On a Linux or Raspberry Pi device with 1 GB of memory, iframes and applications do not play; see Memory.

Apple TV supports images, video, HLS streams, and cards. It cannot display iframe web pages or packaged web applications. screenRIG still publishes a playlist that holds either and marks the screen applications_unsupported; Apple TV does not play that playlist and keeps playing the last playlist it accepted. iPhone and iPad play images, video, HLS streams, cards and soundtracks; web pages and applications need another Player.

An iframe src can be any YouTube video, Shorts, live, playlist or youtube.com/channel/UC…/live link. screenRIG stores it as an embed that autoplays, loops and hides YouTube's controls. Every Player plays it with sound where the screen's browser allows sound, and the Player web app mutes it when the browser refuses; add mute=1 to the link to mute it everywhere. Set the page's advance to {"mode":"duration","after_ms":30000,"until":"video_end"} and the page lasts until the video ends (a page with exactly one YouTube video; a playlist or live stream has no end); after_ms is how long it shows when the screen cannot read the video's length.

Every Player platform above also plays the playlist soundtrack. The Player web app starts it once the browser allows sound; see Soundtracks.

Pages on the screen's network

An application and an iframe page can call devices and servers on the screen's own network, such as a controller at http://192.168.1.20. Each Player reaches these addresses:

Addresses on the screen's network that applications and iframe pages reach, by Player
PlayerApplicationIframe page
Android, Amazon Signage Stick, Windows, Linux and Raspberry Pihttp://, https://, ws:// and wss:// addressesThe same
macOShttp://, https://, ws:// and wss:// addressesA page with an https:// address reaches https:// and wss:// addresses; a page with an http:// address reaches http:// and ws:// addresses
Web / PWAWherever the browser allows itWherever the browser allows it
Samsung Smart Signage (Tizen), LG webOS Signage, BrightSignhttps:// and wss:// addresseshttps:// and wss:// addresses

On macOS, give a device that serves plain http, or one with a self-signed certificate, as the iframe's own http:// address: the page is framed, and its http:// and ws:// requests work. On Samsung, LG and BrightSign, serve a device on the screen's network over https:// or wss://.

The Player web app hands the browser's Local Network Access permission to the frames of applications and iframe pages alike, so the browser's owner decides what a page reaches. On Chrome and Edge 142 and later, set the enterprise policy LocalNetworkAccessAllowedForUrls to https://play.screenrig.ai: private IP addresses and .local names then load over http and ws, fetch and images included. For other http:// host names, also set InsecureContentAllowedForUrls to https://play.screenrig.ai, or choose Insecure content: Allow in the site settings: images and ws then load, and fetch also needs the browser started with --allow-running-insecure-content. Address the server by IP address or .local name to avoid both. The policies name the Player page, not the page's address. Reach devices on the screen's network covers pictures and CORS.

Eventual sync

Android, Amazon Signage Stick, macOS, Windows, Linux, Raspberry Pi and BrightSign Players gradually align page changes with nearby Players showing the same playlist revision. Assign the same playlist to screens on one IPv4 subnet. Use fixed page durations of at least one second, cut transitions, no entrance animations, no visibility rules and no ad slots. Each Player broadcasts one small page-start beacon and makes a tiny adjustment to its wait before the next page. Timing adjustments activate only after a second Player on that same playlist revision is discovered. Screens on different playlists do not influence one another. A lone screen keeps its normal playback timing; the group follows the median playback position once peers join.

The network must allow device-to-device UDP broadcast on port 49817, and for BrightSign groups on port 49818 too. Allow local-network access when the device asks. Screens keep playing through packet loss, power cycles and network partitions, and converge again as page beacons arrive. Each added wait is capped at 40 milliseconds. Long pages and large timing differences take longer to converge; this synchronizes page changes rather than video frames or soundtracks.

To bring a location close together quickly, ask your agent to restart playback on its screens with screen reload --tag LOCATION, replacing LOCATION with their shared tag. The Players restart eligible playlists at the first page and finish alignment through their regular beacons. Pairing and downloaded content stay in place.

Install a native Player

Where to get each native Player
PlatformGet the Player
Android TVs, tablets, and signage boxes (Android 9 or later)Google Play or the Android APK
Amazon Signage StickSelect screenRIG during setup
Fire TV Stick (Fire OS)Amazon Appstore
Apple TV (tvOS 17.5 or later)App Store
macOS (14.5 or later)Mac App Store
iPhone and iPad (iOS and iPadOS 17.5 or later)App Store
Windows (Windows 10 version 1809 or later, or Windows 11)Microsoft Store
Linux (x86_64)Linux package from screenrig.ai/linux/
Raspberry Pi (64-bit)Raspberry Pi image or Linux aarch64 package from screenrig.ai/linux/
Samsung Smart Signage (Tizen)Native Player
BrightSignscreenrig.ai/brightsign/
LG webOS Signage (6.0 or newer)screenrig.ai/webos/

Every download is also on the Downloads page.

  1. 01

    Install the Player for your screen device.

  2. 02

    Launch it. It opens full screen and shows a pairing code.

  3. 03

    Give the pairing code to your agent. It pairs the screen and publishes to it.

Each native Player downloads media once, caches it, and replays it from local storage.

Install the Android APK

Use the APK on Android TVs, Google TV devices, tablets, and signage boxes on Android 9 or later that do not use Google Play. Use it when you install by ADB.

The APK is signed and public. It is the same Player as the Google Play build. Its file name carries the version, so use https://screenrig.ai/android/manifest.json as the only pointer to the current file.

Before you start, turn on developer options and USB debugging or network debugging on the device. You also need adb on your computer.

  1. Connect to the device. For a network device, run adb connect DEVICE_IP:5555.

  2. Download, check, and install the APK:

    Download, check, and install the APK
    curl -fsSL https://screenrig.ai/android/manifest.json -o manifest.json
    path=$(jq -r .player.path manifest.json); sha=$(jq -r .player.sha256 manifest.json)
    curl -fsSLO "https://screenrig.ai$path"
    echo "$sha  ${path##*/}" | sha256sum -c -
    adb install -r "${path##*/}"
    adb shell am start ai.screenrig.player
  3. The Player opens full screen and shows a pairing code. Give the code to your agent.

Start at boot

Start on boot is on by default. It is a switch in Player Settings: once the screen is paired, press OK on the remote to open the menu and choose Player Settings. On Android 9, no permission is needed. On Android 10 and later, grant Display over other apps unless the device is device-owner managed: select Start on boot and follow its prompt. Where a permission screen is available, the Player asks when it first shows its pairing code: select Open settings and allow Display over other apps. Until the permission is granted the row reads Permission required and the Player does not start at boot. You can also grant it with ADB:

Start at boot
adb shell cmd appops set ai.screenrig.player SYSTEM_ALERT_WINDOW allow

On Fire OS 8, use ADB to grant this permission; its settings screen does not provide it.

Screensaver

On Android TV and Google TV, screenRIG is one of the TV's screensavers. Open Screen saver in the TV's Settings and select screenRIG. When the TV would start its screensaver, the Player comes to the front and plays your content. No permission is needed.

Home screen

Turn on Home screen in Player Settings and screenRIG becomes what the device shows when it goes home: the Home button, a restart and the end of the screen saver all return to it. It is off by default and is offered on the Google Play and APK builds. Android asks you to confirm the choice where it lets an app be the home app. Where the TV's own launcher outranks any chosen home app, as on Google TV, the Player instead comes back to the front 1.5 seconds after anything it did not open takes the screen, and that needs Display over other apps, as Start on boot does. Turn Home screen off to give home back to Android.

Updating

Run the install steps again. Android installs the newer version over the installed one and keeps your pairing. It refuses an older version.

Google Play

The APK and the Google Play build share package ai.screenrig.player. If the Google Play build is installed, uninstall it first. Pair the Player again after you install the APK.

Linux and Raspberry Pi

The Linux Player is one self-contained package for 64-bit Linux, built for x86_64 PCs and for aarch64 boards such as the Raspberry Pi. Qt, Qt WebEngine and GStreamer are inside the package. The machine needs the glibc version listed for its architecture at screenrig.ai/linux/, a Wayland session or the cage kiosk compositor, and its own GPU drivers, fonts, CA certificates and audio service. Video decodes on the GPU: VA-API on Intel and AMD, NVDEC on NVIDIA and V4L2 on Raspberry Pi and other ARM boards.

Install it with the installer, which picks the build for the machine and verifies the download against the signed release manifest:

Quick install
curl -fsSL https://screenrig.ai/linux/install.sh | sh

On a dedicated screen, add --kiosk (sh -s -- --kiosk) to start the Player at boot inside cage under a systemd service. Run the installer again to upgrade, or with --uninstall to remove it. --prefix DIR installs somewhere other than /opt/screenrig-player, and a prefix under your home directory needs no sudo. --kiosk-user USER names the account the kiosk runs as. Manual install: download screenrig-player-linux-x86_64.tar.gz or screenrig-player-linux-aarch64.tar.gz from screenrig.ai/linux/, extract to /opt/screenrig-player, and run /opt/screenrig-player/screenrig-player. The signed release.json in the same directory lists each archive's size and SHA-256. --fleet-link URL joins your project with a fleet link, with no pairing code. --manage-host adds the Device Configuration menu to a --kiosk install.

Without --kiosk the Player runs as a window on your desktop and leaves the machine to you: it offers no remote reboot, video wall or rotation, so screen reboot and screen wall set refuse it. A --kiosk install gives the machine to the Player for them, and --manage-host adds Device Configuration.

Debian 13, Raspberry Pi OS (trixie, 64-bit), Ubuntu, Fedora and Arch Linux run the Player when they meet the package's glibc requirement. Debian 12 and Raspberry Pi OS bookworm ship an older glibc; upgrade them first. Per-distribution packages for a kiosk install are in the Linux download notes.

Memory

The Linux Player needs 1 GB of memory, and 2 GB is recommended. What a screen plays depends on its memory:

MemoryPlays
2 GB or more (recommended)Everything in the Linux row of Primitive support by platform: images, video including 4K, cards, streams, audio, web applications and web pages
1 GB (minimum)Images, video up to 1920 × 1080, cards, streams and audio
Less than 1 GBNothing. The Player shows on screen that the device does not have enough memory

With 1 GB, the Player skips each web application, web page and video above 1920 × 1080, writes a warning to the screen's Player log, and plays the rest of the playlist. A Raspberry Pi 4 plays HEVC up to 1080p60; a Raspberry Pi 5 plays HEVC up to 4K60.

Raspberry Pi

The screenRIG Player image is a ready-made card for a Raspberry Pi 4 or 5 (64-bit, one image for both). It is an appliance: it boots straight into the Player full screen, with no desktop and no login. The system is read-only and comes in two copies, so the Pi updates it by itself and goes back to the previous copy if an update fails. The Player updates itself every hour and rolls back a release that does not connect. The Pi keeps no logs and writes almost nothing to the card. Download screenrig-player-rpi-arm64.img.xz, or flash it with Raspberry Pi Imager: start Imager with the screenRIG list.

Start Raspberry Pi Imager
# Linux
rpi-imager --repo https://screenrig.ai/linux/rpi-imager.json
# macOS
open -a "Raspberry Pi Imager" --args --repo https://screenrig.ai/linux/rpi-imager.json
# Windows (Command Prompt)
"C:\Program Files\Raspberry Pi Ltd\Imager\rpi-imager.exe" --repo https://screenrig.ai/linux/rpi-imager.json
  1. Choose your Raspberry Pi model, then screenRIG Player, then the card.
  2. Skip Imager's customisation step: its hostname, Wi-Fi, user and SSH settings do not apply to this image.
  3. Write the card, put it in the Pi and power it on.

To use the downloaded file instead, open Imager as usual and choose Use custom.

On first start the screen shows a pairing code: give it to your agent. Connect Ethernet, or set Wi-Fi and the time zone on the screen in Device Configuration, which also sets Displays and more.

While the Player or the Raspberry Pi system updates in the background, playback carries on, with a small update icon in the screen's bottom-left corner and a short notice in the status band at the bottom. Just before it restarts, the screen says so for a few seconds: a Player update restarts the Player and the picture returns after the startup animation, and a system update restarts the Raspberry Pi, which takes about a minute. Afterwards the screen says once, briefly, "Player updated to 26.11.3" or "System updated", or, if the new version did not reach screenRIG and the Pi went back to the previous one, that the update did not start and the screen is on the previous version.

Optional files on the card's first partition, the one a PC can open (named BOOTCONFIG), set the Pi up:

  • screenrig-fleet-link holds your fleet link URL. The Pi joins your project by itself, with no pairing code.
  • screenrig-ssh-key holds an SSH public key. It turns on SSH for that key only, as root.
  • screenrig-logs keeps the system log in memory for diagnosis.
  • screenrig-adb-key holds your computer's adb public key. It turns on Remote debugging for that key only.

A Pi that loses or resets its data comes back as the same screen, with no new pairing, because its identity comes from the card together with the board. A card moved or copied to another board is a new screen and pairs again.

On a Raspberry Pi 5, when a display schedule turns the display off, the Pi powers itself down, and its clock wakes it five minutes before the display comes back on. It is never off for more than 12 hours at a time. A Pi 4 stays on with its display off.

To install the Player on a Raspberry Pi OS card you set up yourself instead, use the Linux package above.

Use Raspberry Pi OS (64-bit) based on trixie; the 32-bit and bookworm images cannot run the Player. A Pi needs 1 GB of memory, and 2 GB is recommended (Memory). Every Raspberry Pi plays HEVC (H.265) video only, decoded in hardware: it skips an H.264 video with a warning, so upload every video for a Pi with screenrig media upload --codec hevc, at any size. A Raspberry Pi 4 plays HEVC up to 1080p60; a Raspberry Pi 5 plays HEVC up to 4K60. A Pi 4 shows 60 frames a second when the video is the only video on its page, not moving, on a landscape screen with one display, and 30 frames a second otherwise. For 4K at 60 frames a second on a Pi 5, upload with screenrig media upload FILE --codec hevc --max-edge 3840 --max-fps 60. Raspberry Pi OS Lite with --kiosk boots straight into the Player.

An application on a Pi can read USB barcode and badge readers, serial devices and Bluetooth LE sensors, hear buttons and door contacts on the GPIO header, and drive relays and receipt printers. Buttons and relays on GPIO covers the wiring, and Hardware an application can use lists what every Player offers.

A Raspberry Pi 4 or 5 shows 1080p at 60 Hz on a display larger than 1080p, such as a 4K TV, unless you choose 4K with Resolution in Device Configuration or your agent sets the output mode with screenrig screen display-output SCREEN_ID --mode 3840x2160x60p; --mode auto returns it to 1080p. A Pi 5 plays 4K video at 60 frames a second either way: at a 1080p output the display hardware scales it down, and with the output set to 4K it shows native 4K detail. At 4K the Pi works much harder, so busy pages, such as web content, heavy animation or a video beside cards, run at lower frame rates, while simple pages and video stay smooth. While the Pi is unpaired, its pairing screen says when it is running a larger display at 1080p and where to choose 4K. Choosing 4K on the device asks first, then asks "Keep this resolution?".

A Raspberry Pi 4 or Pi 5 drives two displays, either showing the same picture on both or extending one playlist across them. A Pi 5 extends any playlist across two 1080p displays, including video on one display with live cards or a web app on the other and a video on each display. A Pi 4 extends images, cards that change from slide to slide, and a video on one display beside still content on the other, and it mirrors any playlist.

To upgrade a Player you installed on Raspberry Pi OS, rerun the Linux installer using the existing installation prefix and Player account; pairing and display settings are kept. A screen reload refreshes content and does not install a new Player version.

Device Configuration

Open the Player's menu (press Esc on a keyboard, or hold a touch for 5 seconds) and choose Device Configuration to set up the device itself, with no keyboard or SSH session. The Raspberry Pi image has it, and so has any dedicated Linux kiosk installed with --manage-host, which needs NetworkManager:

Kiosk install with Device Configuration
curl -fsSL https://screenrig.ai/linux/install.sh | sh -s -- --kiosk --manage-host
  • Displays. Mode, Layout, Order, Rotation and Resolution, and with two displays the menu appears on the first display. Mode is Mirror, the same picture on both, or Extend, one wall, with Layout side by side or stacked and Order the order you choose; Rotation turns the picture; Resolution is Automatic or one of the display's modes. On a Raspberry Pi, Automatic is 1080p at 60 Hz on a display larger than 1080p, and choosing a mode above 1080p asks first. A new resolution stays only when you choose Keep; without an answer the display goes back to the one before after 15 seconds. It needs wlr-randr (sudo apt install wlr-randr).
  • Wi-Fi. Choose a network and enter its password.
  • Network. Addressing, automatic or a manual IP address, gateway and DNS, and the device's name on the network.
  • Time zone. The device's zone, which the screen's schedules use unless you set one for the screen.
  • Remote debugging. On the Raspberry Pi image and a --remote-debug install: adb from your computer, off until you turn it on.
  • Restart device, Shut down and Reset this screen.

Without a keyboard, an on-screen keyboard appears for text entries. A layout chosen here reaches the screen's settings, so screen show lists it, and your agent can change it with screen wall set.

Remote debugging

Remote debugging lets you diagnose a Linux or Raspberry Pi Player from your computer with the standard Android adb tool over the local network: a root shell on the device, screenshots, the system log, file copies, port forwarding, a Player install, taps and keys. scrcpy mirrors and controls the screen. The Raspberry Pi image has it, and a dedicated Linux kiosk gets it with --remote-debug; running the installer again without that option removes it. It is off until you turn it on: open the Player's menu, choose Device Configuration, then Remote debugging, then On. It stays on across restarts, and the screen shows the address to connect to, which Network also lists.

Remote debugging with adb
# A Linux kiosk with Remote debugging
curl -fsSL https://screenrig.ai/linux/install.sh | sh -s -- --kiosk --manage-host --remote-debug
# From your computer
adb connect ADDRESS:5555
adb shell
adb exec-out screencap -p > screen.png
adb logcat
adb push FILE /data/local/tmp/
adb forward tcp:8080 tcp:8080
adb shell input tap X Y
adb install screenrig-player-linux-aarch64.apk
  • Trust. The device answers adb on TCP port 5555. While it trusts no computer, the first one that connects within 10 minutes of Remote debugging starting is trusted and remembered; every other computer stays unauthorized. Nothing asks on the screen, so connect from your own computer right after you turn it on.
  • By the card. On the Raspberry Pi image, a file named screenrig-adb-key on the card's first partition, holding your computer's adb public key (~/.android/adbkey.pub, which adb devices creates), turns Remote debugging on at boot for that key alone, with no first-connection window. Remove the file and restart to stop it, unless it is also on in the menu.
  • Logs and installs. adb logcat prints the system log in Android's format; a Raspberry Pi keeps one only when the card holds screenrig-logs. adb install takes the Player archive from screenrig.ai/linux/ for the device's architecture, renamed to end in .apk. The device swaps in the new Player and goes back to the previous one if it does not start healthy within 5 minutes. Screenshots on a Linux PC need grim (sudo apt install grim).
  • Limits. adb reverse, adb pair, USB connections, screenrecord and adb uninstall are not supported, and adb root and adb remount change nothing because the shell is already root. Files pushed to /data/local/tmp or /sdcard live in memory and cannot run directly: run a script with sh /data/local/tmp/script.sh.
  • Security. Whoever holds a trusted key has a root shell on the device. While Remote debugging runs, the screen shows a Remote debugging chip in the corner over content; live view shows it, and screenshots the Player uploads leave it out. Turn it on only on a network you trust, keep port 5555 off the internet, and turn it off when you are done: Off stops it and forgets the trusted computer.

Find a screen on the network

Every Raspberry Pi screen has a name of its own on your network: screenrig- and six characters from its board, such as screenrig-ab12cd. The pairing screen shows the name and the address in its bottom-right corner, small, so whoever stands at the screen can read them. Once the screen is paired, screen show and the screen's Health section in the dashboard list the name and every address the device has. A Linux PC keeps the name you gave it, and shows it the same way.

A Pi answers by its name while it is waiting to be paired, and while SSH or Remote debugging is on. A paired screen with neither stays quiet on the network: find it by the local address the dashboard shows.

A computer on the same network reaches a Pi by its name:

Reach a Pi by its name
ping screenrig-ab12cd.local
# With Remote debugging on
adb connect screenrig-ab12cd.local:5555
adb mdns services
# With screenrig-ssh-key on the card
ssh root@screenrig-ab12cd.local

While it answers, the Pi announces itself with multicast DNS (Bonjour) on its own network only: its name, a _screenrig._tcp service that carries its Player version, its model and whether it is paired, and, while Remote debugging is on, the _adb._tcp service that adb mdns services lists. Nothing it announces lets anyone in: adb and SSH still need your key. The Device Configuration Network screen shows the name too.

Video walls

One Player drives 2 to 12 displays as one wall: the Linux Player on a --kiosk install with wlr-randr (sudo apt install wlr-randr), the Windows Player, and a BrightSign model with several video outputs, which shows its outputs as one wall. A Raspberry Pi 4 or Pi 5 drives two displays; a PC drives as many as its graphics outputs allow, and an Intel mini PC such as the Quieter 4C drives up to three. The Windows Player arranges Windows' display layout itself: it positions and rotates the displays, and mirrors them through Windows' duplicate mode for a playlist without a format. Windows keeps its own display scaling. A wall of 2 displays is in every plan, a wall of 3 displays comes with Plus and above, and walls of 4 to 12 displays with Enterprise (see pricing).

screen show lists the screen's outputs, for example HDMI-A-1 on Linux or DISPLAY1 on Windows. A wall is a row (left to right), a column (top to bottom) or a grid. A grid takes --columns, the displays per row, and fills at least two rows: 12 displays in 4 columns make 3 rows. Displays are numbered left to right, then top to bottom, and --outputs names the outputs in that order. --rotation turns every display clockwise by 0 (the default), 90, 180 or 270 degrees; 90 and 270 are portrait panels.

Set and clear a wall
screenrig screen wall set SCREEN_ID --outputs HDMI-A-1,HDMI-A-2 --arrangement row [--rotation 0|90|180|270]
screenrig screen wall set SCREEN_ID --outputs DISPLAY1,DISPLAY2,DISPLAY3,DISPLAY4 --arrangement grid --columns 2
screenrig screen wall clear SCREEN_ID

On a Linux Player with Device Configuration, the screen sets a wall of two displays itself: Displays, then Mode, Extend sets the same wall as screen wall set with both outputs, and Mirror a wall of the first output alone, which the second display mirrors. screen show reads what the screen chose, and the next screen wall set or screen wall clear replaces it; with no wall, two displays mirror. A playlist with a format plays on an extended pair; while the screen mirrors, it keeps showing what it last played, so assign an ordinary playlist, or extend the screen again.

A screen that plays a playlist built for its wall shows each display's number and output name for 20 seconds after a wall change, so you can check the order.

A single screen can be rotated too: name its one output and a rotation, for example screenrig screen wall set SCREEN_ID --outputs HDMI-A-1 --rotation 90 for a portrait screen. It needs the Linux Player on a --kiosk install with wlr-randr, and no plan feature. On a Raspberry Pi image or a --manage-host install you can also choose it on the device, from the Player's menu.

A playlist built for the wall carries a format (displays, arrangement, orientation and, for a grid, columns) and one page canvas, in 1080p design units per display: a tile is 1920 × 1080 landscape or 1080 × 1920 portrait, and the canvas is the tile times the columns and rows. A 4K panel needs nothing different. A screen plays a wall playlist only when its wall has the same shape.

Wall canvas by displays, arrangement and orientation
DisplaysArrangementLandscape canvasPortrait canvas
2row3840 × 10802160 × 1920
2column1920 × 21601080 × 3840
3row5760 × 10803240 × 1920
3column1920 × 32401080 × 5760
4grid, 2 columns3840 × 21602160 × 3840
12grid, 4 columns7680 × 32404320 × 5760

Place an item with displays: [1,2,3] spans three displays in a row, [2] sits on one display and [1,2] spans two. The displays fill a rectangle of the wall: on a grid of 4 columns, [1,2,5,6] is the top left block and [3,7,11] a column of three. Or give a free rect on the wall canvas. A card lays out inside its displays, so center on [2] sits in the middle of display 2; without displays it uses every display. On a screen with a wall, an ordinary playlist (no format) plays mirrored on every display.

Render wall video at the wall's aspect ratio within 4K, such as 3840 × 720 for three landscape displays in a row, 3840 × 1080 for two and 3840 × 1620 for a grid of 4 columns and 3 rows, upload it with --max-edge 3840 (the default transcode fits 1920 by 1080) and place it with content_fit: fill. Keep text and faces off the seams between displays.

json
{
  "name": "Lobby wall",
  "format": { "displays": 3, "arrangement": "row", "orientation": "landscape" },
  "pages": [
    {
      "id": "welcome",
      "canvas": { "width": 5760, "height": 1080, "background": "#000000FF" },
      "transition": { "type": "crossfade", "duration_ms": 500 },
      "advance": { "mode": "media_end" },
      "primitives": [
        {
          "id": "film",
          "primitive": "video",
          "selector": { "by": "id", "media_id": "med_01EXAMPLEWALL000000000" },
          "displays": [1, 2, 3],
          "layer": 0,
          "content_fit": "fill"
        },
        {
          "id": "menu",
          "primitive": "card",
          "card": "crd_01EXAMPLEMENU000000000",
          "layout": "center",
          "displays": [2],
          "content_fit": "fill"
        }
      ]
    }
  ]
}

Strips

A strip is a playlist drawn over the page along one edge of a display, such as a footer ticker or a header logo. The page keeps playing underneath; the strip hides the part it covers. A strip is made for a region: header (the top edge), footer (the bottom edge) or side (the right edge, full height).

A strip playlist is a region playlist: it carries format: {"region": "footer", "orientation": "landscape"}, where orientation is the orientation of the display it is made for, as the viewer sees it. It has one strip canvas, shaped as its edge: the long side runs along the edge and is at least twice the short side, such as 1920 × 240 for a landscape footer or header and 240 × 1080 for a landscape side. A strip holds image and card items only, with no video, stream, iframe, application or ad slot, and has no soundtrack. A strip is never a default playlist or a takeover.

Make a strip and show it
screenrig playlist create ticker.json --format-region footer --format-orientation landscape
screenrig campaign create --name Ticker --playlist-id pl_TICKER --tag lobby --covers footer

A campaign or a schedule entry shows a strip through covers: footer, header or side plays a strip of that region, and full (the default) or main plays an ordinary playlist as the page. A level that covers a region needs a playlist made for that region.

The strip keeps its canvas aspect along the edge of each display of its orientation, after rotation, and covers at most half of the display. A display of the other orientation shows only the page, and so does a display the strip would cover by more than half (its height for a header or footer, its width for a side). The alert bar of an overlay trigger draws above a strip. A campaign or entry that fits none of the screens it targets is refused (playlist_format_mismatch); on a screen of a mixed audience where it does not fit, campaign explain reports region_not_laid_out and the screen shows the page. Changing a playlist into or out of a region, or to another region, is refused while a screen, folder or campaign uses it.

Install the Player web app

  1. 01

    Open play.screenrig.ai/player/ on the screen device.

  2. 02

    On iOS, use Safari: Share → Add to Home Screen. On Android, use Chrome: Install app or Add to Home Screen.

  3. 03

    Open the installed PWA and follow its displayed setup instructions.

  4. 04

    Keep the PWA in the foreground on the screen device.

Start a kiosk browser with autoplay allowed (Chrome --autoplay-policy=no-user-gesture-required, Fully Kiosk's Autoplay Audio) and the Player web app plays sound at once; a browser that refuses sound plays video muted, and the Player log says so.

The Player web app needs a browser with the features of Chromium 76 or newer; a browser without them shows a notice on the screen that names what is missing. Open the Player in one window per browser profile: a second window waits, and says the Player is open in another window, until the first closes.

A Player pairs with the API of its own environment: play.screenrig.ai with api.screenrig.ai. When the CLI uses another API origin, --api-url https://api.DOMAIN, open https://play.DOMAIN/player/ instead.

Your agent needs the official plugin to publish content to the Player.

ChromeOS kiosk

Managed ChromeOS devices, such as a Chromebox, a Chromebase or a ChromeOS Flex PC, run the Player web app as a kiosk app from the Google Admin console. The device boots straight into the Player, keeps it full screen, and starts it again if it closes.

  1. 01

    In the Google Admin console, open Devices → Chrome → Apps & extensions → Kiosks and select the organizational unit for your screens.

  2. 02

    Add the app by URL: your project's fleet link, or https://play.screenrig.ai/player/ with the trailing slash to pair each device by its code.

  3. 03

    Set it to auto-launch, and turn on Allow app to manage power.

  4. 04

    In the device's kiosk power settings, set the idle action to Do nothing, so the screen never dims or sleeps.

  5. 05

    Restart the device. With a fleet link, the Player joins your project as a new screen on its own. Without one, it shows its pairing code: give the code to your agent.

In the kiosk session the Player reads the device's serial number and the asset ID and location you annotate on the device in the Admin console. They appear in the screen's host details in the dashboard and in screen show. When a powerwash or reinstall gives the device a new Player identity, the serial lets your agent reconnect it to its existing screen with screen recover instead of pairing a new one.

For the soundtrack, allow autoplay for https://play.screenrig.ai with the AutoplayAllowlist policy.

One URL for the whole fleet

A fleet link is one Player URL that turns every device opening it into its own screen in your project, with no pairing code. Ask your agent for one (screenrig fleet-links create), or create it in the dashboard under Settings → Fleet links, and put its URL in the kiosk app in step 2. Each new device joins with the link's tags and playlist and takes its name from the asset ID, then the location, you annotate on it in the Admin console.

A device that is already a screen stays that screen through restarts and updates. After a powerwash or reinstall it comes back as the same screen, once its old Player identity has been silent for ten minutes. Cap a link with a most-screens limit, turn it off to stop new screens joining, or rotate it to replace a URL that was shared too widely. Screens a link already made keep playing through all three. Keep the URL in the Admin console: it creates screens in your project.

Display power over RS-232

Connect the display's RS-232 control port to the ChromeOS device with a USB serial adapter, and grant the adapter to https://play.screenrig.ai with the SerialAllowUsbDevicesForUrls policy (the adapter's USB vendor and product IDs) or SerialAllowAllPortsForUrls. At start the Player finds a Samsung (MDC), LG, NEC or Philips (SICP) display on the granted port at the factory-default 9600 baud and display ID. It then switches the display's own power, standby and back on, and reports the power state the display reads back. The screen's host capabilities list Display power (RS-232).

Select the panel adapter in the kiosk URL with serialDisplay=usb-0403:6001, replacing 0403:6001 with its four-digit hexadecimal USB vendor and product IDs. The Player probes only the selected adapter, remembers a detected panel for later starts and leaves application peripherals untouched. Use an adapter with unique USB IDs among the granted ports. Set serialDisplay=none to forget the panel and stop probing.

Browser sources (vMix, OBS)

A browser source keeps no storage, so the Player in it would lose its pairing every time it loads. A screen link is the address of one screen: the Player opened from it is that screen on every load, with nothing kept. Use it for a vMix or OBS browser source, or any browser that clears its data.

  1. 01

    Pair the screen once. Open the Player web app on any browser, give your agent the code it shows, and wait until the screen is active.

  2. 02

    Ask your agent for the screen's link (screenrig screen link create SCREEN_ID), or open the screen in the dashboard and choose Create link in the Screen link row of its Properties tab.

  3. 03

    Copy the link: your agent prints it with screenrig screen link show SCREEN_ID, or choose Copy link in the dashboard. It is https://play.screenrig.ai/player/#screen= followed by a secret.

  4. 04

    Paste it as the URL of the browser source.

  5. 05

    The source plays the screen's playlist at once, and again after every reload.

Open a screen link in one place. Opened in two, it is one screen twice. Several browser sources in one browser, each with its own link, run as separate screens.

A screen link is a credential: whoever has it opens that screen. When it leaks, or you want it back, ask for the link again (screenrig screen link create SCREEN_ID, or Replace link): the old address stops working at once and a source still showing it shows a notice and no content, with no pairing code. Paste the new address and the source plays again. Turn off link (screenrig screen link delete SCREEN_ID) ends the link without a new one. The screen's own Player, if it has one, is not affected either way.

Advertising on your screens

The Player you already use is also the ad Player: there is nothing extra to install.

Selling is a choice you make per screen, through the same official plugin and CLI. Opt an owned screen in with screenrig ads inventory update scr_LOBBY --enabled and describe it publicly with the site name, city, region, venue type, and audience tags you choose. Define reusable ad slots with screenrig ads slots create — accepted media (image or video), the longest image and video durations, and an optional rate override for that slot. A slot definition alone changes nothing on the glass; placing its adslot page in one of your playlists is what gives that screen an actual ad break, and every other page keeps playing normally.

Paid ads require a Player that supports adslot playback; Apple TV, iPhone and iPad play house content only. The server serves a Player without that support only the ordinary playlist, so that screen plays house content and no paid advertising; a capable Player requests a fill for each adslot page and skips any slot it cannot fill, keeping the playlist moving. Buyers pair nothing — they buy from your inventory through the invitation you send with screenrig invitations create --kind ad-buyer --email ADDRESS --screen-id scr_LOBBY.

The plugin, project, and first-screen steps are in the Quickstart guide.

Windows

Install the Player from the Microsoft Store on a PC with Windows 10 (version 1809 or later) or Windows 11, on Intel, AMD or Arm. It opens full screen with the cursor hidden, keeps the PC and its display awake, and shows a pairing code. Iframe pages and applications draw through Microsoft's WebView2 runtime, which the Player looks for when it starts; images, video, streams and cards need nothing extra.

To lock a PC to the Player, download the kiosk setup script from the Windows section of Downloads and run it once from an elevated PowerShell on the PC, signed in at the PC itself. It locks the PC to the Player with Assigned Access or Shell Launcher, whichever the Windows edition offers (Windows Home gets no lock), turns off the notifications, prompts, lock screen and screen saver that would paint over it, and installs Windows updates at 3 am without restarting the PC under the Player. Run it again after any change; add -Undo to take it all back.

On a locked PC the Player stays in front of every window. When another window covers it for 3 seconds, or another application holds the foreground for 10 seconds, the Player logs player.window_covered or player.foreground_lost, and your agent reads them with events list --source log --screen-id ID.

Commercial displays

Samsung Smart Signage (Tizen) runs the native screenRIG Player.

BrightSign players running OS 9.1 or newer auto-start the screenRIG Player from an SD card. Extract the package to the card root, insert it, and power on. The player applies its hardware policy and opens the screenRIG Player.

  1. 01

    Set the player's clock and network first. A wrong clock stops the secure connection.

  2. 02

    Extract it to the root of a FAT32 SD card and insert the card.

  3. 03

    Power on the player. It starts the package and shows the pairing code.

  4. 04

    Give the code to your agent.

A Samsung, BrightSign or LG display that has opened the Player once still starts it when the network is down at power-on, and plays its saved playlist.

An application on a BrightSign player can reach its hardware: GPIO lines, RS-232 and USB serial devices, keyboard-wedge barcode and badge readers, infrared receive and send, UDP messages and, on the XT1143, XT1144, XT1145, XT2144 and XT2145, the live picture of the player's HDMI input. Samsung Smart Signage (Tizen) and LG webOS Signage applications get keyboard-wedge scanning and no other hardware. BrightSign players describes the player, and Hardware an application can use lists every Player.

The BrightSign Player captures screenshots that include playing video, sets the output mode (resolution and refresh rate) to one of the modes the player reports, asks the TV over HDMI-CEC to switch to the player's input, and joins eventual sync with the other players nearby.

LG webOS Signage

LG webOS Signage panels on version 6.0 or newer (Chromium 79 or newer) run the screenRIG Player. An installed app starts at power-on and opens it. Panels on webOS Signage 4.x or older run a browser older than the Player needs. Download the packages from screenrig.ai/webos/.

A panel in Local application launch mode installs com.lg.app.signage.ipk from a USB stick.

  1. 01

    Set the panel's date and time and its network first. A wrong clock stops the install with "Unknown error" and stops the secure connection.

  2. 02

    On a FAT32 USB stick, make a folder named application at the root and put com.lg.app.signage.ipk in it. Keep the file name.

  3. 03

    Plug the stick into the panel. In Server Settings, set Application Launch Mode to Local and the type to IPK, then run Local Application Upgrade from USB.

  4. 04

    Restart the panel. It starts the app and shows the pairing code.

  5. 05

    Give the code to your agent.

To install from the panel's app menu or from an SI server, use ScreenRig-webos.ipk instead. The two packages are separate apps to the panel, each with its own pairing, so install one of them on a panel.

A panel that starts before its network is ready shows the screenRIG screen and keeps trying until the Player answers. While it waits, press Info on the remote to see the panel's model, browser version and connection state.

Other commercial displays with a built-in HTML5 browser or URL launcher can open play.screenrig.ai/player/ directly and follow the web app steps above. The display must keep the page in the foreground and allow it to store data. Android TV and streaming boxes with a full web browser can do the same: open play.screenrig.ai/player/ in the box’s browser, give your agent the pairing code, and keep the page in the foreground.

Streams and fallback images

Use stream for a live feed and video for an uploaded file. A stream needs a ready uploaded image from the same account as its fallback. The image appears while connecting, if playback stalls, or when the Player cannot receive the source.

Prepare a feed

Use a public HTTPS HLS playlist without embedded credentials, or a camera's RTSP URL. For the Web Player, the playlist, segments, and keys must allow cross-origin requests from the Player origin. H.264 video with AAC audio is a practical starting profile; decoding depends on the device. Audio is muted by default, and browser autoplay rules still apply.

Choose timing and transport

Use at most one stream per page and duration-based advance. Supply one or two sources with different protocols, in preference order. A source can give only its url: an https URL is HLS, an rtsp or rtsps URL is RTSP. For multicast, use an administratively scoped IPv4 group in 239/8 and a UDP port; add an HLS alternative for other Players. screenRIG does not convert multicast into HLS. Streams are not cached for offline replay; the fallback image is.

Play a camera directly

Android, Amazon and Linux Players open rtsp:// camera sources themselves, from the Player's own network, with no relay. Use the URL the camera or recorder gives, including a user:pass@ login. Linux also opens rtsps:// sources.

For a UniFi Protect camera, turn on RTSP for a channel in the camera's Protect settings and copy its URL. Android and Amazon map Protect's rtsps:// URL on port 7441 to plain rtsp:// on port 7447, removing enableSrtp. The Player needs a route to port 7447 on the Protect console; this connection uses neither TLS nor SRTP. For other encrypted RTSPS sources on Android and Amazon, use an HLS alternative or the fallback image. Linux opens a Protect rtsps:// URL as given. Other Players play the HLS alternative or show the fallback image.

Enable multicast reception

On Android, open the operator menu, choose Player Settings and enable Multicast streams; it is off by default. On Linux and Raspberry Pi, set SCREENRIG_ENABLE_MULTICAST=1 in the Player's launch environment and check screenrig-player --capabilities-json. The network must carry the selected multicast group and port. DRM, RTP, custom authentication headers and stream transcoding are not supported.

Soundtracks

A playlist soundtrack plays on every Player. The Player downloads and verifies each MP3 track with the rest of the playlist, then plays the tracks in order while pages change. Page transitions never stop or restart the music, and the soundtrack keeps playing offline from the cached tracks. A cued soundtrack (cued: true) plays a track only when a page cue starts it and is silent after that track ends until the next cue. A page whose advance is audio_end ends when its cued track ends; if the Player cannot play the track, the page lasts the track's length. macOS, Apple TV, iPhone, iPad and Windows play the first 32 tracks as an uncued soundtrack, and an audio_end page there lasts its after_ms.

When the agent republishes the playlist, the current track keeps playing if it is still in the new soundtrack. The soundtrack volume is multiplied by the Player volume, so the operator volume setting or the display's own volume control still decides how loud the screen is.

A video or stream plays silent unless the playlist sets muted to false on it. Then it plays its sound at the Player volume while its page shows, and that page pauses the soundtrack, which resumes from the same point on the next page without sound.

Browsers can block sound until someone touches the page. The Player web app keeps showing pages, starts the soundtrack on the first tap or key press, and plays a video that has sound muted until then. For an unattended kiosk browser, allow autoplay with sound; in Chromium, launch with --autoplay-policy=no-user-gesture-required; on a ChromeOS kiosk, set the AutoplayAllowlist policy. Native Players need no setting.

Device health and display control

Every Player reports device health every fifteen minutes, and at once when its display connection or power changes. It declares the device controls it supports: remote reboot, remote volume, and the display power methods it can use. What a Player can read and switch depends on the platform and on how the device is set up.

Each screen's actual capabilities appear in screen show as its host capabilities, next to its latest health report, so the agent knows before it acts whether that screen can reboot or switch its display. The table shows what each Player can do.

Device health and display control by Player
PlayerHealth reportedDisplay powerReboot
Web / PWAPlayer uptime, CPU cores, display state, and network type where the browser exposes itRS-232 on a ChromeOS kiosk with a granted serial port; on-screen blackoutNo
Android (Google Play)Device and Player uptime, memory, CPU cores, display connection and power, network and Wi-Fi signal, battery level, charging and power source where the device has a battery, crashes, and renderer restartsOn-screen blackoutNo
Android (managed, device owner)As Google Play, plus CPU temperatureBacklight; HDMI-CEC on a privileged install; on-screen blackoutYes
Amazon Signage StickAs Google PlayOn-screen blackoutNo
Linux and Raspberry PiDevice and Player uptime, memory, CPU load, temperature, display connection and power, network and Wi-Fi signal, and crashesHDMI-CEC with a CEC device and cec-ctl; DDC/CI where ddcutil finds the monitor; panel backlight; on-screen blackoutYes, after a --kiosk install
macOSDevice and Player uptime, memory, CPU load and cores, display connection and power, and network typeDisplay sleep, once it has worked on that Mac; on-screen blackoutNo
Apple TVDevice and Player uptime, memory, CPU load and cores, display power, and network typeOn-screen blackoutNo
WindowsDevice and Player uptime, memory, CPU cores, display connection and power, network type, and renderer restartsDDC/CI where the monitor answers; monitor off; on-screen blackoutYes, when the account may shut down the PC
Samsung Smart Signage (Tizen), LG webOS SignageThe web Player readingsOn-screen blackoutNo
BrightSignThe web Player readingsHDMI-CEC through the BrightSign shell; on-screen blackoutYes, through the BrightSign shell

Remote actions

Three more device controls reach a Player as commands: clear its caches, restart its application (not the device), and update it to the newest release. A Player declares clear_cache, restart_app or update in its host capabilities only where the behaviour works on that device, so screen show tells the agent before it acts; a screen whose Player does not declare the capability answers command_unsupported and nothing is sent. Clearing the cache keeps the pairing and settings and refills content from the manifest. Each command is listed under commands in screen show, done or failed with the cause the Player reports.

Remote actions by Player
PlayerClear cacheRestart appUpdate
Web / PWAYesYes, a page reloadYes, the service worker updates, then the page reloads
Android (Google Play, Amazon Signage Stick)YesWhere the device lets the Player relaunch itselfNo, the store updates it; the Amazon Signage Stick updates it over the air
Android (managed, device owner)YesYesNo, the device manager updates it
Linux and Raspberry PiYesYesYes, on an install that left an update channel
macOSYesYesNo, the App Store updates it
Apple TVYesNoNo, the App Store updates it
WindowsYesYesYes, on the Store-packaged build
BrightSign, Samsung Smart Signage (Tizen), LG webOS SignageYesYes, a page reloadYes, the service worker updates, then the page reloads

Idle dark, automatic brightness and kiosk lock

Three screen settings shape the glass on the device itself. A Player applies one when screen show lists its host capability (display_power.idle, brightness.auto or kiosk_lock); the setting is stored either way.

  • Idle dark. After 30 to 86400 seconds without a touch or key, or, when presence is a wake event, without anybody in front of the screen, the glass goes dark and playback pauses. A touch or presence, as you choose, lights it again; the touch that wakes a dark glass goes no further. Presence reads the device's camera on the device, and no image leaves it; the person setting up the device grants the camera permission in Android settings or with adb shell pm grant ai.screenrig.player android.permission.CAMERA. A display schedule or override that holds the display off wins.
  • Automatic brightness. auto sets the brightness from the device's light sensor; fixed, the default, keeps the operator's brightness. A device declares brightness.auto only when it has a light sensor.
  • Kiosk lock. On an Android phone, tablet or box that is not a TV, the Player pins itself to the screen with screen pinning, no device owner needed. The person at the screen confirms the first time, and the status bar, home and recents are blocked while it holds. A device-owner managed Player locks itself with no prompt, TV or not. Android TV, Google TV and Fire TV devices otherwise ignore the setting.

Your agent sets them with screen display-idle, screen brightness and screen kiosk-lock. The screen page's Properties tab in the dashboard has the same three under Device settings.

Output mode and TV input

Two more screen settings: the output mode applies on BrightSign and on a Linux or Raspberry Pi --kiosk install, TV input on BrightSign.

  • Output mode. The player reports the resolutions and refresh rates it can set, such as 3840x2160x60p, and your agent picks one of them, or auto for the display's own preferred mode; on a Raspberry Pi 4 or 5, auto is at most 1920x1080 at 60 Hz on a larger display, and a mode above 1080p answers a display_output_above_1080p warning. screen show reports the mode in force, so a Pi left on auto reads 1920x1080x60p. The player applies a new mode once and keeps it across restarts; a BrightSign player can restart itself to do it. A Linux Player sets the mode on every display it drives and checks that the display comes up in it: when it does not within about ten seconds, the Player goes back to the mode before and screen show keeps showing that one. A mode the player does not report is refused.
  • TV input. With the setting on, the player asks the TV over HDMI-CEC to switch to its input when it starts and each time the display turns on, so the TV changes to the player by itself. It sends nothing while a display schedule holds the display off.

A screen whose Player does not offer one refuses the setting. Your agent sets them with screen display-output and screen display-cec, and screen show lists the modes its Player reports.

Live view

Live view shows what a screen plays as video in the dashboard, and screenrig screen live frame saves JPEG frames of it for an agent that has HTTPS and nothing else. The Android Player on Android 10 or later with a hardware H.264 encoder (Google Play, Amazon Signage Stick and managed builds), Linux and Raspberry Pi publish it, and a screen that can lists the live_view host capability in screen show. On Android, someone at the screen allows screen capture once each time the Player starts. A live session ends by itself when its lease runs out; start it again to keep watching.

Control a screen on the device

Once the screen is paired, press OK on the remote to open its operator menu. On Apple TV, press Select or Menu. Without a remote, hold a touch screen for five seconds, press Enter or Esc on a keyboard, or click the screen. The first screen of the menu holds:

  • Screen name. Select it to rename the screen.
  • Playlist. Its hint is the playlist the screen plays. Select it, or press Right, to list every playlist in the project in alphabetical order, and choose one to switch the screen to it. A takeover, campaign or playlist schedule still decides what plays; the hint always names what is playing.
  • Page. Its hint is the name of the page now showing; a page's name is its identifier. The menu opens on this row. Press Left or Right to step to the previous or next page, or select it to list the playlist's pages in playback order and choose one to jump to. The chosen page starts from its beginning.
  • Player Settings. Brightness, volume and reset, and on Android multicast reception, start on boot, home screen and, while the Player is pinned, leaving kiosk lock.
  • Device Configuration. On a Raspberry Pi image or a --manage-host install: Displays, Wi-Fi, Network, Time zone, restart and shut down, and on the Pi image or a --remote-debug install Remote debugging. There, reset is Reset this screen.
  • Exit closes the menu from any screen.

Back, or Left on a list, returns to the previous screen. The menu closes by itself after 60 seconds without input. Reset gives the Player a new identity and a new pairing code; pair it again, or let your agent reconnect it to its screen.

Pause and resume

Press Play/Pause on the remote to pause the screen; the Paused chip shows. On a keyboard, press K on Windows, Ctrl+Alt+Space on Linux and Raspberry Pi or Space on Android; on a Mac, use the pause button on the window toolbar or Playback → Pause. iPhone and iPad cannot pause. A paused screen holds its page timer, the page's video and the soundtrack. Press the button again and everything continues from where it stopped: a page set to show for 20 seconds, paused at 10 seconds, shows for the remaining 10 seconds, and the music resumes from the same point instead of starting over. Moving to the next or previous page, or choosing one in the menu, keeps the pause: the new page waits at its start until you resume. Cards, web pages and live streams keep running while paused. A pause ends by itself after 60 minutes.

macOS toolbar and AirPlay

The macOS Player opens full screen. Press ⌘F to leave full screen, and its window shows a toolbar with a page picker and previous, pause, next, AirPlay and settings buttons; ⌘F returns to full screen, and the Player starts in the mode you last used. Choose the AirPlay button and pick an Apple receiver, such as an Apple TV, to show the Player's picture there. macOS asks you to allow screen capture of the Player window and local network access. The picture goes without sound or cursor, the Mac keeps playing if the receiver drops, and the receiver is a display only: it does not become a screen in your project.

Reconnect or replace a Player

A Player that is reset or reinstalled pairs as a new screen unless your agent reconnects it.

  • Reconnect. A display that lost its stored identity, after a reinstall, a powerwash or a reset on the device, shows a new pairing code. When it reports the serial or device ID of an existing screen, screen show lists a recovery_pending offer with the platform, model and firmware of the display asking. Check them against the display you expect, then ask your agent to run screenrig screen recover SCREEN_ID. The screen keeps its name, playlist, schedules and history, and the old identity stops working after fifteen minutes. No offer is made while the screen's current Player is still online, and a screen archived by a reset on the device stays archived until screen unarchive.
  • Replace. Pair the new device as its own screen, then ask your agent to run screen replace SCREEN_ID --with NEW_SCREEN_ID. The new device takes over the old screen, which keeps its name, playlist, schedules and history, and the new screen is archived.

Check your first screen

Give your agent the intended screen and ask it to publish a simple welcome message. Ask for a screenshot when the Player is showing it.

If the screen is absent from the agent's list, confirm that the Player is open and its setup is complete. If content does not update, check the device's connection and ask the agent to inspect screen state and playback evidence.

A chip on the screen, or a code in screen show, is explained in Player status codes.

Once the screen is paired, its operator menu names the screen and shows its playlist and page.

Continue with the agent workflow.