Forem: Bruno Aggierni 🇺🇾

🚀 Meet CTV Bridge: The Open-Source Desktop App That Simplifies Tizen, webOS & AndroidTV Development

Bruno Aggierni 🇺🇾 — Fri, 30 Jan 2026 12:45:55 +0000

Developing apps for Samsung Tizen, LG webOS and AndroidTV TVs usually means juggling two SDKs, multiple CLI tools, different packaging formats, and long build/deploy cycles (Basically, a living hell).

After years of dealing with this workflow (and getting extremely frustrated with 1000 coffees in my bloodstream), I built something to fix it.

Meet CTV Bridge. A free, open-source desktop tool that unifies the entire Connected TV development workflow for both Samsung Tizen, LG webOS and AndroidTV.

👉 GitHub: https://github.com/Braggiouy/ctv-bridge
👉 Latest Release: https://github.com/Braggiouy/ctv-bridge/releases

🎯 What Is CTV Bridge?

CTV Bridge is a cross-platform Electron app (macOS, Windows, Linux) built with React and TypeScript. It provides a simple and unified UI for device management, deployment, and debugging.

It supports TVs from 2015 onward and requires zero CLI knowledge.

⭐ Key Features

🖥️ 1. Multi-Platform Support

Samsung Tizen
Full integration with Tizen Studio CLI
LG webOS
Full support for webOS CLI tools
Android TV
ADB-based deployment and debugging

Configure all SDK paths directly in the app (no ENV variables required)

⚡ 2. One-Click Deployment

Automated Builds: Build .wgt .ipk and .apk packages automatically.
Smart Logic: Automatically handles uninstallation of old versions and installation of new packages.
Instant Launch: Auto-launches your app on the TV after deployment.
Live Logs: Stream real-time deployment logs and detailed CLI output directly in the UI if something goes wrong.

🐞 3. Advanced Debugging

Built-in Inspector: Launch the webOS Inspector with Chrome DevTools in one click.
Debug Mode: Automatically launches your app with debugging enabled.
Run apps in debug mode via ADB. Stream logcat output directly in the app

📱 4. Unified Device Manager

Custom Naming: Manage all your TVs by name, not just IP addresses.
Auto-Detection: Smart SSH key handling and connection guidance.
Connection Doctor: Built-in troubleshooting for connection issues.
Secure Storage: WebOS passphrases are stored securely in your system's keychain.

🧩 Technical Overview

Tech stack: Electron + React + TypeScript
License: MIT
Privacy-focused: All data stored locally or in your system keychain.
Auto-update notifications included.

🏁 Getting Started

Download the latest release.
Install required SDKs:
- Tizen Studio (Samsung)
- webOS CLI (LG)
- Android SDK / ADB (Android TV)
Open CTV Bridge and configure SDK paths.
Add your TV device (and give it a custom name!).
Click Deploy to build, package, install, and launch your app.
That’s it. No terminal required.

Contributions and feature requests are welcome!

⭐ Try CTV Bridge If you build Smart TV apps, give it a try and if it helps you, consider starring the repo!

👉 GitHub: https://github.com/Braggiouy/ctv-bridge
👉 Releases: https://github.com/Braggiouy/ctv-bridge/releases
👉 Issues / Feature Requests: https://github.com/Braggiouy/ctv-bridge/issues

🚀 Just Launched My Smart TV / OTT Portfolio 📺

Bruno Aggierni 🇺🇾 — Sun, 11 Jan 2026 19:05:26 +0000

This isn’t a typical personal website.

As a Frontend Engineer with a focus on OTT, Streaming, and SmartTV applications, I wanted to do something different.

🔗 Live demo: https://braggio.dev/

It’s a TV-first streaming app pretending your browser is a Smart TV 📺

(yes, you can navigate it with ↑ ↓ ← → + Enter).

What’s inside? 👀

Remote-first navigation (actual TV-style focus, not “tab until it works”)
Real-time QoS dashboard (bitrate, buffer health, dropped frames)
Multiple video players under one abstraction (Shaka, HLS.js, Dash.js, Video.js, RX Player)
React 18 + TypeScript + Vite
@noriginmedia/norigin-spatial-navigation doing the heavy lifting
Tailwind CSS + shadcn/ui (glassmorphic dark vibes)
Three.js via @react-three/fiber because… why not ✨

💡 The idea was simple:

My portfolio shouldn’t talk about OTT apps I develop. It should be one.

If you’re into frontend, OTT, Smart TV apps (or just curious), I’d love to hear what you think 😃 🍿

🎬 The Beginner’s Guide to Open-Source Web Video Players for OTT Front-End Developers

Bruno Aggierni 🇺🇾 — Wed, 19 Nov 2025 16:15:05 +0000

`Introduction : What the F is this?`

If you're getting into OTT (Over-The-Top) streaming development (whether for Smart TVs, web platforms, streaming startups or whatever crazy project you are working on), understanding video players is a must.

This article explains, in a beginner-friendly way:

✔ What a video player actually does
✔ The difference between HLS and MPEG-DASH, as well as what DRM is
✔ List of (IMO) the best and most used open source OTT video players

`What Exactly Is a Web Video Player?`

A web video player is the part of a streaming app that:

Displays the video (of course 🤦)
Controls playback (play/pause/seek)
Loads segments over the internet
Manages adaptive streaming (quality changes)
Handles DRM (if required; More on this in a future article)

Under the hood, a player works on top of HTMLVideoElement, and may rely on:

MSE (Media Source Extensions) → lets the player feed video chunks to the browser
EME (Encrypted Media Extensions) → required for DRM

`Streaming Formats You MUST Know in OTT`

Most OTT services rely on Adaptive Bitrate Streaming so video quality adjusts to network conditions.

Format	Description	Used By
HLS (.m3u8)	Adaptive streaming from Apple, extremely common on Web & TV	Apple TV, iOS, Safari, many web players
MPEG-DASH (.mpd)	Open standard adaptive streaming	Android TV, Tizen, WebOS, set-top boxes

Quick Tip: Most professional OTT apps support both formats.

`The Essential Open Source Players for OTT`

Personal list, order not relevant

`1 - Video.js`

Best for: Getting started, building full featured web streaming UIs
Supports: HLS, DASH (via plugins), subtitles, ads, analytics
Why it’s great: Easy to learn, huge plugin ecosystem

Great for beginners
Used by many streaming platforms
Fully customizable UI

👉 Recommended for beginner OTT developers.

`2 - HLS.js`

Best for: Web apps streaming (HLS only).
Supports: HLS via MSE for Chrome/Firefox (Safari supports it natively)

Browser support quick tip:

Safari plays HLS natively — Chrome/Firefox do not.
HLS.js fixes that.

Lightweight
Can be used standalone or inside Video.js
Ideal for live streaming and VOD when only HLS is required

👉 Recommended for HLS format handling and Apple developers.

`3 - Shaka Player (Google)`

Best for: Production OTT apps, DRM, multi-CDN environments
Supports: HLS, DASH, Widevine/PlayReady/FairPlay DRM
Why it’s pro: Extremely reliable ABR (adaptive bitrate logic)

Used in enterprise streaming. Excellent for serious OTT engineering (and not so serious OTT engineers 😈) .

DRM support out of the box
Powerful development APIs
Great performance on Smart TV browsers

👉 Recommended for advanced OTT developers.

`4 - Dash.js`

Best for: Services that stream (MPEG-DASH only)
Supports: Adaptive DASH streaming (reference implementation)

Maintained by the DASH Industry Forum
Reliable ABR algorithms
No built-in UI. You must create your own controls

👉 Learn if you work with DASH-only pipelines.

`5 - RxPlayer (by CANAL+)`

Best for: production grade, customizable DASH/HLS playback
Supports: HLS, DASH, DRM, low latency streaming, offline playback

Designed for real OTT use cases
Strong performance on Smart TVs
Very robust streaming engine

👉 Recommended for advanced OTT developers.

`Streaming Player Comparison (HLS / DASH / DRM)`

Player	HLS	DASH	DRM Support	Integration Complexity
Video.js	⚠ via VHS/HLS.js/Shaka	⚠ via contrib-dash/Shaka	⚠ Depends on engine/plugin	Easy/Medium
HLS.js	✔ Desktop: via JS, Safari: native	❌	⚠ Widevine requires EME, FairPlay handled natively in Safari/iOS	Medium
Shaka Player	✔	✔	✔ Widevine / PlayReady, ⚠ FairPlay only Safari/iOS	High
Dash.js	⚠ CMAF-HLS only	✔	⚠ Requires EME for DRM	Medium–High
RxPlayer	✔	✔	✔ Widevine / PlayReady	High

DASH not supported by HLS.js FairPlay supported only in Safari/iOS natively

`Which Player Should You Learn First? (And suffer in the process)`

Getting started with OTT streaming can feel like a jungle 😅.

Here's a simple path I’d recommend:

Step 1 — Start with Video.js

Video.js is your playground for learning the basics. It lets you:

Play HLS (.m3u8) and DASH (.mpd) via plugins
Add subtitles (WebVTT)
Control playback with JS APIs
Customize your UI (buttons, progress bar, volume, etc.)

Quick tip: HLS works out-of-the-box on Safari/iOS. On Chrome/Firefox, Video.js uses HLS.js or VHS behind the scenes.

Step 2 — Dive into HLS.js

Handles HLS on browsers that don’t support it natively
Lets you play with adaptive streaming and MSE
Can be used standalone or inside Video.js for more control

Step 3 — Level up with Shaka Player

Plays HLS and DASH
Supports DRM (Widevine/PlayReady, FairPlay on Safari/iOS)
Smart TV ready
Advanced ABR logic for smooth playback

If your goal is Smart TV or professional OTT apps, learning Shaka is essential in my opinion. It's like a "Swiss Army Knife" in the industry.

Quick tip: Don’t rush. Start with Video.js, understand HLS.js, then move to Shaka when you feel comfortable with playback, ABR, and DRM.

`OTT Streaming Glossary used`

Concept	What It Means / Why It Matters
HLS (.m3u8)	Apple’s adaptive streaming format. Works natively on Safari/iOS, requires JS players elsewhere (HLS.js/Video.js).
MPEG-DASH (.mpd)	Open standard adaptive streaming. Supported widely on Android TV, Tizen, WebOS, and most modern browsers.
ABR (Adaptive Bitrate)	Adjusts video quality automatically based on network speed to avoid buffering.
DRM (Widevine, FairPlay, PlayReady)	Protects premium content; FairPlay works only natively on Safari/iOS. Widevine & PlayReady require EME integration.
CDN Delivery	Content Delivery Network. Distributes video globally to reduce latency and buffering.
Manifest / Playlist	File linking video chunks (`.m3u8` for HLS, `.mpd` for DASH). Player reads this to stream content.
MSE (Media Source Extensions)	JS API that allows feeding video chunks to the browser for adaptive streaming.
EME (Encrypted Media Extensions)	JS API required for DRM playback in browsers (Widevine, PlayReady).
VOD (Video on Demand)	Pre-recorded streaming content that users can watch anytime.
Live Streaming	Real-time streaming of events; requires low-latency and ABR handling.
Segment / Chunk	Small piece of video streamed separately to allow adaptive bitrate and smooth playback.
Low-Latency Streaming	Reduces delay between broadcaster and viewer, important for sports, auctions, or interactive content.
Player Engine / Framework	The underlying JS library or player (Video.js, Shaka, HLS.js) that handles playback, ABR, DRM, and UI.
Plugins / Extensions	Add-ons for Video.js or other players to support DASH, subtitles, analytics, ads, etc.

If this helped you, consider sharing it with other devs starting in OTT 🚀  
💬 Suggestions, fixes, or improvements are always welcome in the comments!

Made with ❤️ for the streaming developer community by Braggio - GitHub

Free OTT Streaming Cheat Sheet (HLS, DASH, DRM, ABR & More)

Bruno Aggierni 🇺🇾 — Tue, 18 Nov 2025 10:56:00 +0000

If you're learning about OTT (Over-The-Top) video streaming, Smart TV apps, or working with web video players, this cheat sheet will help you understand the essential terms used in the streaming industry.

(And will help me get back here whenever I forget about a term 😅 )

⚠️ This cheat sheet is evolving. More terms and explanations will be added over time.

📌 Key OTT Streaming Terms

Term	Category	Summary
HLS (.m3u8)	Format	Apple adaptive streaming format widely used in OTT
MPEG-DASH (.mpd)	Format	Open standard adaptive streaming format
Manifest (Playlist)	Streaming Concept	File listing video segments, audio, and subtitles
ABR (Adaptive Bitrate)	Streaming Concept	Automatic quality switching based on network speed
DRM	Security / Playback	Protects premium content from unauthorized access
Widevine / PlayReady / FairPlay	DRM Systems	Most common DRM platforms for web & Smart TVs
MSE	Browser API	Browser API for feeding video chunks to playback
EME	Browser API / DRM	Browser API required for encrypted playback
Segment / Chunk	Streaming Concept	Small pieces of video (chunks) delivered during playback
VOD vs Live	Streaming Type	On-demand vs real-time streaming content
CDN	Delivery	Content Delivery Network for fast global streaming

💬 Feedback or Suggestions?

If you want me to expand this cheat sheet into a full OTT Developer Handbook, or include topics like:

Codecs (AV1, HEVC, VP9, AVC)
SSAI (Server-Side Ad Insertion) vs CSAI (Client-Side Ad Insertion)
Multi-CDN routing

Drop a comment below!

Follow me on Dev.to to get notified when new articles are out 🚀

Made with ❤️ for the streaming developer community by Braggio - GitHub