Video Playout Software 2026: Run a 24/7 TV-Style Channel

Published on

Video playout software for a 24/7 channel: ffplayout, CasparCG, OBS with Advanced Scene Switcher and FFmpeg compared, plus what a playout server needs.

A streamer at a desk with OBS and a multistream dashboard on two monitors, an audio mixer in front of him and a server rack behind

You want a channel that behaves like television: a morning block, a prime time slot and something sensible overnight, every day, without you clicking anything. Search for "video playout server" or "streaming playout" and most results are paid cloud services or broadcast hardware. This guide explains scheduled playout, compares the open-source playout software you can run yourself (repositories and docs checked on 8 November 2026), and lists what the server behind a 24/7 channel needs.

Quick answer: Video playout software runs a channel from a timetable: it knows what airs at 18:00 and plays a filler when a file is missing. The most complete free playout system for an online channel is ffplayout, a Linux service with a web interface, daily playlists and fillers; its GitHub repository is active and not archived (v2.7.1, 28 October 2026). CasparCG Server is the broadcast-grade engine, but it needs an OpenGL 4.5 graphics card and a separate client for the schedule. OBS with the VLC Video Source and the Advanced Scene Switcher plugin switches scenes by the clock and lets you go live in between. The FFmpeg concat demuxer loops a list but has no clock. Hosted online playout software trades that control for less upkeep.

Scheduled playout versus a looped file

A loop plays one file or one folder again and again. Someone who tunes in at 21:00 sees whatever happens to be playing. Scheduled playout works from a timetable instead: each day has a playlist, every item has a start time, and the recap show starts at 18:00 because the schedule says so. A real playout system also handles what goes wrong. If a file is missing or a playlist runs short, it plays a filler or a station loop instead of going black, and it keeps the clock in step so the next block still starts on time.

That difference decides which tool you need. For a lofi mix or one long ambience video, a loop is enough, and our guide to looping video files on a 24/7 YouTube stream covers it. For named blocks, a broadcast day that starts at 06:00 and a schedule you can prepare for next Tuesday, you want playout.

Open-source playout software at a glance

ffplayoutCasparCG ServerOBS + Advanced Scene SwitcherFFmpeg concat demuxer
What it isPlayout server with a web interfaceGraphics and video playout engine driven by clientsLive production app with an automation pluginFFmpeg reading a list of files as one input
Clock-based scheduleYes: a playlist per day, templates, custom day startThrough a client or your own script over AMCPYes: time conditions switch scenesNo: plays the list in order
Gaps and missing filesFillers built inHandled by the clientA fallback scene you buildNot handled
Encodes while on airYes, on the CPUYes, the mixed outputYes, the whole canvasNo, with -c copy and matching files
Latest stable releasev2.7.1, 28 Oct 2026v2.5.1, 16 Sep 2026OBS 33.0.1, 29 Oct 2026; plugin 1.37.2, 1 Nov 2026Part of FFmpeg

Release dates come from each project's GitHub releases on 8 November 2026.

ffplayout: the closest thing to a free playout system

Status: the ffplayout repository is not archived. On 8 November 2026 the latest stable release was v2.7.1 from 28 October, version 2.8.0 was in beta (2.8.0-beta.4 on 5 November), and the main branch had commits on 7 November. It is written in Rust on top of the FFmpeg libraries and licensed GPL-3.0.

The README calls it "a 24/7 broadcasting solution". It plays either a watched folder, in sorted or shuffled order, or a JSON playlist for each day that stays editable while the channel runs. For a channel that runs day after day you set a day_start (06:00 instead of midnight, for example) and a length of 24 hours. When a playlist is shorter than the day, ffplayout loops fillers until the time is full; when a clip or the whole playlist is missing, it plays a filler, and if no filler exists it creates a dummy clip. It can also trim the last clip so the day ends on time.

You do not have to write every day by hand. A template describes blocks with a start time, a duration, source folders and a shuffle flag, and ffplayout generates the daily playlists from it for a date range, from the command line with -g and --template or through its API:

{
  "sources": [
    { "start": "00:00:00", "duration": "06:00:00", "shuffle": true,  "paths": ["/media/overnight"] },
    { "start": "06:00:00", "duration": "06:00:00", "shuffle": false, "paths": ["/media/morning"] },
    { "start": "12:00:00", "duration": "06:00:00", "shuffle": true,  "paths": ["/media/afternoon"] },
    { "start": "18:00:00", "duration": "06:00:00", "shuffle": false, "paths": ["/media/prime"] }
  ]
}

On top of that come a static or animated logo, text overlays you control from the web interface, scheduled lower thirds (marked experimental), RTMP and SRT live ingest so you can cut into the schedule with a live show, several channels on one install, and email or HTTP alerts from the logs.

Setting it up: the project ships .deb and .rpm packages. Install one, add the FFmpeg 7.1 or newer runtime libraries, start the service and open http://<server-ip>:8787 to create the first admin. The install guide asks you to put a reverse proxy with SSL in front before you expose it to the internet. HLS is the default output; for YouTube, Twitch or Kick switch to the stream output, which the docs say is mainly tested with RTMP. Multiple outputs per channel and output reconnection are marked experimental and, per the README, still need sustained testing before production use, so start with one stream output.

Resources: ffplayout processes everything on the CPU and needs no graphics card. Its README recommends at least 4 dedicated threads and 3 GB RAM for 720p.

CasparCG Server: broadcast graphics and playout

CasparCG Server plays out and records graphics, audio and video to multiple outputs, and its README says it "has been in 24/7 broadcast production since 2006". It runs on Windows (Windows 11 recommended) and Linux (Ubuntu 24.04 recommended). The hard requirement is a graphics card capable of OpenGL 4.5, with an Nvidia card recommended. A server without a capable graphics card cannot run it.

CasparCG is an engine, not a scheduler. You control it over AMCP, a text protocol that listens on TCP port 5250 in the default casparcg.config. A client prepares the next clip with LOADBG, and the AUTO flag starts that clip when the current one ends, so a client can chain items back to back. The timetable itself lives in the client. The official CasparCG Client is a separate download, and the project's related projects page names CasparCG-Scheduler and TVPlay, the playout automation used at TVP. To get a stream out, the FFmpeg consumer takes a file or URL as its output path, set in the config or added with the AMCP ADD command.

Status: active and not archived, with commits on 27 October 2026, licensed GPL-3.0. Version 2.5.0 (10 December 2025) added support for headless Linux and Ubuntu .deb packages. Version 2.5.1 (16 September 2026) dropped the AVX2 requirement except for v210 Decklink output and moved to FFmpeg 8.1.2.

Pick CasparCG for graphics templates, Decklink output or your own automation on AMCP. For a plain online channel it is more work than ffplayout.

OBS as a playout system: VLC Video Source and Advanced Scene Switcher

OBS was built for live production, but with one plugin it runs a schedule. The layout:

  1. One scene per block (Overnight, Morning, Afternoon, Prime), each with a VLC Video Source that holds that block's files.
  2. One fallback scene with a station loop that is safe to air at any time.
  3. Advanced Scene Switcher macros that switch scenes by the clock.

The OBS knowledge base sets the details for the VLC Video Source. It only appears when VLC is installed, and 64-bit OBS needs 64-bit VLC. Unlike the plain Media Source, it holds a playlist. Loop Playlist is on by default, Shuffle Playlist is off, and Visibility Behaviour defaults to "Stop when not visible, restart when visible". That default is what you want for programmed blocks: each block starts at its first file when its scene comes on air.

In Advanced Scene Switcher, a macro runs actions when its conditions are met. The Date condition takes a day of the week ("Any day" for daily blocks) and a time in 24-hour format with At, Before or After. Pair it with the Switch scene action: Date, Any day, At 18:00:00, then Switch scene to Prime. Make one macro per block, or pick specific days for a weekend schedule.

For a block that should play once and then hand over to the station loop, turn Loop Playlist off and add a macro with the Media condition set to Ended (Playlist) and Switch scene to the fallback. The plugin's wiki warns that Ended (Playlist) does not trigger while the VLC source keeps looping.

Versions on 8 November 2026: OBS 33.0.1 (29 October) and Advanced Scene Switcher 1.37.2 (1 November), which needs at least OBS 31.1.1. The plugin ships installers for Windows and macOS, .deb packages for Ubuntu 24.04 and 26.04, and a Flatpak for Flatpak OBS. Both projects are GPL-2.0.

The trade-off: OBS composes and encodes its whole canvas all the time, so it uses processing power around the clock, and your schedule lives in macros instead of a calendar. In return you can cut to a browser source or a live network stream whenever you like. Set up reconnection too; our post on OBS auto reconnect for 24/7 streams has the settings.

FFmpeg concat demuxer: a loop, not a schedule

The concat demuxer reads a text file with a list of media files and demuxes them "one after the other, as if all their packets had been muxed together". The FFmpeg docs add the catch: all files must have the same streams, with the same codecs and time base. Meet that once, and FFmpeg can stream with -c copy, so it does not encode anything while on air.

1. Prepare every file to the same format. This example makes 1080p at 30 fps with H.264 and AAC:

ffmpeg -i input.mov \
  -vf "scale=1920:1080:force_original_aspect_ratio=decrease,pad=1920:1080:(ow-iw)/2:(oh-ih)/2" \
  -r 30 -pix_fmt yuv420p \
  -c:v libx264 -b:v 6000k -maxrate 6000k -bufsize 12000k -g 60 \
  -c:a aac -b:a 128k -ar 44100 -ac 2 \
  /srv/playout/ready/input.mp4

-g 60 at 30 fps puts a keyframe every 2 seconds, which is what YouTube recommends (never more than 4). YouTube also asks for constant bitrate, and 128 kbps stereo AAC at 44.1 kHz. For 1080p at 30 fps with H.264 it lists 5 Mbps as the minimum and 14 Mbps as the recommended video bitrate, so pick a value in that range that your files and your upload can carry.

2. Write the list and save it as /srv/playout/loop.txt. Put ffconcat version 1.0 on the first line, exactly as written, so FFmpeg recognises the file as a concat script:

ffconcat version 1.0
file '/srv/playout/ready/intro.mp4'
file '/srv/playout/ready/episode-01.mp4'
file '/srv/playout/ready/episode-02.mp4'

3. Stream it in a loop. Absolute paths count as unsafe, so add -safe 0. -re reads at native speed and -stream_loop -1 repeats the input forever:

ffmpeg -re -stream_loop -1 -f concat -safe 0 -i /srv/playout/loop.txt \
  -c copy -f flv "rtmp://YOUR_INGEST_URL/YOUR_STREAM_KEY"

4. Keep it running with systemd, so a crash or a dropped connection starts FFmpeg again:

[Unit]
Description=FFmpeg playout loop
Wants=network-online.target
After=network-online.target

[Service]
ExecStart=/usr/bin/ffmpeg -re -stream_loop -1 -f concat -safe 0 -i /srv/playout/loop.txt -c copy -f flv rtmp://YOUR_INGEST_URL/YOUR_STREAM_KEY
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target

What it does not do: there is no clock, no filler and no block logic. Treat the list as fixed while it runs; edit it and restart the service to change the order. Crossfades between items need filters and re-encoding, which our FFmpeg playlist loop with crossfade guide starts from. The concat demuxer is the right tool for one loop that should never stop, and the wrong one for a timetable.

Hosted playout services

The other category is online playout software that runs on someone else's servers. You upload files, build the schedule in a browser calendar, and the service encodes and sends the stream to your platforms. There is no server to patch, but you work within the features, storage and plan limits of their dashboard. We compared one of them, playout.video, with running OBS on your own streaming server on our playout.video alternative page, including its plans as checked on 7 November 2026.

What a 24/7 channel needs on the server side

Upload and traffic. Each destination takes your full bitrate, all day. One stream at 6 Mbps video plus 128 kbps audio is about 6.1 Mbit/s, which comes to roughly 66 GB a day and about 2 TB per 30 days, plus a little container overhead. Multiply by the number of platforms you send to directly.

Storage. The same 6.1 Mbit/s is about 2.8 GB per hour of programming. A library of 50 hours at that bitrate needs around 140 GB, before fillers, graphics and spare copies.

Processing. Prepared files through the concat demuxer barely load the CPU. ffplayout and OBS encode all the time, and CasparCG needs its graphics card.

Automatic restarts. ffplayout installs as a system service and the FFmpeg loop runs under systemd. OBS needs its reconnect settings and a way to start after a reboot.

A fallback. Keep a station loop or filler with music you have the rights to, so a missing file shows your logo instead of a black screen.

The right clock. Time conditions and daily playlists follow the clock of the machine they run on. Set the server's time zone to your audience's before you plan an 18:00 block.

Monitoring. A stream can look fine on the server while the platform shows nothing; see how to monitor a 24/7 live stream.

Archives. YouTube can archive a live stream automatically when it is shorter than 12 hours and says a longer one may not be captured at all, so do not count on a replay of a 24/7 broadcast.

Which playout software fits

  • A real schedule, Linux, no graphics card: ffplayout.
  • Graphics templates, Decklink output or your own automation: CasparCG Server with a client.
  • A schedule plus live segments, overlays and browser sources: OBS with the VLC Video Source and Advanced Scene Switcher.
  • One loop that never changes: the FFmpeg concat demuxer under systemd.
  • No server at all: a hosted playout service.

For the OBS route, our streaming VPS plans are built around OBS Studio, open in a web browser and stream on a 1 Gbps uplink. Storage runs from 30 GB SSD on Stone to 200 GB enterprise NVMe on Sapphire, Platinum is rated for 1080p at 30 fps or 720p at 60 fps, and graphics are mostly shared and differ per machine, so plan OBS or FFmpeg on them rather than CasparCG. For ffplayout or a plain FFmpeg loop on Linux, our VPS plans run in an EU data center with dedicated RAM and shared vCores. The Standard VPS-M has 4 vCores, 8 GB RAM, 80 GB NVMe and 10 TB of monthly traffic; ffplayout asks for 4 dedicated threads at 720p, so watch the CPU load on a test day or pick a plan with more vCores.

FAQ

What is video playout software?

Software that runs a channel from a schedule: it plays files and live inputs at set times, fills gaps with fillers and sends one continuous output to a platform. A loop repeats files; a playout system knows what should be on air at every moment.

Is ffplayout archived or still maintained?

It is maintained. On 8 November 2026 the GitHub repository was not archived, v2.7.1 had come out on 28 October 2026, 2.8.0 was in beta and the last commit was from 7 November. The old Python code lives on a separate python-v4.0 branch, whose README names 4.0 as the last Python version; the current code is Rust.

Can OBS do scheduled playout?

Yes, with the Advanced Scene Switcher plugin. Build one scene per block with a VLC Video Source playlist, then add macros with a Date condition (day and time) and a Switch scene action. A Media condition set to Ended (Playlist) can hand over to a fallback scene when a non-looping block finishes.

Does CasparCG need a GPU?

Yes. Its README requires a graphics card capable of OpenGL 4.5 and recommends Nvidia. On a CPU-only server, use ffplayout or FFmpeg instead.

How much bandwidth does a 24/7 playout server use?

Bitrate times time. A 6 Mbps video stream with 128 kbps audio uses about 66 GB a day, roughly 2 TB per 30 days, for each destination.

Sources

All opened on 8 November 2026: