Prism

Recent updates

What's new

• Sep 13 '26
  One delivery path, fewer machines. Prism now delivers only through its own origin. The code that pushed into AWS MediaPackage, its signing proxy and a separate side path for audio are gone. The origin server powers down with the rest of the fleet; a second viewer box that could only decode in software and a demo playout server that ran around the clock were switched off. Between runs, only the console stays on.
• Sep 13 '26
  DASH delay 9.4 s → 3.7 s, and the player was not at fault. The DASH manifest's clock was being stamped only after the packager finished analysing its input, so the whole timeline ran 5.8 s behind reality — and the player reported it was 3 s from live while showing frames 9 s old. The origin now sets that clock from the segments themselves. Same viewer box, same manifest through the CDN: 3.7 s from glass to glass at 4K, 60 fps. Found on the way: the CDN cached any origin error for 10 s by default, so one hiccup could freeze every viewer behind that edge — turned off.
• Sep 12 '26
  Switched on in production, and Apple's tools approve. A full day of runs on the new origin: the automatic health check green at every stage, both player modes compared, a 300 Mbps run with nothing refused, and a 15-minute test with Apple's own tools on a rented Mac. Apple's stream validator passed with no must-fix items, both direct and through the CDN, after six fixes it asked for. Apple's own player reached the 8K rendition within 10 s once the origin stopped trickling the newest chunk out as it was produced. A chunk delivered at production speed makes every player believe the network is only as fast as the current bitrate. That is why no player had ever stepped up to 8K on its own.
• Sep 12 '26
  Measured against MediaPackage — same day, same probes. Delay at the origin's output 1.0 s and at the CDN edge 1.1 s at 140 Mbps, versus 2.5 and 2.6 s through MediaPackage. At 300 Mbps: 1.2 and 1.4 s, with no upload size limit in the way. Two 5.1 surround tracks arrived with every channel where it belongs. A probe bug fixed on the way had made the new path look 2 s slower than it was. New defaults: quarter-second chunks, which came in 0.4 s faster than half-second ones.
• Sep 12 '26
  A viewer that can actually play 8K. Linux browsers cannot decode HEVC, so the old viewer box only ever watched the 1080p rendition. A Windows machine with an NVIDIA L40S and Chrome decodes 8K at 60 fps and is now the reference viewer: 5.7 s from glass to glass at 8K, 3.6–3.8 s at 1080p or 4K. The gap is the player's 3-second safety buffer plus a rule in the web player that widens the buffer every time 8K stalls — understood and documented, not a measurement error.
• Sep 11 '26
  Our own low-latency origin. MediaPackage's limits were built in: a size cap per upload that held the feed to about 140 Mbps, a codec label Safari rejects, a web-player freeze at the live edge, and 1.4 s of delay we could not see into. Prism now packages on its own server. It cuts the stream into quarter-second chunks, answers a player the instant a new chunk exists, and serves low-latency HLS and DASH from one set of files. Sessions hand over cleanly. It passed 44 of 44 end-to-end checks on a laptop the first day; the cloud machines were built the next.
• Aug 25 '26
  "Partial" is not "failed". The show's five-hour recording — 313.5 GB, every received byte intact — had been labelled failed because storage briefly pushed back. Recordings now say partial (ended early, nothing lost) or failed (bytes actually lost), and the recorder rides out about 90 s of storage slowdown instead of 8.
• Aug 23 '26
  First production show. An arena fight night: 7 hours 3 minutes of continuous 8K60 transmission, 447 GB through the cloud, the whole show recorded, a venue power cut survived mid-day (the chain recovered itself in about 20 minutes while a UPS held the switcher), and a lens-to-screen delay reading at the end. Four fixes were released during the day. What the field taught — the upload cap grazing its limit at busy moments, the web player freezing at MediaPackage's live edge — is what led to the self-hosted origin.
• Aug 19 '26
  A second on-site encoder. A Blackwell-class machine set up by one script, burn-in passed, joined the fleet as a contributor the console can start and stop remotely.
• Aug 12 '26
  Accounts and partner access. Sign-in is a page in the console and the account is the email address. Three roles apply to every action — partner (read-only, plus the monitor), operator, admin — and passwords reset by email. Partners get one button, Run standard test, which starts the standard campaign from a preset the admins maintain. The live view now raises an alarm when a feed arrives at full rate but nothing comes out the other side.
• Aug 6 '26
  Player overhaul. The confidence monitor was rebuilt around the picture and a six-cell status strip; a chip says what the rig is doing right now; every number says where it comes from; an idle endpoint parks on black instead of replaying old segments as if they were live. Also: large recordings now download to the end, and the contribution receiver recovers in 7 s instead of two minutes.
• Aug 5 '26
  Stress-tested at the ceiling. Worst-case grain content, 8K59.94 HEVC at 140 Mbps, through the contribution rail: 10.7 GB in a 638 s session with zero drops and the encoder at half its hardware capacity. Packaged segments ran 17.8 MB — under the managed origin's upload cap with margin — and back-to-back sessions re-entered cleanly in seconds. Release v2026.8.11 cut the same night.
• Aug 5 '26
  59.94 is now exact, end to end. Fractional (NTSC) rates ride as true rationals, segment durations snap to whole keyframe groups (a 2 s target becomes exactly 2.002 s), and manifests declare actual segment durations — declared and delivered now agree to the microsecond, at any cadence. No integer keyframe count fits an integer second at 59.94; the pipeline stops pretending otherwise.
• Aug 4 '26
  Remote contributor control. On-prem encode boxes are now fleet members: an outbound-only agent (venue NAT never matters) converges the box to the console's desired state, and the Fleet view starts/stops the SRT contribution remotely — with saved destinations, write-only passphrases, bitrate/preset handles, and a stop-first guard so nothing ever silently retargets a live stream. Proven end to end on real rented hardware.
• Aug 4 '26
  The player probe got its own box — and the delivery numbers got honest. The real-player (post-decode) probe now runs on a dedicated instance, after measurement was caught starving the packager it measured. With the load moved, the managed origin's real cost is ~1.4 s — the earlier ~7.7 s figure was the starved box, and it is retracted. Best full-run medians then: encode 0.67 s, packager output 2.4 s, real player ≈6 s.
• Aug 3 '26
  A real camera, live, measured from the lens. An 8K cinema camera fed the chain over quad-link SDI on the on-prem contributor: 8K59.94 live end to end, 10-minute runs at 60 fps / speed 1.00× / zero drops, 75–82 Mbps delivered. A filmed optical slate anchors time-zero at the glass, so latency is lens-referenced, not encoder-referenced — the acquisition stage is now part of the measurement model, and "not measured" is never shown as zero.
• Aug 3 '26
  Surround through the managed origin, proven at the edge. 5.1 AAC delivered through the full chain with 6/6 channel identity confirmed at the CDN. The historical "undecodable multichannel" defect was root-caused: a layout whose channel map rode in an in-band descriptor the re-packager drops. The wire format is now measured per encoder build and the preflight refuses layouts that would not survive.
• Jul 31 '26
  Recording and versioned releases. Every contribution can be captured to object storage as it streams (crash-safe partial masters, integrity-hashed), with an asset library, downloads, guarded delete, and frame-exact clips. The platform itself moved to CalVer releases: CI on every merge, tagged releases, production pinned to tags with a real rollback story.
• Jul 28 '26
  Transmission mode. Beyond bounded test campaigns: unbounded runs with rolling window reports (configurable cadence), an SRT contribution leg that reconnects instead of dying silently, and honest drop accounting — outages are counted in the record, not smoothed over. Merged and locally proven, incl. a mid-run listener kill producing correct drop windows; first real-network run is next fleet session.
• Jul 28 '26
  The console grew up. One monolithic page became a seven-view operator console — Home, Test lab (a five-step builder generated from declarative field tables with a self-testing parity check), Live ops (targets strip, the health of every delivery surface, event log, rolling quality), Audio, a typed Reports system (campaigns, comparisons, channel-check records, delivery snapshots — one renderer per kind), Fleet, and the Confidence monitor. Built agent-first: an executable GUI spec gates every merge.
• Jul 23 '26
  Audio is latency-invisible — proven. Back-to-back fleet runs, video-only vs. 8K60 + 16 channels of AAC: every stage moved ≤~3% (T1 +39 ms … T5 +143 ms). Two 7.1 tracks flowed through the whole chain — SRT contribution, packager, all four delivery surfaces — with zero receiver restarts.
• Jul 20 '26
  Multichannel audio, instrumented like the video. Up to 32 channels (4×7.1 AAC tracks), each channel carrying a unique fingerprint tone so channel identity is verified, not assumed — 32 of 32 confirmed by frequency analysis through a real hardware encode. A live channel-check board solos any channel at the source mid-run (no restart) and writes an auditable line-check record with auto-verdicts — the classic broadcast fax check, with proof.
• Jul 8 '26
  Global delivery, measured per region. CloudFront now fronts the managed origin (with cryptographically signed origin access), and probe boxes in Virginia and Frankfurt read the QR straight off their local edges: the home-region edge sits ≈0.2 s behind the packager's output, Virginia ≈+0.9 s, Frankfurt ≈+1.8 s — real geographic propagation, not an estimate.
• Jul 8 '26
  Seven stages: the packager gets its own hop. The chain is now T0→T6 — the receiver (T3), the packager's output (T4), the CDN edges (T5) and the player (T6) are separate readings, so the packager's cost (~0.9 s then) and each region's CDN cost are individually visible instead of blended.
• Jul 8 '26
  The instrument audits itself — and caught its first bug. A one-click health check runs a 90 s test stream and confirms every probe reported and every stage measured. Its very first run exposed a probe decode bottleneck whose fix rewrote the story: encode and SRT transit are sub-second (≈0.46 s and ≈0.71 s) — the earlier multi-second readings were the probe's own lag. Packaging, not encoding, dominates the budget.
• Jul 8 '26
  Hardened for shared use. Per-user audit trail, campaigns that boot a cold fleet themselves (four boxes across three regions from one click), a 30-minute idle auto-stop that reclaims everything — including the regional probe boxes — and operator stops that end runs cleanly instead of as errors.
• Jul 7 '26
  Prism Console. The control plane moved to a dedicated always-on instance: TLS with per-user logins, fleet start/stop from the browser, and campaigns relayed to the GPU encoder — operators never need shell access.
• Jul 7 '26
  Prism Player. A hosted player that plays any endpoint (HLS, low-latency HLS, or DASH), reads the QR code off the picture for true glass-to-glass delay, shows its buffer, bitrate and segment telemetry, and feeds the player stage into the pipeline graph.
• Jul 7 '26
  Viewing ladder. Delivery now carries two variants: the bit-exact 8K HEVC measured product plus a universal 1080p H.264 preview transcoded once on the receiver's GPU — any laptop can watch, and viewers can lock either variant in the player.
• Jul 7 '26
  Managed origin validated. The pipeline ingests into AWS MediaPackage v2 without a MediaLive channel in front (a small signing proxy keeps Prism's encoder in the path), the QR code survives re-packaging, and one set of chunks serves HLS, low-latency HLS with real partial segments (~4.7 s fresh), and DASH.
• Jul 6 '26
  Correlation gate closed. Known-delay injection now passes in both directions (encode +471 ms, SRT +523 ms, each rising alone) — the check that makes every latency number trustworthy.

The measurement model

One timestamp, followed from the lens to the screen

Every frame carries a small QR code holding the moment it was created. Wherever a probe sees that frame, the delay is simply how old the frame is — no clock arithmetic between machines, no guessing. With a real camera there are two starting points, kept apart on purpose: pipeline delay counts from the encoder's stamp (T0→T6); glass to glass counts from the scene itself, read off a clock displayed on set that the camera films — the camera slate page, a full-screen QR clock any display can show.

Precise stages catch each frame and measure its own age; freshness stages fetch whatever is newest at that point and measure how old it is. The camera stage is kept separate from the T-stages on purpose: a single frame that shows the filmed clock and carries the encoder's stamp gives lens-to-capture time with the observer's clock cancelled out, but it has its own error sources (display lag, exposure, how well the two clocks agree), and every report states them. Every run discards its warm-up and starts its counters from zero, so the numbers are steady-state, not the first noisy seconds.

Capabilities

What it does

The whole chain in one platform — from a test source or a real camera to the viewer's screen — with the measurement an ordinary encoder cannot give you.

What you put it to

What it lets you test

The questions a delivery chain actually raises — answered on real hardware and a real network, with numbers you can trust and compare.

Seen live

The pipeline graph, mid-run

The console's live T0→T6 graph during an 8K run across the fleet — the encoder, the receiver, the origin, the CDN edge and the real viewer drawn as one chain, each node showing how old the picture is by the time it gets there and how many frames it read.

Every figure is the picture's age at that point, from an 8K60 run on 2026-09-13 (140 Mbps, two 5.1 tracks). Encode and contribution catch each frame; the receiver (T3) reads the newest segment it has packaged, so it can sit below the contribution figure — different methods, both labelled. The origin (T4) and the CDN edge (T5) are read per quarter-second chunk, one frame per chunk, which is why their counts are lower. T6 is the real viewer: fetch through the CDN, buffer, hardware decode, render — everything a viewer experiences, read off the rendered picture; here the 8K-capable box watching the DASH stream at 4K. At the edge the chain fans out per region: US East reads level with the home edge, Frankfurt about 0.15 s behind it (2026-09-12).

The rig

Hardware & cloud

The validated results run on AWS — a small fleet across three regions — but nothing here depends on AWS.

Where it stands

Validated so far — and what's left

The chain is proven end to end at 8K — from a real camera, through Prism's own low-latency origin, to a real 8K-capable viewer, and through a seven-hour production show. What remains is about wider audio, endurance and resilience — none of it blocks the numbers that already work.

What's next

Roadmap

Where Prism is headed, grouped by horizon — roughly the order it will land.