Two questions customers now ask
Two questions come up in cloud contracts in 2026 that rarely came up in 2016. The first is what does this cost the planet? Data centres used about 415 TWh of electricity in 2024, around 1.5% of the world's total, and the International Energy Agency's base case has that roughly doubling by 2030, with AI the largest driver (IEA, Energy and AI). Regulators now ask for numbers: larger data centres in the EU must report their energy and water use (Delegated Regulation 2024/1364), and many companies must report the emissions of what they buy, including cloud services.
The second is can my provider see my data? Encryption at rest and in transit, from security and identity, protects data on disks and wires, but a program must decrypt data to compute on it, and while it does, the host operating system, the hypervisor and anyone who controls them could in principle read it. For a hospital in Seoul, a bank in Johannesburg or a government in Paris weighing the sovereignty questions of the previous lesson, that gap matters.
This lesson answers both with numbers and mechanisms: energy, carbon and water, computed; carbon-aware scheduling, simulated; trusted execution and attestation, built in miniature; the new isolation runtimes, compared; and a short, dated look at where the cloud is going. How the electricity reaches the building is Lumenary EE's subject, in powering data centres and renewables and storage.
Energy, carbon and water
Most of the electricity a data centre draws goes into the IT equipment — servers, storage, network. The rest goes into cooling, power conversion and distribution losses, lighting and offices.
Definition— Power usage effectiveness (PUE)
The ratio of a facility's total energy to the energy delivered to its IT equipment, measured over a year:
A PUE of 1.5 means half a kilowatt-hour of overhead for every kilowatt-hour of computing. Introduced by The Green Grid and standardised as ISO/IEC 30134-2, it has companion metrics: WUE, litres of water per kWh of IT energy, and CUE, kilograms of CO₂ per kWh of IT energy.
Uptime Institute's 2025 survey put the industry's average PUE at 1.54, almost unchanged since 2018 (Uptime Institute); large providers report fleet averages of roughly 1.1 to 1.2 for their own newest sites. PUE is a measure of the building, not of the computing: a data centre full of idle servers can have an excellent PUE.
Definition— Carbon intensity
The mass of greenhouse gases, in CO₂-equivalent, emitted per kilowatt-hour of electricity: g CO₂e/kWh. The average intensity of a grid is total emissions divided by total generation; the marginal intensity is the emissions of the generators that respond when demand changes by a little. Both vary by place and by hour.
Grid intensities differ by more than a factor of ten. Grids built largely on hydro, nuclear or geothermal power — Norway, France, Kenya, Québec — run at tens of grams per kWh in typical hours; coal-heavy grids such as those of India, South Africa or Poland at several hundred, around 700 or more at their most coal-dependent; most others lie between. Open data from Ember and Electricity Maps give the current figures, and since the best region for carbon is often not the best for latency or law, this becomes a real design input.
The block computes the footprint of one month-long training run — 1,024 GPUs — in four kinds of site, and the energy per token of serving, using example figures.
# Energy, carbon and water of one month-long training run, in different data centres.
# All figures are illustrative examples; real ones come from metering.
gpus = 1024
kw_per_gpu = 1.2 # average draw per GPU including its share of the server (CPUs, memory, fans, NICs)
hours = 30 * 24
it_mwh = gpus * kw_per_gpu * hours / 1000
sites = [ # (description, PUE, on-site water use effectiveness in litres per kWh of IT energy, grid gCO2e/kWh)
("modern site, low-carbon grid", 1.10, 0.2, 50),
("modern site, mixed grid", 1.10, 0.2, 400),
("evaporative cooling, mixed grid", 1.20, 1.8, 400),
("older site, coal-heavy grid", 1.60, 0.5, 700),
]
print(f"IT energy: {it_mwh:,.0f} MWh ({gpus} GPUs x {kw_per_gpu} kW x {hours} h)\n")
print(f"{'site':34s} {'PUE':>4s} {'facility MWh':>12s} {'overhead MWh':>12s} {'t CO2e':>7s} {'water m3':>9s}")
for name, pue, wue, grid in sites:
facility = it_mwh * pue # PUE = facility energy / IT energy
tonnes = facility * 1000 * grid / 1e6 # kWh x g/kWh -> tonnes
water = it_mwh * 1000 * wue / 1000 # WUE is per kWh of IT energy; litres -> cubic metres
print(f"{name:34s} {pue:4.2f} {facility:12,.0f} {facility - it_mwh:12,.0f} {tonnes:7,.0f} {water:9,.0f}")
# The same arithmetic for serving: an 8-GPU server making 6,000 output tokens per second (example).
server_kw = 8 * kw_per_gpu * 1.10 # with PUE 1.10
wh_per_1000_tokens = server_kw * 1000 / 6000 * 1000 / 3600
print(f"\nserving: {wh_per_1000_tokens:.2f} Wh per 1,000 output tokens at full load; "
f"{wh_per_1000_tokens * 400 / 1000:.2f} g CO2e on a 400 g/kWh grid")The run uses 885 MWh of IT energy, about what 250 households using 3,500 kWh a year each would use in a year. The building's PUE moves the total by up to 45%, but the grid matters far more: 49 tonnes of CO₂e in a modern site on a low-carbon grid against 991 in an older site on a coal-heavy one, a factor of twenty, of which the grid alone accounts for fourteen. Water tells a third story: evaporative cooling lowers PUE by spending water, nine times as much here as the modern sites. Serving costs about half a watt-hour per thousand tokens at full load in this example — the same order of magnitude as Google's published figure of 0.24 Wh for its median Gemini Apps text prompt, which counted idle capacity and overheads but not training (Google, 2025) — and much more when servers sit half idle.
Accounting, and its arguments
Companies report electricity emissions under the GHG Protocol in two ways. Location-based accounting multiplies consumption by the average intensity of the local grid. Market-based accounting subtracts clean energy the company has bought — renewable certificates, or long-term power purchase agreements (PPAs) — so a company can report near-zero emissions while drawing power from a fossil-heavy grid at night, provided it bought enough solar energy over the year. That gap led some providers to adopt the stricter goal of hourly matching (often called 24/7 carbon-free energy), in which clean supply must match consumption hour by hour and place by place, and the GHG Protocol has been revising its Scope 2 guidance with hourly matching among the proposals. Beyond electricity lies embodied carbon — making the chips, servers and buildings — which can dominate on a clean grid and grows with every hardware refresh.
Water
Data centres consume water directly, by evaporation in cooling towers and adiabatic coolers, and indirectly, through the power plants that supply them. Evaporative cooling typically consumes one to two litres per kWh of IT energy in warm climates; air cooling with dry coolers uses almost none on site but more electricity; closed-loop liquid cooling, now standard for racks drawing over 100 kW, moves heat efficiently but must still reject it somewhere. Distinguish withdrawal (water taken) from consumption (water not returned), and note where: a litre evaporated in a water-stressed region matters more than one in a wet one. Estimates of AI's water footprint (Li et al.) are contested in their assumptions but have made the question visible, and some operators now publish per-site water data.
Carbon-aware scheduling
Not all work is urgent. Training runs, nightly batch jobs, video transcoding, model evaluation and backups usually have deadlines measured in hours, not milliseconds. Carbon-aware scheduling moves such work to the hours (time shifting) or the regions (location shifting) with cleaner electricity. Google has described doing this across its fleet, using day-ahead forecasts of carbon intensity to set hour-by-hour limits on flexible compute in each cluster for the next day (Radovanović et al.); open tools such as the Green Software Foundation's Carbon Aware SDK expose intensity forecasts to any scheduler.
The simulation runs 40 flexible jobs over two days in a sunny region whose grid is cleanest at midday and a smaller hydro-and-wind region that is cleaner but has room for only two jobs at a time. Each job has a deadline; jobs are placed in order of deadline, and capacity is respected.
import numpy as np
# Two days of hourly grid carbon intensity (g CO2e/kWh) in two regions, synthetic but shaped like real grids:
# "south" has much solar power (cleanest at midday, dirtiest at night); "north" is hydro and wind (low, flatter).
hours = np.arange(48)
solar = np.clip(np.sin((hours % 24 - 6) / 12 * np.pi), 0, None) # 0 at night, 1 at noon
rng = np.random.default_rng(11)
INTENSITY = {
"south": 520 - 330 * solar + rng.normal(0, 15, 48),
"north": 160 + 40 * np.sin(hours / 9) + rng.normal(0, 10, 48),
}
CAPACITY = {"south": 6, "north": 2} # jobs each region can run at once; the north region is small
# 40 flexible batch jobs: (submitted at hour, hours to run, power in kW, hours allowed from submission to finish)
jobs = [(int(rng.integers(0, 24)), int(rng.integers(1, 6)), float(rng.choice([20, 40, 80])), int(rng.integers(8, 24)))
for _ in range(40)]
def kg_co2e(region, start, dur, kw):
return kw * INTENSITY[region][start:start + dur].sum() / 1000
def schedule(policy):
load = {r: np.zeros(48, dtype=int) for r in INTENSITY}
total, late = 0.0, 0
for sub, dur, kw, allowed in sorted(jobs, key=lambda j: j[0] + j[3]): # earliest deadline first
regions = ["south", "north"] if policy == "shift in time and place" else ["south"]
free = [(s, r) for r in regions for s in range(sub, 48 - dur + 1) if (load[r][s:s + dur] < CAPACITY[r]).all()]
on_time = [(s, r) for s, r in free if s + dur <= sub + allowed]
if policy == "run as soon as possible" or not on_time:
s, r = min(free) # earliest start with room
else:
s, r = min(on_time, key=lambda o: kg_co2e(o[1], o[0], dur, kw))
late += s + dur > sub + allowed
load[r][s:s + dur] += 1
total += kg_co2e(r, s, dur, kw)
return total, late
base, _ = schedule("run as soon as possible")
for policy in ["run as soon as possible", "shift in time", "shift in time and place"]:
kg, late = schedule(policy)
print(f"{policy:24s} {kg:6,.0f} kg CO2e ({1 - kg / base:5.1%} less) deadlines missed: {late}")Shifting in time alone saves 9.2%: the deadlines are too short for many jobs to wait for noon, and the sunny region has room for only six jobs at once when they do. Allowing jobs to move to the cleaner region as well saves 43.6%, with no deadline missed. In practice location shifting is limited by everything the previous lessons taught: where the data is and what moving it costs, latency, residency rules, and whether the cleaner region has spare capacity — which, for the newest accelerators, it often does not.
Confidential computing
All the isolation in virtualisation and containers protects tenants from each other and the provider from tenants. Confidential computing turns the arrow round: it protects a tenant's code and data from the provider — from the host operating system, the hypervisor, the cloud's operators, and anyone who has compromised them.
Definition— Trusted execution environment (TEE)
A hardware-enforced region of execution whose memory is encrypted and integrity-protected by the processor, with keys the processor generates and never reveals, so that software outside it — including the most privileged software on the machine — cannot read or tamper with what is inside. A TEE can produce attestation evidence: a report, signed by a key rooted in the hardware, of what software was loaded into it.
TEEs come in two shapes. Process enclaves, such as Intel SGX, protect part of an application, which must be split into trusted and untrusted halves; the trusted computing base is small, but porting software is hard. Confidential virtual machines protect a whole VM, so unmodified operating systems and applications run inside: AMD SEV-SNP, Intel TDX and the realms of the Arm Confidential Compute Architecture, announced in 2021, whose hardware support is arriving later than the other two's. Since 2023 GPUs have joined: NVIDIA's Hopper and Blackwell GPUs can run in a confidential mode, encrypting traffic between the confidential VM and the GPU, which matters for AI models and prompts. The Confidential Containers project brings the same protection to Kubernetes pods.
Providers offer these side by side, each documented on its own pages: confidential VMs on Azure, Google Cloud, AWS and Alibaba Cloud, among others, mostly at a small premium. AWS also offers Nitro Enclaves, a different design: isolated environments carved out of an instance by AWS's own Nitro hypervisor, with attestation by the Nitro system — so the root of trust is the provider's hardware and firmware rather than the CPU vendor's.
Attestation: trusting a workload you cannot see
Memory encryption alone is not enough. How does a data owner know that the VM asking for a decryption key is really running inside a TEE, on genuine hardware, with the software they approved — and not a copy the operator modified to leak data? Remote attestation answers that, in the roles the IETF's RATS architecture names (RFC 9334):
- While the TEE boots, the hardware measures each component — firmware, kernel, application — by hashing it into a register.
- A verifier sends a fresh random nonce. The TEE asks the hardware for a report containing the measurements and the nonce, signed with a key whose certificate chains to the manufacturer.
- The verifier checks the signature chain, the nonce, security-relevant flags (no debug mode, current firmware) and that the measurements match reference values, ideally produced by reproducible builds of software the owner has reviewed.
- Only then does a relying party, often a key-management service, release the secret — typically wrapped to a public key the TEE put in the report, so that only that TEE can unwrap it.
The block builds the protocol in miniature with Python's standard library, and tries five ways of fooling it.
import hashlib
import hmac
def extend(register, component):
"""Measured boot: fold each component's hash into a running register, as TPMs and TEEs do.
The result depends on every component and on their order, and cannot be 'un-extended'."""
return hashlib.sha256(register + hashlib.sha256(component).digest()).digest()
def measure(components):
register = bytes(32)
for c in components:
register = extend(register, c)
return register
# Stand-in for the chip's attestation key. Real TEEs sign reports with an asymmetric key whose certificate
# chains to the manufacturer, so anyone can verify them; an HMAC key keeps this sketch to the standard library.
CHIP_KEY = b"fused-into-the-processor-at-manufacture"
def tee_report(components, nonce, debug=False):
"""What the hardware produces when the workload asks for evidence: measurement, the verifier's nonce, a flag."""
body = measure(components) + nonce + (b"\x01" if debug else b"\x00")
return body, hmac.new(CHIP_KEY, body, hashlib.sha256).digest()
APPROVED = {measure([b"firmware v7", b"kernel 6.12 hardened", b"model-server 2026.11"])} # from reproducible builds
def verify_and_release(report, nonce):
body, tag = report
if not hmac.compare_digest(tag, hmac.new(CHIP_KEY, body, hashlib.sha256).digest()):
return "refused: not signed by genuine hardware"
measurement, got_nonce, debug = body[:32], body[32:-1], body[-1]
if got_nonce != nonce:
return "refused: stale or replayed evidence"
if debug:
return "refused: debug mode lets the host read guest memory"
if measurement not in APPROVED:
return "refused: software is not on the approved list"
return "released: data key sent to this workload"
good = [b"firmware v7", b"kernel 6.12 hardened", b"model-server 2026.11"]
n1, n2 = b"nonce-1f4a", b"nonce-93c0"
old_report = tee_report(good, n1)
forged_body = measure(good) + n2 + b"\x00"
cases = {
"genuine workload, fresh nonce": tee_report(good, n2),
"host swapped in a logging kernel": tee_report([b"firmware v7", b"kernel 6.12 + debug log", b"model-server 2026.11"], n2),
"same components, different order": tee_report([b"kernel 6.12 hardened", b"firmware v7", b"model-server 2026.11"], n2),
"old genuine report replayed": old_report,
"report forged without the chip's key": (forged_body, hashlib.sha256(forged_body).digest()),
"genuine software, debug mode on": tee_report(good, n2, debug=True),
}
for name, report in cases.items():
print(f"{name:38s} -> {verify_and_release(report, n2)}")Only the genuine workload, with a fresh nonce and debug mode off, gets the key. A kernel modified by the operator produces a different measurement; so does the right software loaded in the wrong order; an old report fails the nonce check; a report not signed by the chip fails the signature; and debug mode, which would let the host read the VM's memory, is refused by policy even though the software is right.
The trust model, precisely
A confidential VM is designed to protect the confidentiality and integrity of its memory against the host software and the provider's operators. It does not protect:
- Availability. The host can always stop, pause or starve the VM.
- Input and output. Disk and network traffic leave the TEE; the guest must encrypt them itself, and verify what it reads.
- Against bugs in the guest. A vulnerable application inside a TEE is still vulnerable; attestation will faithfully report that it is running.
- Against all side channels. Since 2018, researchers have repeatedly shown how timing, caches, power and speculative execution can leak secrets from SGX and SEV, and vendors have repeatedly patched them.
- Against physical attacks, in most designs. In 2025 academic researchers published three attacks in which inexpensive devices placed on a server's memory bus defeat the memory encryption of current TEEs — WireTap and Battering RAM on DDR4 systems, TEE.fail on DDR5 systems with Intel TDX and AMD SEV-SNP, including extracting attestation keys. The vendors responded that physical attacks of this kind are outside their stated threat models. The practical lesson is that confidential computing reduces how much you must trust the operator; it does not make physical security of the building irrelevant.
Used with that understanding, confidential computing has real uses: releasing decryption keys only to attested workloads in a chosen jurisdiction (a technical answer to some sovereignty questions); letting several organisations analyse pooled data that none may see in full; protecting model weights and user prompts in AI serving. Some AI services now describe designs in which the software images of their serving nodes are published so that outside researchers can check what attestation will accept (Apple's Private Cloud Compute is one documented example). The Confidential Computing Consortium of the Linux Foundation hosts much of the open-source work.
WebAssembly and new isolation runtimes
The isolation table in virtualisation and containers ran from processes to bare-metal hosts. Two newer kinds of boundary now sit near its top, trading generality for start-up times of microseconds to milliseconds and very high density — exactly what edge platforms and serverless functions need.
Language-VM isolates. A JavaScript engine such as V8 can host thousands of separate isolates in one process, each with its own heap, started in a few milliseconds. Edge platforms use them to run many customers' functions on every server; the boundary is the engine's correctness, so such platforms add process sandboxes and other defences around it.
WebAssembly. WebAssembly (Wasm) is a compact, portable bytecode, standardised by the W3C and first shipped in browsers in 2017, that compilers for C, C++, Rust, Go, Python and many other languages can target. Three properties make it attractive beyond the browser:
- A sandbox by construction. A module can touch only its own linear memory, bounds-checked by the runtime, and can call only the functions its host gives it.
- Capabilities, not ambient authority. Through WASI, the system interface, a module gets no files, sockets or clock unless the host grants them, directory by directory. A container, by contrast, sees whatever its kernel exposes unless something takes it away.
- Components. The component model describes typed interfaces between modules written in different languages. WASI 0.2 (2024) was the first stable release built on it, and WASI 0.3, ratified in 2026, adds native asynchronous I/O.
Runtimes include Wasmtime (Bytecode Alliance), WasmEdge (a CNCF project) and Wasmer; edge platforms run Wasm at scale, and the runwasi shims let Kubernetes schedule Wasm workloads beside containers. The limits are real too: code generally runs somewhat slower than native, support for threads, GPUs and some system interfaces is still maturing, and the runtime's compiler is itself attack surface, so platforms running hostile code layer Wasm inside a process sandbox or microVM rather than relying on it alone.
Other new runtimes chase the same goal from the virtualisation side: Hyperlight runs a single function in a tiny VM with no guest operating system, started in a millisecond or two; unikernels such as Unikraft compile an application and only the operating-system parts it needs into one small VM image. A pressing new customer for all of them is AI agents, which write and run code that nobody has reviewed and so need cheap, strong, short-lived sandboxes by the million.
| Boundary | What separates tenants | Start-up, order of magnitude | Fits |
|---|---|---|---|
| Container | the shared host kernel | hundreds of ms | one organisation's services |
| MicroVM | a minimal hypervisor | about 100 ms | multi-tenant functions and containers |
| Function VM without a guest OS | a hypervisor, no guest kernel | about 1 ms | very short functions |
| JavaScript isolate | the language engine, plus process sandboxing | a few ms | edge functions |
| WebAssembly instance | bounds-checked memory and granted capabilities | microseconds to ms | edge, plugins, untrusted extensions |
| Confidential VM | hardware memory encryption, against the host too | seconds | data the operator must not see |
Where the cloud is going
Predictions about computing age quickly, so here are forces visible in late 2026, with what is uncertain about each.
- Power is the constraint. In several regions the wait for a grid connection, not chips or money, sets how fast data centres are built. Providers have signed agreements to buy power from existing and restarted nuclear plants and from small modular reactors not yet built, alongside wind, solar and storage. The uncertainty is large: the IEA's own scenarios for 2035 differ widely, efficiency keeps improving, and greater efficiency has so far tended to raise demand rather than lower it.
- Heat becomes a resource. Liquid cooling of dense AI racks produces warmer water that is easier to reuse, and some data centres, especially in the Nordic countries, already feed district-heating networks.
- Confidential by default. Confidential VMs cost little more than ordinary ones, and confidential GPUs make protected AI serving practical; the open questions are side channels, physical attacks and whether attestation can be made understandable to the people relying on it.
- Regional clouds. Sovereignty rules and capacity scarcity are pushing toward more regions, more local operators and more partner-run clouds, at some cost in scale and features.
- Finer isolation. WebAssembly components, function VMs and sandboxes for agents are making units of computation smaller and shorter-lived, extending the line from servers to VMs to containers to functions.
- Accountability. Reporting rules for energy and water, emissions disclosure, transparency logs for attested software, and published post-incident reviews all push the cloud toward being measurable from outside.
Optional Christian reflection · Stewardship
A reflection from the Christian tradition that inspires Lumenary Academy. It is not part of the mathematics and you are welcome to skip it.
The cloud makes computing feel weightless, yet every query is drawn from rivers, mines and grids that other people depend on. An old idea of stewardship — that what we are given to use is held in trust, for neighbours and for those who come after — fits the cloud well: measure honestly, waste little, and do not hide the costs that others bear.
Common misconceptions
Misconception
"A low PUE means a green data centre." PUE measures only the building's overhead. A site with PUE 1.1 on a coal-heavy grid emits far more than one with PUE 1.4 on a hydro grid, and PUE says nothing about water, embodied carbon or idle servers.
Misconception
"Our provider buys 100% renewable energy, so our cloud use has zero emissions." Annual market-based matching can coexist with fossil power at night and in winter. Hourly, location-based figures tell you what the grid actually supplied.
Misconception
"Confidential computing means the provider can't affect my workload." It protects memory confidentiality and integrity. The provider can still stop the VM, observe its I/O patterns and timing, and — according to the 2025 research — attack some designs physically.
Misconception
"Attestation proves the code is secure." It proves which code is running. Whether that code deserves trust depends on review, reproducible builds and the security of its supply chain.
Misconception
"WebAssembly will replace containers." It suits small, fast-starting, sandboxed units of code, and is spreading at the edge and in plugins; most existing server software, with its threads, system calls and native libraries, runs more naturally in containers and VMs. The two increasingly run side by side.
Exercises
1. Sustainable and confidential cloud
Warm-upHumanA data centre's IT equipment used 10,000 MWh last year, and its annual PUE was 1.35. How many MWh went to everything other than the IT equipment (cooling, power conversion, lighting and so on)?
2. Sustainable and confidential cloud
CoreHumanA training run uses 1,600 MWh of IT energy in a data centre with PUE 1.25, on a grid whose average carbon intensity over the run is 350 g CO₂e/kWh. Using location-based accounting, how many tonnes of CO₂e does the run emit?
3. Sustainable and confidential cloud
CoreComputationalWrite best_start(intensity, duration, earliest, deadline) for time-shifting a flexible job. intensity is a list of hourly carbon intensities; the job runs for duration consecutive hours, may start no earlier than hour earliest, and must finish by hour deadline (so it may occupy hours up to deadline - 1, and never beyond the end of the list). Return the start hour that minimises the total intensity over the hours it runs, choosing the earliest start among ties. Raise ValueError if no start is feasible.
4. Sustainable and confidential cloud
CoreComputationalImplement measured boot. Write measure(components) that starts with a register of 32 zero bytes and, for each component (a bytes object) in order, replaces the register with sha256(register + sha256(component)) (both as raw 32-byte digests). Return the final register as a hexadecimal string.
5. Sustainable and confidential cloud
CoreHumanYou run a workload in a confidential VM (AMD SEV-SNP or Intel TDX) on a public cloud, and release your data key only after attestation. Whom or what must you still trust for your data's confidentiality? Select all that apply.
6. Sustainable and confidential cloud
StretchHumanA flexible job can run at 13:00 or at 02:00. The grid's average intensity is 180 g/kWh at 13:00 (lots of solar) and 420 g/kWh at 02:00. A marginal-emissions service reports that at 13:00 solar is already fully used and any extra demand is met by a gas plant (about 450 g/kWh), while at 02:00 surplus wind is being curtailed and extra demand would use it (about 20 g/kWh). Which choice cuts the emissions caused by the job, and why?
7. Sustainable and confidential cloud
Warm-upHumanA host runtime instantiates a WebAssembly component that uses WASI, granting it one preopened directory, /data/in, and nothing else. What can the component do?
Further reading and resources
- Energy and AI · International Energy Agency · 2025Estimates and scenarios for data-centre electricity demand to 2035.
- Uptime Institute Global Data Center Survey 2025 · Uptime Institute · 2025
- The Green GridThe industry body that introduced PUE and related metrics, later standardised in the ISO/IEC 30134 series.
- Commission Delegated Regulation (EU) 2024/1364 on a rating scheme for data centres · 2024Requires larger EU data centres to report energy, water and other indicators.
- GHG Protocol Scope 2 Guidance
- Carbon-Aware Computing for Datacenters · Ana Radovanović et al. · 2021How Google shifts flexible work in time to cleaner hours.
- Making AI Less "Thirsty": Uncovering and Addressing the Secret Water Footprint of AI Models · Pengfei Li, Jianyi Yang, Mohammad A. Islam and Shaolei Ren · 2023
- Measuring the environmental impact of delivering AI at Google Scale · Google · 2025
- Green Software Foundation — Software Carbon Intensity specification
- Carbon Aware SDK
- EmberOpen data on electricity generation and its carbon intensity by country.
- Electricity Maps
- WattTimeMarginal-emissions data for electricity grids.
- Confidential Computing Consortium
- RFC 9334: Remote ATtestation procedureS (RATS) Architecture · 2023
- AMD Secure Encrypted Virtualization
- Intel Trust Domain Extensions
- Arm Confidential Compute Architecture
- NVIDIA confidential computing
- Azure confidential computing
- Google Cloud Confidential Computing
- AWS Nitro Enclaves
- AMD SEV-SNP on Amazon EC2
- Alibaba Cloud ECS confidential computing
- Confidential Containers
- TEE.fail: Breaking Trusted Execution Environments via DDR5 Memory Bus Interposition · 2025
- Battering RAM · 2025
- WireTap: Breaking Server SGX via DRAM Bus Interposition · 2025
- Private Cloud Compute: A new frontier for AI privacy in the cloud · Apple Security Engineering and Architecture · 2024
- WebAssembly
- WASI
- WASI 0.3 · Bytecode Alliance · 2026
- Wasmtime
- WasmEdge
- Wasmer
- runwasicontainerd shims for running WebAssembly workloads alongside containers.
- Hyperlight
- Unikraft