NULLDRM — My Computer

3 ways How it works Add apps Suite Swarm Open source

NULLDRM

self-hosted capture · decrypt · restream

Free forever · no licenses · open source before end of 2026

One suite, three ways to run it: tools alone on your desk, a VPS restreamer with a phone agent that heals down channels, or join a swarm where everyone contributes the subscriptions they already own. No paid tiers. No license keys. No “pro” unlock.

Welcome

Three ways — Wizard

Pick the level that fits. Same toolkit underneath — you decide how much automation and how much cooperation you want.

1

Tools alone

Capture · unlock · restream on your machine

Use the CLIs and helpers by themselves. Log Widevine licenses, pull keys, decrypt, and restream locally (or pack HLS for VLC). No VPS required. No always-on agent. You run a capture when you need fresh material.

Phone MITM or catalog/CDM helpers
One-shot capture when a key expires
Full control, zero swarm

2

VPS + phone agent

Host the restreamer · agent heals downtime

Run streamd on a VPS (or home server) so channels stay restreamable. Plug a phone into a machine running the agent. When a stream goes down or keys go missing, the agent notices, opens the app, collects new keys, and posts them back — then the restreamer restarts with fresh credentials.

streamd serves HLS + dashboard on the VPS
Agent watches health on a loop
Your phone(s) automate key refresh

3

Join a swarm

Many owners · one restream grid

A host runs streamd and configures which channels the swarm should keep alive. You point your agent at that host and contribute only the channels you own — maybe you have Sky, someone else has Virgin, someone else has a free-to-air app. Nobody needs every subscription. The swarm covers the lineup together.

Host defines the channel list
Contributors bring phones + the apps they can legitimately open
When a feed dies, any matching agent in the swarm can refresh it

That is the point of the swarm: distributed ownership. One person should not need every platform. Many agents, many subscriptions, one shared restream.

How it works — Help and Support Center

Under the hood (from the project docs):

Phone (ADB) + appproxy MITM
        │
        │  mpd/hls + key + pssh
        ▼
   ┌────────────────────────────┐
   │  streamd  (:8083)          │
   │  SQLite + dashboard + API  │
   └─────────────┬──────────────┘
                 │ credentials
                 ▼
        NRE + ffmpeg → local HLS

   agent (laptop / mini PC / many nodes)
   poll → queue → free device → open app
   → capture → POST credentials → close app

Capture paths

Phone MITM — on-device HTTPS proxy + ADB automation when the app must play for a live session.
Catalog / CDM helpers — some apps expose enough catalog + license material to fetch keys without opening the UI.

What you run

Piece	Role
`streamd`	Web control plane — streams, health, claims, credentials, HLS workers (the VPS / host)
`agent`	Always-on refresher — down channel → phone capture → POST new keys
`capture` / helpers	One-shot phone or catalog capture (mode 1, or manual fallback)
on-device proxy	HTTPS MITM + discover for unknown apps

Tip Posting new credentials to a running stream hard-restarts the media worker so NRE/ffmpeg pick up the new MPD and keys.

Add apps — Module wizard

New streaming apps plug in through a module system. The capture core stays generic; each app is a small module that teaches the agent which package to open, where to tap on screen, and any license / manifest hints it needs.

What a module configures

App identity — name, Android package, channel list
Launch — how to start the app over ADB
Screen automation — taps / navigation to land on a channel and hit play (coordinates or UI flow)
Capture hints — license URL patterns, PSSH / key paths, headers
Optional rewrite — manifest helpers when a stream needs them

Extend the core API

Simple apps can stay config-light: package + click map + hints. When that is not enough, a module can extend the core API — custom launch logic, richer auto-play, discover hooks, or app-specific post-processing — without forking the whole agent.

pkg/app/<yourapp>/
   Register("yourapp") → App module
        │
        ├─ Package / Channels
        ├─ Launch + AutoPlay (screen taps)
        ├─ CaptureHints
        └─ optional API extensions
                │
                ▼
        agent / capture core (unchanged)

Tip Ship a module, register it, point streamd at app=yourapp. Agents that have the APK installed can then automate that channel in a swarm.

Suite — Program Files

Widevine logging

Capture license exchanges, PSSH, and content keys. Thin CDM helpers where needed — operator-owned device identity.

ADB phone toolkit

Pool of serials. Launch the app, land on the channel, start playback, force-stop clean so the next job is not fighting a ghost proxy.

HTTPS MITM / discover

On-device proxy, request dumps for apps you have never seen. Discover first — automate second.

streamd

Self-hosted dashboard + API + NRE/ffmpeg workers into local HLS. Your token. Your disk. Your host.

One-shot CLIs

Capture a channel now. Catalog helpers when the phone can stay in the drawer. Scripts for local restream / VLC checks.

Operator docs

Folder maps, Brightcove notes, deploy crumbs — written for people who SSH at 2am.

Swarm mode — Network Neighborhood

Mode 3 in detail. The host is just someone running streamd and publishing which channels they want kept alive. Contributors run agents pointed at that host.

Host configures the channel list (Sky sports, Virgin entertainment, free apps, …)
You join with an agent + phone that has your apps / logins
Agent only picks up work for channels it can actually open
Fresh keys / manifests POST back to the host → restream continues
If your box sleeps, another contributor with the same app can cover

Example lineup: one person covers Sky, another covers Virgin Media, another covers a public broadcaster app. The host restreams the combined grid. Nobody bought the whole universe.

Every node is self-hosted — the host picks who may write credentials
No mandatory central SaaS; swarms are voluntary
Start alone (mode 1 or 2), grow into a crew when you are ready

Open source — Coming soon

Under construction

Public release targeted before the end of 2026.

What we intend to publish: streamd, agents, capture/MITM tooling, the app module system, docs, and the three-way self-host / swarm story — all free to use and extend.

There will be no paid license, no seat count, no “enterprise binary”. If you can run it, you can use it. Modules you write stay yours to share.

What stays on you: devices, accounts, keys, and what you choose to restream. Tools are neutral; operators are not excused.