⚿ Sign in
OWLOWL  ← Home

OWL

Greening of Streaming · Live energy measurement · GoS1

You're browsing as Anonymous · curated demo runs, live measurement, full methodology — same numbers as members see. Sign in to unlock custom inputs and uploads, or see what changes →

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.

About Greening 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 →

— W
GoS1 current power draw · Tapo P110 · device layer only
What's being measured?

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.

Why does this matter?

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

This tour — about 5 minutes
1  Video transcode — what one encode really costs
2  Energy budget — turn Wh/min into planning
3  Video enhancement — when improving video earns its watts
4  Confidence & findings — how we know a number is real
+  optional detour: AI workloads (LLM · image · RAG)
Every step opens on a real stored measurement — and you can trigger fresh runs and watch them live.

Video Transcode

What this shows

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.

What we're doing

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.

How this is measured

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.

Result

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.

Energy Budget Planner

What this shows

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.

Why it matters

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.

Wh per minute of 1080p video · VMAF 92 · measured · GoS1 · 2026-06-20
CodecCPUGPU
H.2640.3330.109
H.2650.6270.129
AV10.3490.125
Single stream · Meridian (soft live-action — low SI/TI) · the full planner adds ABR ladders, budgets and every VMAF target.
Open the energy budget planner ↗

ML Video Enhancement BETA

What this shows

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.

Why it matters

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 →

Optional AI detour · jump to Confidence anytime →

LLM Inference BETA

What this shows

How much energy each generated token costs — and how model size translates into energy use per unit of output.

What we're doing

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).

How this is measured

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.

Why mWh per token?

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.

Result

Scope: device layer only (GoS1). No amortised training cost included. mWh/token measures inference energy only — not the energy cost of training the model.

Image Generation BETA

What this shows

How much energy one AI-generated image costs — measured end to end on real hardware, not estimated from TDP or cloud benchmarks.

What we're doing

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.

How this is measured

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.

Result

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.

RAG Energy Cost BETA

What this shows

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.

What we're doing

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.

How this is measured

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.

Result

Scope: device layer only (GoS1). Network excluded. RAG retrieval adds overhead but the dominant cost remains token generation.

How We Flag Confidence

The problem

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.

The system

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

🟢 Repeatable
≥95% confident above idle and ≥ 9 task polls. Reliable enough to cite.
🟡 Early insight
≥80% confident above idle and ≥ 4 task polls. Directional, but needs a longer run before we'd stake a public claim on it.
🔴 Need more data
Not yet distinguishable from idle. We publish it anyway — but we won't cite it yet.
Why a confidence interval?

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.

The Other Half: Client Decode

Why it matters

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.

One clip, four silicon paths — measured 2026-07-30

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 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.

See it live

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 ›

Findings

Greening of Streaming · OWL · GoS1

From OWL's body of evidence — citable findings backed by stored measurements:

🟢Playing the same video, display attached: a fixed-function streaming box draws 4–7× less than a general-purpose board — even against the board's own hardware decoderv1 · 2026-07-30
BBB 1080p60 H.264, local file, screen on, marker-verified: Google TV +0.30 W · Pi 400 hw +1.32 W (4.4×) · Pi 400 sw +1.96 W (6.5×) · Pi 5 sw +2.03 W (6.8×). All 🟢.
🟡Which codec is cheapest to decode has no silicon-independent answer: a wash on hardware, up to ~60% spread in software — and the measurement regime can flip the rankingv1 · 2026-07-29
Hw (Google TV): codec spread ≤0.08 W. Sw at 1× (both Pis): h264 +1.57 < av1 +1.83 < hevc +2.56 W. Sw saturated: ranking inverts (av1 +4.15 < h264 +5.13 W).
🟢A hardware decoder cuts client decode power ~3.6× — and having the silicon isn't enough: stock software must be able to reach itv1 · 2026-07-29
Pi 400, same board, same 1080p60 file — H.264 hw +0.35 W vs sw +1.25 W playing (3.6×); +0.64 vs +2.62 W saturated (4.1×). Pi 5 (block dropped): +1.57 W.
See all findings (11) →

Want to dig deeper?

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.

Join GoS — unlock the middle column ↗ Already a member? Sign in

Same measurement quality on every tier. Members shape the inputs; everyone sees the results.


greeningofstreaming.org ↗

Scope: device layer only (GoS1). Network, CDN, CPE excluded.
LLM: no amortised training cost included.

· CPU · GPU