Greening of Streaming · Live energy measurement · GoS1
OWL measures the real energy cost of video transcoding and AI inference — using a calibrated smart plug, not estimates. Every number on this page comes from a live measurement on GoS1, a server in our lab in France.
OWL is built by Greening of Streaming — a global, member-driven non-profit working to reduce the energy footprint of streaming.
Mission. Reduce the environmental impact of streaming through energy-efficient solutions and industry collaboration.
No greenwashing. Every public claim is backed by verifiable data and real-world implementation.
A network of member organisations collaborating through Labs — working groups that produce research, build measurement tools like OWL, and publish recommendations. Membership is open across the streaming ecosystem.
Learn more at greeningofstreaming.org →
GoS1 is an AMD Ryzen 9 workstation with an NVIDIA GeForce RTX 5080 GPU. Power is sampled via Tapo P110 at 1-second intervals on each of two staggered meters, connected to the mains supply. We measure the delta between idle baseline and task power — not estimated TDP or nameplate figures.
Scope: device layer only. Network, CDN, and CPE are explicitly excluded. Amortised embodied carbon and training cost are not included in LLM measurements.
Streaming accounts for a significant and growing share of global internet traffic. Codec choice, inference model size, and hardware path all affect real energy use — but most published figures are estimates or averages. OWL produces primary measurement data that operators and researchers can reproduce and cite.
→ Read the full measurement methodology protocol, confidence framework, scope statements, calibration
Whether transcoding to the same quality target uses more energy on CPU or GPU — and whether the faster path is also the more efficient one.
Encoding a 2-minute 4K clip (Meridian, Netflix Open Content, CC BY 4.0) to 1080p — once in software on the CPU and once as a full GPU pipeline (hardware decode + scale + encode via hevc_nvenc, or av1_nvenc on the AV1 chip). Same source. Same per-codec bitrate target. Tapo P110 sampled at 1-second intervals on each of two staggered meters throughout.
5s idle baseline before each run. 10s thermal cooldown between CPU and GPU. Energy = ΔW × duration / 3600. Confidence: each run carries a per-run confidence interval — 🟢 needs ≥95% confidence above idle and ≥ 9 task polls (the full story is the Confidence step, later in the tour).
Source: 3840×2160 · 59.94fps · H.264 · 2min · ~122MB · fast demo. The Result panel below always shows the most recent stored run.
Scope: device layer only (GoS1). Network, CDN, and CPE not included. A faster encode does not automatically mean less energy — this measures total Wh, not rate.
The same measurements, flipped into the operator’s question: given an energy budget and a quality target, how much video can you actually ship? Pick a VMAF target (92 by default — the figure transcoding farms cite) and OWL shows how many hours each codec and hardware path buys you, from real measured curves.
It turns Wh-per-minute into planning — the H.264 / HEVC / AV1 and CPU-vs-GPU decision, sized to a budget, measured rather than estimated.
| Codec | CPU | GPU |
|---|---|---|
| H.264 | 0.333 | 0.109 |
| H.265 | 0.627 | 0.129 |
| AV1 | 0.349 | 0.125 |
Step 1 spent energy to shrink video. This flips the question: what does it cost to make video better? A machine-learning enhancer on the lab GPU takes a rough, low-resolution clip and denoises and upscales it — and OWL meters the watt-hours at the wall and scores the quality before and after, like every other workload on the bench.
The showcase below: real 2005 phone footage — 544×408, heavily compressed — machine-upscaled to 4K for a couple of watt-hours. Watch the two previews, then read what that difference cost in the card underneath.
How to read the card: the quality line is a no-reference score of the source vs the enhanced output (higher is better) — the measured quality change the watt-hours bought. Energy and duration cover the whole enhancement run, metered at the wall like every OWL measurement.
Operators handed an imperfect feed can weigh enhancing it against its real energy cost — and see where enhancement earns its watts and where it just burns them.
Running an enhancement yourself is a member feature — each run holds the lab GPU for real minutes, and an open free enhancer would turn the measurement bench into a video-improvement service. Members: sign in and open ML Video Enhancement →
How much energy each generated token costs — and how model size translates into energy use per unit of output.
Running a fixed prompt (T3, long generation — a technical briefing on network energy attribution) through Qwen3 4B cold: model unloaded before baseline so we capture the true first-request cost. GPU inference via Ollama (CUDA).
Model unloaded from VRAM. 3s settle. 5s idle baseline. Single inference run. Tapo P110 at 1-second intervals on each of two staggered meters. Primary metric: mWh per output token.
Model: Qwen3 4B (2.5 GB). The Result panel below always shows the most recent stored run.
Token count varies between models and prompts, so raw Wh figures aren't comparable. Energy per token puts a 1-billion-parameter model and a 20-billion-parameter model on the same axis, so model size can be traded off against energy directly. The Findings step carries the citable numbers.
Scope: device layer only (GoS1). No amortised training cost included. mWh/token measures inference energy only — not the energy cost of training the model.
How much energy one AI-generated image costs — measured end to end on real hardware, not estimated from TDP or cloud benchmarks.
Running SD-Turbo (stabilityai/sd-turbo, CPU, 8 steps, 512×512) with a randomly modified prompt — the colour modifier changes each run to prove the image is generated live, not replayed from cache.
5s idle baseline. CPU diffusion run. Tapo P110 at 1-second intervals on each of two staggered meters. Metric: Wh per image = ΔW × generation_time / 3600.
The Result panel below always shows the most recent stored run.
Scope: device layer only (GoS1). Network and storage excluded. This measures one image on one machine — not the energy cost of a hosted API call.
Whether retrieval-augmented generation (RAG) — searching a local corpus before answering — costs meaningfully more energy than plain inference, and see the difference in context size the model must process.
Running three modes back-to-back on Qwen3 4B: baseline (no retrieval), RAG (small corpus), and RAG Large (with re-ranking). Same question, same model, same hardware — only the retrieval pipeline changes.
Each mode: 5s idle baseline, inference with Tapo P110 at 1-second intervals on each of two staggered meters. Metric: mWh per output token. ChromaDB embeddings via sentence-transformers. Corpus: academic papers on streaming energy.
Scope: device layer only (GoS1). Network excluded. RAG retrieval adds overhead but the dominant cost remains token generation.
Not every measurement we take is equally trustworthy. System noise — Tapo P110 quantisation, OS jitter, Wi-Fi polling variance — is real. A task that adds a small delta above baseline might be signal or artefact. We need a principled way to say which.
Every result carries a traffic light. As of CR-028 Phase 2 it's a per-run
confidence interval — "can this run be told apart from idle?" — not a fixed
watt rule.
confidence = Φ(ΔW / SE), SE from this run's noise + the calibrated idle floor
Fixed thresholds (e.g. "5W = green") don't adapt to the machine's actual noise level. Instead we take this run's own baseline + task power samples, form a standard error on ΔW (worst case of the run's observed noise and the calibrated idle floor, plus a drift term), and turn ΔW into a one-sided confidence that the task draws above idle. A short run can't go green on a couple of lucky readings — it also needs enough task polls.
On any result page, click a 🟢 🟡 🔴 badge for a quick reminder of the formula.
Everything so far measured the server. But encode energy is paid once per title — decode energy is paid per viewer, per hour. OWL's decode rig applies the same method (idle baseline, ΔW, confidence flags) to real playback devices: two Raspberry Pis and a Google TV streamer, each on its own milliwatt meter, sharing one measured screen.
Same 1080p60 file, local delivery, display attached, all rows 🟢 with in-band black/white markers verifying the screen showed real content:
| Google TV — fixed-function | +0.30 W | 1× | run |
| Pi 400 — hardware H.264 | +1.32 W | 4.4× | run |
| Pi 400 — software | +1.96 W | 6.5× | run |
| Pi 5 — software (hw block dropped) | +2.03 W | 6.8× | run |
A purpose-built streaming box plays the same video for 4–7× less energy than a general-purpose board — and a device generation that drops a decoder block (Pi 5) loses its efficiency to software. Invisible on any spec sheet; visible at the wall.
The rig is a public page: live device tiles, recent runs, and every result's raw per-second samples as CSV/JSON. Open the decode rig ›
Greening of Streaming · OWL · GoS1
From OWL's body of evidence — citable findings backed by stored measurements:
OWL has three access tiers. The numbers and methodology you've just seen are identical for all three — what changes is who can shape the inputs (custom prompts, custom ffmpeg, all-codecs sweeps, your own corpus, full settings access).
| Public | GoS member | Lab (operator) | |
|---|---|---|---|
| Pre-baked workloads, live wall-power & CO2e | ✓ | ✓ | ✓ |
| Guided tour, methodology, recent-run history | ✓ | ✓ | ✓ |
| Custom video upload | — | ≤ 1024 MB | no cap |
| Custom prompts & custom ffmpeg commands | — | ✓ | ✓ |
| All-codecs sweeps, batch / compare-modes | — | ✓ | ✓ |
| RAG corpus upload (your own PDFs) | — | ✓ | ✓ |
| CSV / JSON export of your runs | — | ✓ | ✓ |
| Edit settings, run variance calibration, full results view | — | — | ✓ |
Lab tier is granted automatically on the GoS1 LAN (loopback / 192.168.x). There's no public sign-up for Lab — it's the operator surface for the bench itself.
Same measurement quality on every tier. Members shape the inputs; everyone sees the results.
Scope: device layer only (GoS1). Network, CDN, CPE excluded.
LLM: no amortised training cost included.