KB vs KiB: why your 1TB drive shows 931 gigabytes.

It's one of the oldest complaints in computing: buy a "1 TB" drive, plug it in, and Windows reports 931 GB. The drive is fine. The label is even technically correct. What you're seeing is a unit collision — two industries using the same word for two different numbers — and once you see the two numbers, every "missing space" mystery resolves into arithmetic.

The two kilobytes.

In the metric system, kilo- means exactly 1000 — a kilometer is 1000 meters, a kilogram is 1000 grams. By that rule a kilobyte is 1000 bytes, a megabyte a million, a gigabyte a billion, a terabyte 10¹².

But computer memory doesn't come in round decimal sizes. Address lines are binary, so memory capacity naturally lands on powers of two — and 2¹⁰ is 1024, which is almost 1000. Early engineers borrowed the prefix: "kilobyte" for 1024 bytes was too convenient to resist, off by only 2.4%. The habit stuck, and grew: "megabyte" for 1024², "gigabyte" for 1024³.

So the same word came to mean two numbers, and — the actually annoying part — the gap between them compounds at every prefix. Kilo is off by 2.4%, but each step multiplies another 1024/1000, so mega is off by about 4.9%, giga by 7.4%, and tera by nearly 10%.

How the collision happened.

Neither side is being dishonest; they're measuring different things.

Memory is binary by construction — a RAM chip with n address lines holds 2ⁿ words, so RAM sizes are honestly powers of two. "16 GB of RAM" really is 16 × 1024³ bytes, and describing RAM in decimal units would be the awkward choice.

Storage has no such constraint — a disk holds however many sectors fit on the platters or flash dies, no power of two required. Drive makers use the metric meaning (and say so in the fine print: "1 TB = 1,000,000,000,000 bytes"). Metric is also, strictly, what SI says the prefixes mean.

The collision only became visible because operating systems historically reported sizes in binary units while writing the metric symbols next to them. Windows still does: Explorer divides by 1024³ and prints "GB". The drive says 1 TB in decimal; the OS reports the same bytes in binary units with a decimal label. Same drive, same bytes, two numbers.

The missing 69GB, exactly.

Run the numbers for a "1 TB" drive:

The label:     1 TB  =  1,000,000,000,000 bytes     (decimal, as marketed)

The OS:        1,000,000,000,000 / 1024³
             =  931.32...                            binary gigabytes (GiB)

Windows says:  "931 GB"                              (binary math, decimal label)

Not one byte is missing — 931.32 GiB and 1 TB are the same quantity in different units, like 100 kilometers and 62 miles. The "lost" 69 GB is the 7.4% gap between giga (10⁹) and gibi (2³⁰), and it grows with drive size: a "4 TB" drive shows about 3.64 binary terabytes, an "8 TB" drive about 7.28.

KiB, MiB, GiB: the official fix.

In 1998 the International Electrotechnical Commission gave the binary quantities their own names, so each number could have its own word: kibi (Ki, 1024), mebi (Mi, 1024²), gibi (Gi, 1024³), tebi (Ti, 1024⁴) — "binary" contractions of the metric prefixes. Under this scheme, now part of the ISO/IEC 80000 standard, the rule is simple: KB means 1000 bytes, KiB means 1024. No ambiguity, nothing to remember except which suffix you're reading.

Bytes	Decimal (SI)	Binary (IEC)	Gap
thousand-scale	1 kB = 1000	1 KiB = 1024	2.4%
million-scale	1 MB = 1000²	1 MiB = 1024²	4.9%
billion-scale	1 GB = 1000³	1 GiB = 1024³	7.4%
trillion-scale	1 TB = 1000⁴	1 TiB = 1024⁴	10.0%

Adoption, twenty-five years on, is honest-but-partial: Linux tools, technical documentation, and cloud providers increasingly write MiB/GiB when they mean binary; consumer-facing software mostly hasn't switched. Which is why you still need to know who counts which way.

Who counts which way.

Decimal (1000s): drive and SSD labels, macOS (since Snow Leopard in 2009 the Finder reports decimal, so a 1 TB drive shows as ~1 TB), most Linux desktop file managers following GNOME's lead, and networking — bandwidth was always decimal. Networking adds its own twist: link speeds are bits, not bytes, so a 100 Mbps connection tops out around 12.5 megabytes per second before overhead. The b/B distinction hides a factor of eight, dwarfing the 1000-vs-1024 one.

Binary (1024s): RAM, always. Windows Explorer's file and drive sizes (binary math, "KB/MB/GB" labels). Classic Unix tools — ls -lh and df -h use 1024 (with --si switching to 1000). Many programming-language standard libraries and older APIs.

Ambiguous: any bare "MB" in an API response, a config file, a quota, or a spec sheet written by someone who didn't say which they meant. When the number matters — billing, capacity planning, "why is my upload rejected at exactly 10MB?" — find out which convention the system uses before doing arithmetic on it. The Data Size Converter shows any value in both systems at once, which makes the mismatch visible immediately.

What to do in your own work.

Three habits dissolve the whole problem:

Write the suffix you mean. If your code divides by 1024, report KiB/MiB/GiB. If it divides by 1000, report kB/MB/GB. The IEC suffixes exist precisely so readers don't have to guess your divisor.

Store and compare in bytes. Quotas, limits, and thresholds belong in plain bytes internally; convert only at the display edge. Most "off by 4.9%" bugs are two layers converting with different divisors.

Expect the gap when reading dashboards. A cloud instance advertised with "8 GB" of memory, a monitoring agent reporting in GiB, and a spec sheet in GB can all describe the same machine with three numbers. None of them are lying; they're just not using the same kilo.

Takeaways.

This is ultimately a naming bug, not a technology one — a 2.4% shortcut from the 1960s that compounded into consumer confusion at every electronics counter on Earth. The fix costs one letter. Might as well use it.