Methodology

Every figure on this site is peak dense BF16/FP16 floating-point operations per second. That choice is the whole methodology, so it is worth being blunt about why.

Vendors quote whichever number is largest. An NVIDIA B200 is marketed at "20 petaFLOPS" — that is FP4 precision with a 2:1 structured-sparsity assumption. The same chip does 2.25 petaFLOPS of dense BF16, which is the throughput it actually sustains on a general tensor workload with real weights. The marketing figure is not a lie; it is a different measurement, roughly 4 to 9 times larger, and it is not comparable across generations because each generation moves the goalposts to a narrower datatype.

Mobile and edge silicon is quoted in INT8 "TOPS", which are integer operations and not FLOPs at all. Supercomputers are quoted in FP64, which is the opposite problem: roughly an order of magnitude smaller per transistor than half precision.

So we convert everything to one denominator. Half precision is the right one: it is what modern machine learning actually runs in, every current accelerator implements it natively, and it sits in the middle of the range rather than at either marketing extreme. Where a source publishes only FP32, FP64 or INT8 TOPS, the conversion factor used is stated on that constituent's page.

The industry's own shorthand — the H100-equivalent — is carried alongside. One H100e is 989.4 TFLOP/s dense BF16, the spec of an NVIDIA H100 SXM.

The headline is the sum of a partition — slices drawn so that no processor falls into two of them, and none is missed. Eleven slices in three families:

• AI accelerators — datacenter silicon built for tensors, split by vendor: NVIDIA, Google TPU, AWS Trainium, AMD Instinct, and the residual of everyone else. The subtotal is pinned to Epoch AI's published fleet estimate: 15 million H100-equivalents as of January 2026, which at 989.4 TFLOP/s each is 1.484×10²² FLOP/s. Vendor shares within that total follow Epoch's reported splits. Note the boundary precisely: Epoch tracks chips purchased and received, not verified deployments, and explicitly does not adjust for shipment lag — so this line runs somewhat ahead of silicon actually racked and powered.
• Personal & consumer — smartphones, discrete gaming GPUs, PCs and laptops, game consoles. Each is built bottom-up as installed base × normalized per-device throughput, both numbers stated on the constituent's page.
• General-purpose & embedded — server CPUs, and the silicon in cars, cameras and robots.

The boundaries are the load-bearing part. A gaming PC's discrete card is in the consumer-GPU line and its CPU and integrated graphics are in the PC line, so it is counted once, in two pieces, not twice. A host CPU in an accelerated datacenter node is in the server-CPU line while its attached GPUs are in the AI lines — different silicon, no overlap. Google's NVIDIA fleet is in the NVIDIA line and only its TPUs are in the TPU line. Every constituent page states its own overlap treatment.

Between published vintages each slice compounds at its own measured rate, so the headline moves continuously rather than stair-stepping when a quarterly report lands:

Five things are measured, published, and deliberately kept out of the headline. Together they come to more than a hundred times it, which is exactly why the rule matters.

Bitcoin mining ASICs. At roughly 900 EH/s the Bitcoin network performs on the order of 2×10²⁴ integer operations a second — by raw switching throughput, the largest computer humanity has ever built, about fifty times the world's entire floating-point capacity. It can do exactly one thing: hash a block header twice with SHA-256. It cannot run a model, solve a PDE, or add two decimals. Operations per second is not compute, and this is the cleanest possible demonstration.

Marketing headroom. The difference between the numbers on the datasheets and the dense BF16 figures used here. Add it back and the AI fleet appears roughly five times larger. It is a reference amount, not throughput — the compute equivalent of a derivatives notional — and adding it would count the same transistors twice.

Announced, not built. Signed orders, announced campuses and gigawatts of substation capacity under construction. Currently larger than everything installed. A datacenter computes nothing until it is energized, and counting it now would double-count it on the day it is.

TOP500 supercomputers. The world's five hundred fastest ranked machines aggregate about 15 exaFLOP/s at FP64 — and they are overwhelmingly built from the same NVIDIA and AMD datacenter GPUs already counted in the AI lines. Summing it would count the same racks twice. It is published here because it is the most rigorously measured number in the whole table, on a real solver at full precision.

Human brains. Eight billion people at roughly 10¹⁵ FLOP/s each — the middle of the range in Joseph Carlsmith's review for Open Philanthropy, which spans 10¹³ to 10¹⁷. Not machines, not silicon, and not a FLOP/s in any strict sense. It is here as the scale anchor, and it is still about two hundred times all the machine compute on Earth.

Compute is a physical inventory, not a price. It does not fluctuate; it accretes. So there is no daily "market close" to mark against — there is a measured growth rate per slice, and a published vintage to re-anchor to.

The AI fleet compounds at 3.3× a year — a seven-month doubling — per Epoch AI's measurement since 2022. That aggregate is not uniform: NVIDIA's own installed base doubles about every ten months (2.3×/yr), while custom silicon from Google and Amazon compounds faster, which is why the blend exceeds any single vendor. Each vendor line carries its own rate; they blend to 3.2×, against Epoch's measured 3.3×.

Consumer silicon moves on a replacement cycle instead: 10-18% a year, driven by installed base turning over into more capable parts rather than by the base growing. Phones are the fastest of these because NPUs are improving quickly inside a saturated handset market.

One constituent has a genuine daily driver. The Bitcoin overlay is marked live from the network's hash rate (Blockchain.com, with mempool.space as a fallback), converted at approximately 2,560 integer operations per double-SHA-256. That conversion is a physical constant, so unlike an index it is never re-anchored.

If a fetch fails, that constituent carries its last known value (flagged carried) and the headline still computes. A bad fetch never breaks the total.

Nameplate peak is a speed limit, not a speed. Published alongside the headline is a utilization-weighted figure: each slice multiplied by the fraction of its rated throughput it delivers, averaged over a year.

Datacenter accelerators sit at the high end — bought to be saturated, and measured at 35-50% model-FLOP utilization on large training runs, derated here for inference, checkpointing, failures and idle reservations. Personal devices sit at the low end: a phone's neural engine is engaged for seconds a day, a console sits dark, a gaming GPU runs a few hours at partial occupancy. Server CPUs are high, because a saturated database is still saturated.

The result is 11.26 zettaFLOP/s — about 14.1% of the 80.08 zettaFLOP/s headline. The band (5.63 ZFLOP/s - 16.89 ZFLOP/s) perturbs the entire utilization vector by ±50%, because the uncertainty here is systematic: if we are wrong about how busy the world's silicon is, we are wrong about all of it in the same direction.

It is the cross-check and not the headline for the same reason an income approach is secondary on a balance sheet: it rests on an assumption that cannot be observed directly. The headline counts what exists; this estimates what it does. Note that the ratio has been rising, because the fast-growing slice is also the busiest one.

The two halves of the headline sit in very different places, so the country map blends two keys weighted by their real share of the total.

Datacenter and industrial compute (~37% of the headline) is extraordinarily concentrated. The United States holds roughly seventy percent of the world's AI accelerators; five hyperscalers alone hold about 71% of global AI compute and are overwhelmingly US-domiciled. China holds most of the remainder, largely in domestic silicon serving a market NVIDIA cannot legally sell into. Those shares are a curated table, with the small residual spread by GDP.

Personal compute (~63%) follows people, not capital. It is apportioned by population weighted by a device-intensity factor for the country's World Bank income group — devices per person times the capability of a typical device there.

The result is a genuinely different map from a wealth map. The United States leads overall on datacenter silicon, and China leads the world in personal compute, because that is where the phones are. Per person, the gap between the top and the median is more than twenty to one.

This is the most approximate part of the site, and it is presented as an apportionment, not a measurement. Nobody publishes a per-country census of installed FLOP/s.

The series runs from January 2008 and joins at the January 2026 anchor. Before the anchor, every constituent is valued from published waypoints — installed-base counts times per-device throughput for each milestone year — interpolated in log space, because compute grows geometrically and a straight linear join between 10¹⁸ and 10²¹ passes through numbers that were never true.

The waypoints respect when silicon actually existed: the TPU line starts in 2015, Trainium in 2019, Instinct in 2020. Nothing is extrapolated backward into years when the chip had not shipped. The TOP500 line is not reconstructed at all — it is the published aggregate Rmax of each list, which makes it the most trustworthy series here and also the smallest.

Forward of the anchor the normal update math applies, and every reconstructed point is flagged is_backfill in the API and marked reconstructed in the history table.

The headline carries a ±40% band, and that number is computed rather than chosen. Every estimated slice is a product of two factors — installed base and per-device throughput — and each factor has a low, central and high value taken from a named source. We simulate the whole partition 200,000 times across those ranges and read the 5th and 95th percentiles off the result.

The inputs, and where the ranges come from:

• Smartphones — 7.0–7.4B active handsets (Ericsson; Counterpoint measures 2% growth in 2025 and ~4-year replacement cycles). Per-device 1.9–5.0 TFLOP/s, where the low end counts the GPU alone and the rest credits the neural engine at its FP16 rate. That structural choice, not arithmetic, is the widest thing in this slice.
• Consumer GPUs — the per-device figure is no longer a guess: it is a weighted average over the 85 discrete models in the July 2026 Steam Hardware Survey, each at its dense FP16 spec, which comes to 74.2 TFLOP/s. We haircut to 60 for the non-gaming tail Steam under-samples. Installed base 180–350M, anchored on Jon Peddie Research's desktop add-in-board figure plus laptop discrete.
• Consoles — the tightest consumer line, spread only 1.5×, because unit sales are published and specs are exact. Even the active rate is measured: Sony reports 132M PSN monthly actives against 211M PS4 and PS5 sold, so 63% of consoles sold are still in use.
• AI accelerators — inherits Epoch AI's own stated uncertainty, which "spans roughly a factor of 2x around the median".

Why the band is not narrower

Simulating the slices independently would give a much tighter answer — about ±15% — and it would be wrong. Independent errors cancel, and the central limit theorem then hands you a confidence you have not earned. These errors are not independent. The open questions are methodological and hit every slice at once: is tensor peak the right number or shader peak; do NPUs count and at what precision; do installed-base trackers systematically over- or under-count. Get one of those wrong and everything moves the same direction together.

So 60% of each slice's spread is modelled as a shared systematic component that moves the whole partition in one direction, and only the remaining 40% is allowed to diversify away. That is what takes the band from a misleading ±15% to an honest ±40%.

Known directional biases

Stated rather than assumed to cancel. Upward: the chip data counts purchases, not deployments, so some of this silicon is in transit; and nothing is ever retired. Downward: Epoch excludes chips that reached China outside export controls, and the embedded line skips microcontrollers without vector units.

What we would defend: the order of magnitude, the composition, the growth rate, and every exclusion in the not-summed table. What we would not defend: any digit past the second.

The one genuinely precise number here is the Bitcoin overlay's hash rate, measured continuously by the network itself — and it is the number we refuse to add.

• Installed base is estimated, not counted. Nobody publishes how many phones or gaming GPUs are switched on today. Those slices are bottom-up estimates from shipment and installed-base trackers, and the per-device throughput is a weighted judgment about a very long tail of hardware. The consumer lines carry the widest uncertainty on the site.
• Vendor shares are approximate; the total is the pinned quantity. The AI subtotal is anchored to Epoch AI's published fleet figure, whose own uncertainty spans roughly a factor of two. The split across NVIDIA, Google, Amazon, AMD and the residual follows their reported shares and is less certain still.
• Purchased is not the same as running. The upstream chip data tracks chips bought and received, with no adjustment for shipment lag and no retirement assumption, so the AI lines sit somewhat above the silicon genuinely racked and powered today.
• 3.3× a year cannot continue indefinitely. It is a measured rate, not a forecast. Power interconnects, fab capacity and capital all bind eventually. Between published vintages this site projects the measured rate forward; when the rate breaks, the anchor moves and the series is recomputed.
• Peak is not throughput and throughput is not usefulness. Memory bandwidth, interconnect and software maturity decide what a fleet can actually do. Two machines with identical FLOP/s ratings are not interchangeable.
• Compute is not fungible. The single most important thing this site measures is a sum of things that cannot substitute for one another. Seven billion phones do not add up to one training cluster, and no amount of SHA-256 hashing is a gradient step. The headline is an inventory, not a capability.

1. One unit, honestly applied — every chip is normalized to peak DENSE BF16/FP16 FLOP/s. Vendors headline FP4, FP8 or INT8 'AI TOPS' with 2:1 sparsity; those numbers are 4-9x larger and are not comparable across generations, so we convert all of them down to the same denominator.
2. Sold and received, not announced — the headline counts silicon that has been bought and delivered. Announced datacenters and signed orders are carried as context and never added: a signed order computes nothing. But note the boundary honestly: the upstream chip data tracks purchases, not verified deployments, so some of this silicon is in transit or still in a crate.
3. A partition, not a pile — the world's compute is split into non-overlapping slices (AI accelerators by vendor, consumer GPUs, phones, PCs, consoles, server CPUs, embedded) that sum to the headline exactly once.
4. Fixed-function silicon nets out — Bitcoin's ~900 EH/s of SHA-256 ASICs is the largest pile of transistors on Earth by throughput, and it cannot execute a single floating-point operation. It is shown, never summed. The same rule retires the TOP500 line, which is built from GPUs already counted.
5. Delivered compute as the cross-check — nameplate peak is a speed limit, not a speed. We publish a utilization-weighted DELIVERED figure alongside it, with a band, because the honest answer is roughly an eighth of the headline.
6. Marked daily — the AI fleet is compounding at ~3.3x per year (a 7-month doubling, Epoch AI); consumer silicon turns over on a replacement cycle. Each slice accretes at its own measured rate between published vintages, so the counter moves the way the world actually does.
7. Full provenance — every constituent carries its source, its normalization, its growth rate and its double-count treatment. History before launch is reconstructed from shipment and installed-base series and flagged as such.
8. An honest error bar — the headline is published with a factor-of-two band, because roughly half of it rests on bottom-up estimates of consumer installed base and the other half on a source whose own uncertainty spans 2x. The figure is an order-of-magnitude claim with a good middle, not a measurement.