WattOps shows, live, what every GPU, job and team draws and costs, finds the GPUs that are on but idle and what they cost you, and writes the energy and carbon reports your finance, sustainability and grant offices ask for. Measured from the hardware, not guessed.
Just you and a GPU? pipx install landauer-gap gives you joules: one command, a real measurement, free for good.
Every GPU that is switched on or held by a job but doing nothing, live: how many, for how long, and the power and money it burns at your own price per kWh.
“6 GPUs idle now · 1,020 idle GPU-hours this month” How Live works →Energy, cost and CO₂ for each Slurm job, Kubernetes pod and user, so shared clusters can show back or charge back what each group used.
“chem-lab: 1,240 GPU-hours · 496 kWh” See an example →PDF energy and carbon reports per project, with the method, the inputs and a report ID anyone can reproduce: for CSRD, Scope 2, the EU AI Act and grant offices.
“Q3 energy report · ID 7F2A-…” What is in a report →HorneSci builds HST for sparse and incremental computation. With joules compare on six machines, it found where HST beats an optimized baseline, and where it does not.
Run joules connect on each GPU server, Slurm node or notebook, and the Live page shows what the fleet draws right now, what it costs by the hour, and which GPUs burn power doing nothing. A stock ticker, for electricity.
Each machine reports every 5 seconds. Heartbeats never count against your API calls.
On a shared cluster, everyone pays for the power and nobody knows who used it. joules agent runs on each node and splits each GPU’s and CPU’s measured energy between the jobs on it: Slurm jobs, Kubernetes pods, containers or users.
Group it by account, project or user, see it on the Tracking page, export it, and send each group its share every month. No Prometheus or Grafana stack to run.
Universities and public research: half price on every paid plan.
Illustrative numbers, measured the way joules agent does on each node · electricity at $0.12 per kWh · 127 g CO₂ per kWh
Charge each lab its measured share of the cluster’s power, find the idle GPUs, and hand the sustainability office and grant applications a report, without running your own Prometheus and Grafana stack.
Half price for universities and public researchSee the whole fleet live, find the GPUs that are on but idle and what they cost, and give each project its measured energy, cost and carbon.
Fleet: a plan for your fleet, starting with a pilot on your own clusterKnow what each training run and each model really costs to run, get an alert when a change makes it use more, and report the energy to your customers and your sustainability team.
Free to start, then priced by the GPUs you runFinance, sustainability and grant offices, and more and more regulators, ask how much energy your computing used. Paid plans turn the measurements into a PDF per project or per month, with the method written out. For example, providers of general-purpose AI models must keep technical documentation that includes the model’s known or estimated energy consumption (AI Act, Article 53 and Annex XI). Where the energy is not known, Annex XI allows it to be estimated from the computational resources used. That is exactly what WattOps computes, with the method written out.
The reports are PDFs with the inputs, the derivation, the assumptions and a report ID. Anyone can check the ID by running the same inputs again. The same figures support Scope 2 carbon reporting (CSRD, GHG Protocol) and customer sustainability questionnaires.
WattOps is a calculation tool, not legal advice. Check your obligations with your own counsel.
Install joules and start joules agent on each GPU server or Slurm node, by hand, with your config tool, or as a Kubernetes DaemonSet. It reads the power meters about once a second, next to your jobs, not inside them.
sudo joules agent --track fleet
Within seconds the Live page shows every machine’s power and cost, the idle GPUs, and the jobs running now. Finished jobs land on Tracking with their energy, cost and CO₂.
#/live · #/track
Turn idle GPUs off or reschedule them, send each lab its share, get an alert when a job uses far more than usual, and download the monthly report as a PDF.
Slack · Discord · webhook · PDF
AI compute is limited more and more by the power it can get, and some teams are now designing data centres in orbit to sit in the sun. Scroll to zoom in, all the way down.
Racks inside pressurised modules, solar wings for the power and radiators to shed the heat into space. Every watt has to be collected, and every watt has to be got rid of.
Inside, it is the same as on the ground: racks of servers, their GPUs busy, or, too often, switched on and waiting for work.
A data-centre GPU can draw several hundred watts under load and still tens of watts while it does nothing. joules reads both from the GPU's own energy counter.
Every switch costs a little energy each time it flips, and a GPU that is on but idle keeps paying to stay ready.
Each silicon atom is bonded to four neighbours. All the energy a GPU draws ends up here as heat. WattOps measures it from the hardware, not a spec sheet.
See your idle GPUsjoules sends energy readings and the names of the jobs that used them. It never sends your code, prompts, command arguments or files, and nothing at all unless you ask it to.
Read the Privacy Policy and the Data Processing Agreement, or ask us anything.
Live for 1 GPU, Tracking, the calculator, joules and the leaderboards. Free for good, no card needed.
Once you sign in, Billing shows every plan and the price for your own GPUs. For more than 256 GPUs, we set it up with you, starting with a 4–6 week pilot on your own cluster.
Book a demoUniversities and public research pay half: ask us for the code.
The paid plans are for fleets. These are for anyone who trains or runs a model, free for good: a calculator, the joules command, an open leaderboard and an energy check for pull requests.
Enter the model size, the amount of data and your hardware, and see the electricity, cost and CO₂ of a training run before you pay for it.
6 × params × tokens → kWh → g CO₂
Put joules in front of anything you run, like time, and get its real energy, cost and CO₂ from the hardware’s power meters.
joules -- python3 -c "sum(range(10**8))"
A GitHub Action measures your benchmark on every pull request and says when a change makes it use more energy than before.
joules ci --budget 10 -- python3 -c "sum(range(10**7))"
Put joules in front of anything you run, like time. It reads the power meters of the GPU and CPU while the command runs and prints the energy, the cost and the CO₂. This is real output from a MacBook Air.
$ joules -- sh -c 'for i in $(seq $(getconf _NPROCESSORS_ONLN)); do python3 -c "x=0 for i in range(100000000): x+=i" & done; wait' joules · 15.45 s · exit 0 Apple SoC (CPU + GPU + ANE) 71.5 J 4.6 W avg total 71.5 J = 19.9 mWh cost <0.0001 · CO₂ 0.00735 g at 370 g/kWh
On NVIDIA cards every measurement also reads the clock, the temperature, the power limit and the driver’s own throttle reasons, and says in words what they mean. This is real output from a free Google Colab T4: busy the whole time, and still held to 58% of its clock by the power cap. “100% utilisation” never told you that.
$ joules -- python -c "import torch, time
x = torch.randn(8192, 8192, device='cuda'); t = time.time()
while time.time() - t < 30: x = x @ x"
joules · 32.51 s · exit 0
GPU 0 Tesla T4 2.13 kJ 65 W avg nvml counter
927 MHz (58% of max) · 93% busy · memory 61%
68 °C max · limit 70 W · compute-bound
throttled 93% of the time (power cap)
total 2.13 kJ = 591 mWh
cost <0.0001 at 0.1/kWh · CO₂ 0.219 g at 370 g/kWh
On an NVIDIA H200 with half the data changing, HST used 38.8% less GPU energy and 29.5% less time than an optimized baseline. Read the case study.
The same GPUs cost $76.93 per million tokens with 1 user and $1.61 with 256: 30× the API when quiet, 37% under it when busy. Read the write-up.
joules bench gpu --share runs the same one-minute test on any GPU, a Kaggle T4 included, and puts its work per joule on the public board.
joules reads the power meters built into the hardware: NVIDIA and AMD GPU sensors, Intel and AMD CPU energy counters (RAPL) and Apple silicon’s own power reporting. The calculator is within 0.4% of the published energy of GPT-3, BLOOM and Llama 3 70B. What is and is not included is written out on the Method page under “Accuracy and limits”.
No work runs inside your jobs. The agent reads the power counters about once a second, next to your workload, and the command wrapper only watches the command it starts.
Only what you ask for: energy, power, cost and carbon, the machine’s name, and the names and users of the jobs that used the power. Never code, prompts, command arguments, inline scripts or files.
NVIDIA, AMD and Intel GPUs, Intel and AMD CPUs, and Apple silicon Macs. On Windows the GPU is measured and the CPU estimated. The agent knows Slurm jobs, Kubernetes pods, containers and users, and serves Prometheus metrics too.
Yes. The Free plan has the calculator, joules and the leaderboard for good. Once you sign in, Billing shows the paid plans and the price for your own GPUs; they are monthly and can be cancelled any time. For more than 256 GPUs, Fleet starts with a 4–6 week pilot on your own cluster.
PHENEX TECHNOLOGIES INC., a British Columbia corporation in Vancouver, Canada. WattOps was called Landauer Gap until October 2026; the Landauer gap, how far computing sits above the least energy physics allows, is still the science inside it. The method comes from the D3 research series, published with a DOI, and every formula is shown on the Method page.
curl -LsSf https://wattops.dev/install.sh | shjoules --track my-project -- python train.pyRunning a fleet? Book a demo and we will set up a pilot with you.
You have been invited to a team on WattOps. Sign in, or create an account, with the email address the invite was sent to.
This is a preview. Sign-in and accounts work on the website.
Open wattops.dev ↗Free account. By continuing you agree to the Terms and Privacy policy.
An estimate from the inputs above, not a measurement. To measure a real run, use joules. How it is worked out →
| Change | Energy | CO₂ | Cost | Saved |
|---|
| Part | Energy | Share | CO₂ |
|---|
Where would you like to run it first? Pick one; you can add the others any time from here.
Every run you measure with joules: the energy, cost and CO₂ of each one, and whether they are going down.
| When | Run | Above usual | Sent to |
|---|
Each name's runs in the period and project above: medians per run, ± half the spread of the middle half of the runs, and p, the chance of a difference this large if the two were really the same (Mann-Whitney). Lower energy and time is better. Runs named name @ 70% power are grouped by power limit. joules compare --track PROJECT "CMD A" "CMD B" measures both fairly (warm-up, interleaved runs) and sends every run here.
Share of each run the GPU spent below its maximum clock for a reason other than being idle: the power cap, heat (thermal), a hardware slowdown or a power brake. Click a run in the table for the full reading.
| Finished | Project | Run | Hardware | Time | Energy | CO₂ | Gap |
|---|
Energy is what each machine's own meters report: NVIDIA, AMD and Intel GPUs, Intel and AMD CPUs with memory, or on a Mac the Apple chip (CPU, GPU and Neural Engine). Screens, disks and power-supply losses are not included; --pue adds a building's cooling and losses. Runs marked simulated are not measurements. Accuracy and limits →
Connect a computer once. After that, every run you measure on it shows up on this page by itself.
Waiting for your first run… this page updates by itself.
Add --params and --tokens (billions) so joules can work out the Landauer gap. joules sends the energy, time, cost, CO₂, hardware and a short label: the program and script name, or your --label. Never your arguments, code, outputs or file contents. Each tracked run uses one API call.
Every machine running joules agent, a few seconds behind: which GPUs are on but doing nothing and what they cost you, then what the whole fleet draws and costs by the hour.
Power over the window, with its power limit; shaded where the GPU was throttled.
Every GPU, from its own driver readings in each machine's latest heartbeat. Busy is the share of time the GPU was working; throttled means below its maximum clock for a reason other than being idle (power cap, heat, a hardware slowdown). A GPU counts as idle when no job holds it or it is under 5% busy. Machines on joules older than 0.7.2 show their GPUs without readings.
| Job | Machine | GPUs | Power | Per hour |
|---|
Each machine's power is measured by its own meters every second (--pue adds a building's cooling and losses). The split between jobs is an attribution: a job alone on a GPU gets all of it; a shared GPU is split by each job's SM time (GPU time on AMD and Intel), or by the GPU memory it holds when the driver gives no SM time; CPU and memory energy by CPU time. Each finished job says which split it got. A GPU counts as idle when no job holds it or it is under 5% busy. Cost and CO₂ use each agent's --price and grid. Accuracy and limits →
Waiting for your first machine… this page updates by itself.
joules connect!pip install -q -U landauer-gap, in a Python cellimport joules; joules.connect()The agent sends each machine's power, its idle GPUs and the jobs running on it (job name, user and power). Never commands, arguments, code or files. Heartbeats do not count against your API calls. In Kubernetes, run it as a DaemonSet with --name $NODE_NAME; on Linux, sudo joules connect installs it as a service that starts with the machine and can read the CPU energy counters. A machine that goes to sleep sends nothing and leaves a gap in the graph; add --keep-awake to keep it awake while the agent runs.
Every estimate you keep, private to your account. Select two to compare.
Runs are saved in this browser. Sign in to keep them in your account and open them on any device.
Some runs are only in this browser.
No saved runs yet. Configure a run in the calculator, then press S or Save run.
| Run | Energy | CO₂ | Cost | Gap |
|---|
| Metric | Change |
|---|
Measured on real hardware by the people who ran it, from each device's own energy meter. Nothing here is a sample or an estimate, and nobody's name is shown. Anyone can see it at wattops.dev/leaderboard, no sign-in needed.
Every row is the same test: 8192 × 8192 matrix multiplications, 20 seconds in fp16 and 20 in fp32 after a warm-up, with the energy from the GPU's own meter. GFLOP per joule is the work the card does for each joule it draws; higher is better. The power limit and throttling are shown because they decide much of the result: a T4 in a notebook usually runs against its 70 W limit the whole time.
About a minute on any NVIDIA or AMD GPU that PyTorch can use. joules sends only the GPU's name, its power limit, and per precision the number of multiplications, the energy, the time and how much the card throttled. Nothing from your notebook, files or machine name.
Ready made: the Kaggle notebook ↗ runs this test on a Kaggle T4, and the fp16 vs fp32 comparison before it. Copy & Edit, set the accelerator to GPU T4 x2, Run All.
| GPU | fp16 GFLOP/J | fp32 GFLOP/J | Shared |
|---|
Machines are ranked against each other on the same model, never one model against another: a smaller model always uses less energy per token, which does not make it the better choice. Each row is energy above idle, and says what its meters cover; a Mac's meter is the whole chip, an NVIDIA one the GPU alone. Each person's runs count once.
Each figure is what the machine's own meters reported while the model generated tokens. Power at the wall socket is higher. Accuracy and limits →
joules sends only the model name, hardware, energy per token, speed and average power. Nothing from your prompts, outputs, host name or files. Simulated runs are refused, and joules measures the idle machine for 5 seconds first, so every row is energy above idle.
| Model | Hardware | J / token | tok/s | Shared |
|---|
Every figure comes from a published formula, and every assumption is editable in the calculator.
The standard operation count for dense transformers. Run time is compute ÷ (peak throughput × utilisation).
Accelerators first, then CPUs, memory and networking, then cooling and building losses.
Grid presets are rounded recent annual averages. Use your provider’s figure for formal reporting.
One bit per operation gives the lowest floor, so the gap is an upper bound. Reversible computing aims to avoid erasure altogether.
| Run | Source | Calculator | Published | Difference |
|---|---|---|---|---|
| GPT-3 175B, energy | Patterson et al. 2021 | 1,290 MWh | 1,287 MWh | +0.2% |
| GPT-3 175B, carbon | Patterson et al. 2021 | 553 t | 552 t | +0.2% |
| BLOOM 176B, energy | Luccioni et al. 2022 | 433 MWh | 433 MWh | 0.0% |
| BLOOM 176B, carbon | Luccioni et al. 2022 | 24.7 t | 24.7 t | 0.0% |
| Llama 3 70B, energy | Meta model card | 4,480 MWh | 4,480 MWh | 0.0% |
| Llama 3 70B, carbon | Meta model card | 1,900 t | 1,900 t | 0.0% |
The calculator is also compared, on every change, with a separate implementation of the same formulas written independently in Python, over random inputs.
The least energy physics allows for erasing one bit at room temperature: the Landauer limit, kBT ln 2.
Landauer, 1961 · at 300 KHow far above that limit a 3-billion-parameter model ran, per operation, on a MacBook Air. Measured with joules.
llama3.2 3B · M3 MacBook Air · 0.241 J per tokenThe largest difference between our calculator and the published energy of GPT-3, BLOOM and Llama 3 70B.
Patterson et al. 2021 · Luccioni et al. 2022 · MetaThe gap ruler in the calculator and the Landauer gap column on Tracking show every run against this floor. The derivation is in the D3 research series ↗ and on the blog.
joules reads the devices' own meters: the GPU board (NVML, amdgpu, Intel), the CPU package and memory (RAPL), and a Mac's chip (powermetrics). A meter at the wall socket also sees the power supply's losses, fans, storage, the motherboard and network cards, and on a laptop the screen. So joules reports a share of the wall, by design.
We are measuring that share against a logging wall meter, repeated at two GPU power limits, and will publish the dated results here with the raw readings. joules calibrate lets anyone run the same check on their own machine: it compares the meters with a plug-in wall meter over the same minutes and prints the share of the wall reading they saw (--wall-wh for a meter that shows a running total, --wall-csv for one that logs). It is in the joules guide ↗.
| Hardware | Where joules reads energy | What it covers |
|---|---|---|
| NVIDIA GPUs | The driver's energy counter (NVML); its power reading on older GPUs | The GPU board |
| AMD GPUs | The amdgpu driver | The GPU, as the driver reports it |
| Intel Arc and Data Center GPUs | The i915 or xe driver | The GPU |
| Intel and AMD CPUs (Linux) | RAPL energy counters | CPU package, and memory where the CPU reports it |
| Mac with Apple silicon | powermetrics, Apple's own figure | The Apple chip: CPU, GPU and Neural Engine |
| Intel Mac | powermetrics | The CPU package, with its graphics and memory |
| No energy counters (Windows CPUs, cloud VMs) | None: estimated from CPU time, and labelled ESTIMATED | Not a measurement; good for comparing runs |
--pue.--subtract-idle, what the machine draws at rest is measured first and taken off, so a run counts only the energy it caused.Run the same model from your code, CI and dashboards. Create and revoke keys in Settings → API keys.
| Endpoint | Plan | What it does |
|---|---|---|
| POST/api/v1/estimate | Every plan | Inputs in, energy, CO₂, cost, Landauer gap and ranked savings out. Same model as this page. |
| POST/api/v1/estimate | Paid | With {"inputs": {…}, "save": true, "name": "…"} the run is also saved to your account. |
| POST/api/v1/report | Paid | Branded PDF report with a verifiable report ID. Same body as estimate. |
| POST/api/v1/report | Paid | With {"kind": "project", "project": "…", "days": 30}: a measured energy report over every tracked run in that project and period. Add "team": true for your team's runs. |
| POST/api/v1/track | Every plan | Add a measured run. This is what joules --track sends; a team key puts it in your team. The reply lists any energy alerts it set off. |
| GET/api/v1/runs | Paid | Your saved runs, newest first. ?limit=1…200 |
| GET/api/v1/measurements | Every plan | The leaderboard: median joules per token for each model and machine. ?model=llama filters, ?mine=1 lists yours. |
| POST/api/v1/measurements | Every plan | Add a measurement. This is what joules bench --share sends. DELETE ?id= removes one of yours. |
| GET/api/health | Public | Service status and model version. |
Errors are JSON: {"error": {"code", "message", "fields"}}. 401 bad key · 400 bad inputs (each field named) · 403 part of the paid plan · 429 limit reached, with Retry-After. Every response carries X-RateLimit-Limit and X-RateLimit-Remaining.
Manage your profile, sign-in, team, plan, developer tools and API keys, preferences, alerts and data.
How you appear in WattOps, and what we know about your account.
This is your avatar. It is the picture on the GitHub or Google account you sign in with; without one, your initial is shown.
The address you sign in with. Sign-in links and confirmation emails go to it.
Your account's ID in WattOps. Quote it when you contact us about your account.
—Permanently remove your account and everything in it: saved runs, tracked runs, leaderboard measurements, API keys and usage. This cannot be undone.
The ways you sign in, your email address and your password.
Signed in on a computer you no longer use? Sign out everywhere, including here. API keys keep working; revoke them under API keys.
Share projects, Tracking, alerts and energy reports with up to 10 people.
| Member | Role | Joined |
|---|
| Sent | Expires |
|---|
Your plan, what you use of it, and every plan side by side.
What this account uses of its plan's limits.
One GPU is free for good. After that, each GPU is priced by its class, monthly. Change the number any time.
Count them by class. Per GPU is $4–14 a GPU a month, for 1 to 256 GPUs.
Live for 1 GPU, $0 for good and no card: power, idle cost and cost per token, plus Tracking, the calculator and joules.
Fleet: Live for every GPU, volume prices by GPU class, billed yearly from $1,000 a month. Starts with a 4–6 week pilot on your own cluster.
A measurement report: your model and GPUs tested by us, with cost per token, energy per answer and idle waste. From $1,500.
| Free | Per GPU · $4–14 a GPU a month | Fleet · from $1,000 a month | |
|---|---|---|---|
| Live: every machine's power, idle GPUs and running jobs, every 5 seconds (GPUs on Live at once) | 1 | 1 to 256, as many as you choose | All |
| Cost per token on a vLLM or SGLang server, beside an API price you set | ✓ | ✓ | ✓ |
| API calls a month | 100 | 200,000 | 1,000,000 |
| API calls a minute | 10 | 600 | 1,200 |
| API keys | 2 | 25 | 50 |
| Calculator, Tracking, leaderboard, joules, CI actions | ✓ | ✓ | ✓ |
| Branded PDF reports | — | ✓ | ✓ |
| Save and list runs from the API | — | ✓ | ✓ |
| Measured energy reports for a project (PDF) | — | ✓ | ✓ |
| Any run on Tracking as a PDF report, with each phase of a Python session | — | ✓ | ✓ |
| Energy alerts, in the app and to Slack, Discord or a webhook | — | ✓ | ✓ |
| Team workspace, up to 10 people | — | ✓ | ✓ |
Per GPU is billed monthly by Stripe, each GPU at its class's price: Data center $14 (H100, H200, B200, GB200, MI300X), Workstation $8 (A100, L40S, RTX PRO 6000, A6000) and Entry $4 (T4, L4, A10, V100, RTX 4090 and 5090, other GPUs, and a machine without a GPU). Change the GPUs in each class or cancel any time from here or Manage billing, billed pro rata. Fleet is for more than 256 GPUs, from $1,000 a month with volume prices by GPU class, billed yearly under a written order form, and a 4–6 week pilot costs $2,000, credited to your first year: talk to us. Universities and public research pay half: ask us for the code. Rent in the total is an example at typical cloud prices (data center about $2.50, workstation $1.20 and entry $0.35 a GPU-hour). Prices in US dollars, before tax. See the Terms and refund policy.
Everything for putting joules on machines and using WattOps from code, in one place.
Install joules on a Mac, Linux or Windows computer, a GPU server, a Slurm or Kubernetes cluster or a notebook, step by step.
Open setup →Create a key for each machine, CI job or script, see when it was last used, and revoke it.
Manage keys →The estimate, tracking, measurement and report endpoints, with examples in curl, Python and Node.
Read the docs →Measure a command on every pull request, comment the change in energy and fail the check over budget.
Add the workflow →Measure joules per token of a local model and share it to the open leaderboard.
Run a benchmark →joules agent serves /metrics for Prometheus and /jobs as JSON on port 9877, next to your existing dashboards.
Energy per phase from Python with joules.Session, or from any language with two HTTP calls to the agent.
How to measure GPU energy in Python and per LLM token, compare two ways of doing the work fairly, and what our own measurements found.
Read the guides ↗The same command updates an existing install. joules --version shows yours; joules doctor checks which power meters this machine has.
Keys let joules, CI and your code use your account. Treat them like passwords. How to use them →
| Name | Key | Created | Last used |
|---|
Runs tracked with a team key appear on the team's Tracking page. Its calls count against the team owner's plan.
| Name | Key | Made by | Created | Last used |
|---|
Saved to your account, so every device you sign in on uses them.
Choose when to hear that a run used much more energy than usual. Alerts that fire show on the Tracking page.
| For | Project | Threshold | Webhook |
|---|
What your account holds, and a copy of all of it.
One JSON file with everything above, plus your plan, preferences, team and alerts. API keys are listed by name and prefix only; the keys themselves are never stored.
Permanently remove your account and everything in it.