Platform · jeket.

The Air Chain

The signal chain is a file.

Every chain is a Kubernetes Custom Resource. Sources, processing, graphics, analysis and egress are nodes on a graph; the operator reconciles the cluster until the graph is what is actually running. Design it in the editor, deploy it with kubectl, or generate it from your own tooling. The same file describes development, staging and air.

The Air Chain editor showing a declarative signal chain graph

Because it is a resource, everything you already do to resources works: version it, review it, roll it back, template it per venue, and diff air against staging.

The data plane

Frames do not get copied between stages.

Jeket is built on the Linux Foundation dmf-mxl SDK, the EBU Dynamic Media Facility Media eXchange Layer. Functions on the same host exchange media through shared memory; functions across hosts use RDMA. No serialisation, no copies, no format negotiation between stages.

Same host

Shared memory

Every stage in the chain reads the same buffer. Adding a processing step costs the processing, not another copy of the frame.

Across hosts

RDMA fabric

Cross-node exchange over libfabric, so a chain can span boxes without falling back to a network video protocol in the middle of your own pipeline.

Result

Sub-frame internally

Latency inside the pipeline is a function of the work you asked for, not of the plumbing between the stages doing it.

In and out

It speaks what your floor speaks.

Come in at whatever level the room is at. The pipeline downstream of ingest is identical either way, so choosing SRT today costs you nothing when you want ST 2110 later.

Ingest

SMPTE ST 2110: uncompressed video, audio and ancillary data, PTP-synchronised
SRT: contribution from anywhere, including OBS and vMix
RTSP and RTMP: ordinary cameras and ordinary encoders
MoQ: browser and low-latency contribution

Control

NMOS IS-04: discovery, so the sources panel populates itself
NMOS IS-05: connection management, negotiated from the SDP rather than static config
NMOS IS-12: device control
SCTE: break markers carried through the chain
Kubernetes API: everything above, as resources

Egress

ST 2110: back onto the facility fabric
MoQ over QUIC: sub-second live at scale
CMAF on HLS and DASH: in parallel, for everything else
SRT: to downstream production
RTMP: to the platforms that still want it

What runs in the chain

Services, not a monolith.

Each function is its own service on the graph. Use the ones you need; the rest are not deployed and do not cost you anything.

Compositing and keying

Multi-layer compositing, a downstream keyer for bugs and lower thirds, and a rendering service for animated graphics.

Switching and mixing

Video switching with frame synchronisation across sources, plus audio mixing and processing that stays in sync through it.

Breaks and playout

SCTE-driven break insertion and return, with markers carried downstream so packaging knows where the opportunities are.

Video and audio analysis

Continuous inference on the picture and the sound. Analysis is emitted as events other services and your own systems can subscribe to.

Loudness and compliance

Loudness measured against target on every programme path, with silence and level faults raised as events rather than discovered later.

Captions and timed text

Live captions with word-level timing, carried as timed text through the pipeline and out to every egress that can take them.

Deployment

One box, or a facility.

The platform scales from a single box on a desk to a multi-node cluster across a facility. It is the same code, the same graph and the same APIs at both ends, and capability is discovered from the hardware rather than sold as a tier. A node with the right NIC does ST 2110; a node without one does everything else.

Deploy on-prem with zero-touch Kubernetes on bare metal, hybrid with cloud-extended distribution, or fully cloud-native. Your infrastructure, your network, your data.

One graph. One data plane.
Every protocol on the floor.