Run a linear channel from a playlist and live sources — switch on air, splice ads, brand it, and deliver every format at once, from a single SRT feed to a file-driven 24/7 channel. Described in config, driven from one operator console. Two ways in: by what you want to do, or by an example close to your channel.

One console, served by the running channel: the programme on air, the playlist on the timeline, the delivery lit.

Before a channel runs it is described, not coded. One form builds every playout channel as a single route through the channel's own mental model — Sources, Programme, Outputs, Ship — with a live 'This channel' manifest down the side that restates what will be built and updates on every edit. The output is a launchable product template the daemon runs; the same form is what the runner embeds when you configure a channel in place.

1. 01

   Name the inputs

   The live inputs feeding the switched programme. The one-feed case is there on arrival; a second input is one click — here an RTMP remote alongside the SRT studio — and the manifest counts both immediately.

   
2. 02

   Compose the programme

   How items are switched, formatted and composited on air: normalised switching and the flagship ladder by default, with an ad-splice axis and a branding layer each one click away. The manifest lists every axis the moment it turns on.

   
3. 03

   Choose the delivery

   Where the channel is delivered — CMAF HLS/DASH for players and an SRT mezzanine egress for downstream contribution, delivered together. At least one route must be on, and the manifest flags it if none is.

   
4. 04

   Build the template

   With every stop satisfied the manifest reads Valid and Build is enabled — one click produces the launchable product template. A stop that isn't ready keeps its check dark and the manifest names what is left to fix.

   

The operator's home while the channel runs. One screen carries the programme on air, the playlist on a live timeline, the next-switch countdown, and the line status — everything needing attention without leaving the page.

1. 01

   The channel at a glance

   The item on air with its elapsed and remaining, the timeline coloured by state, the next-switch countdown, and the line-status rail — fallback and gap-fill armed, the current run logging.

   
2. 02

   On a real channel

   The same console served by a running instance — a live programme on air over SRT, the delivery lit, and the programme hero carrying the real picture: the JPEG confidence still here, or the live MOQ preview monitor when the channel opts in. A channel with neither shows an honest no-preview, never a faked picture.

   

Every input the channel can take sits on one desk — studios over SRT, a remote feed over RTMP, dial-out contribution — each reading its own health at a glance.

1. 01

   The sources desk

   The inputs the channel is configured to take, each reading its own state, ready to be taken to air.

   

The live control surface for the running channel: the playlist with per-item state, a timeline ribbon with a live playhead, transport controls — Take, Skip, Hold, Jump — and a rebuilt item editor over the channel's own contract.

1. 01

   The playlist, live

   Each item with its scheduled time, duration and state — on air, cued, pending — with gaps derived from the real scheduled starts and a playhead riding the on-air block.

   
2. 02

   Author an item

   Adding or editing an item opens an editor over the channel's public command contract — pick a file from the media library, set the source and timing — with no hand-written config.

   

One programme, several routes out — adaptive HLS/DASH over CMAF, an SRT or UDP-TS mezzanine for downstream contribution, RTMP for origination — each with its own health and a copyable manifest.

1. 01

   The delivery surface

   The CMAF ABR output with its multivariant manifest, an SRT mezzanine egress, and the encode ladder — each with a health pill, so a failing route shows here before a viewer notices.

   
2. 02

   The delivered programme, on air

   A frame pulled straight off a running channel's SRT mezzanine — the real picture the deployment delivers, encoded by the ladder and carried out to air.

   

Two strategies, selected by what the channel composes. Local splice cuts a file ad to air over a downstream smart switch and reverts on end-of-content; SCTE-35 markers signal splice points into a clean feed for downstream SSAI to fill.

1. 01

   Local ad splice

   A file-backed ad player cut to air on cue over the programme, with a Return-to-programme control — the break reverts automatically on end-of-content.

   
2. 02

   SCTE-35 markers

   An 'ad break now' control injects a SCTE-35 cue into a clean mezzanine feed — passthrough-safe, no re-encode of the programme — with the current cue counting down.

   

Branding layers composited onto the programme by one videoCompose node, driven live from the Shot Bar — named shots (Clean Feed, L-Bar, Lower Third, Logo Bug) that each carry their own layout and graphic page, so a take can never key an empty layout. Preview loads a shot into the off-air preview browser before Take commits it; the channel airs the plain programme until a shot is taken. The generic preset picker stays one click away behind Advanced layout.

1. 01

   Preview a shot, take it live

   The Shot Bar over the videoCompose node: every branding shot keyable — the clean feed, the L-Bar squeeze, the graphic bugs — each one Preview away from the off-air monitor and one Take away from air.

   

The rolling record of what actually aired — each item logged as it transitions, with its real duration and result (aired on time, or gap-filled when content was missing), reconciled against the schedule.

1. 01

   What actually aired

   Each aired record with its result — aired on time, or gap-filled — and the current run counted at the top.

   
2. 02

   On a real channel

   The log on a running instance: the item logged the moment the channel took the next one, straight off the live deployment.

   

The floor — the smallest real channel. One SRT feed, the switched programme, the default encode ladder, one CMAF output. Everything else scales up from here.

1. 01

   On air

   A real programme arriving over SRT, on air, delivered as a CMAF ladder.

   
2. 02

   The delivered picture

   A frame off the channel's own egress — the programme it is putting to air.

   

A full-service channel: two SRT feeds the operator can cut between, file-based ad splicing, and branding layers composited downstream — the switched programme carrying more at once.

1. 01

   The switched programme

   The channel on air with the playlist on the timeline and the line status armed.

   
2. 02

   Splice an ad

   A file ad cut to air over the programme, reverting on end-of-content.

   
3. 03

   Brand it

   Named branding shots — the L-Bar squeeze, a lower third, a logo bug — previewed off-air and taken live from the Shot Bar over videoCompose.

   

The channel as a contribution link rather than a player origin. It can dial out to an upstream sender over SRT-caller and deliver two shapes at once — a CMAF ladder for players plus an SRT mezzanine for downstream contribution — or run mezzanine-only with CMAF off, the smallest shape that delivers nothing to players at all. The repo carries both as ready-made configs (srt-caller-cmaf-srt, srt-egress-only); the delivery surface is the same screen either way.

1. 01

   The mezzanine route

   An SRT egress carrying the programme downstream, here alongside the CMAF ABR output — turn CMAF off and the mezzanine stands alone, each route with its own health.

   

The showcase — one source of every v1 transport feeding the switcher, a custom encode ladder, SCTE-35 ad markers, and both a CMAF output and an SRT egress. The full input palette on one channel.

1. 01

   The full input palette

   Every transport the channel can take, each an available source on the switcher.

   
2. 02

   SCTE-35 markers

   Splice cues injected into a clean feed for downstream SSAI — passthrough-safe, no re-encode.

   

A 24/7 file channel — no live sources. The operator schedules items from a media library onto the playlist, and the programme ships one of two ways: in passthrough, the source's coded frames untouched, or re-encoded into the default ABR ladder for adaptive delivery. The same channel one encode switch apart — the repo carries both configs (file-passthrough, file-ladder).

1. 01

   A scheduled playlist

   File items scheduled as a running channel, each with its title, duration and state, and a live playhead on the on-air item.

   
2. 02

   What aired

   The as-run record of the file channel — each item logged as it aired, gap-fill covering any hole.

   
3. 03

   Or re-encoded to a ladder

   The ladder variant: the file programme re-encoded into the CMAF ABR ladder for adaptive delivery.