Convert kB to KiB

A kilobyte is 1,000 bytes when a standards body defines it and 1,024 when an operating system does. This page uses 1,000; the kibibyte is the unit that means 1,024.

A kibibyte is exactly 1,024 bytes. The name was coined in 1998 precisely so that "kilobyte" could go back to meaning 1,000, though the habit never fully took.

The factor is 0.976563, and almost nobody carries that around. Rounded to 0.98 it is off by 0.35 % — which stays invisible on small numbers and turns into a whole unit somewhere around 1,000 kB.

That is the number worth knowing before you round: not the error itself, but where it stops being ignorable. Below that point the shorter factor is the sensible one; above it, use the field above, which never rounds until it prints.

One KiB is 1,024 of the unit below it; one kB is 1,000. On this page that is the difference between 1.024 kB and 1 kB — 2.4 % — and the gap grows at every step up the scale, which is why it is a rounding error on a photograph and a visible chunk of a hard disk.

This is the whole of the missing-storage mystery, and on this page it is worth 2.4 %. A drive sold in kB holds exactly what the label says; Windows divides by 1,024 instead of 1,000, keeps the decimal name, and reports 1 kB where the box said 1.024. macOS has counted these in the decimal units since 10.6, which is why the same drive can look two sizes on two machines — nothing is missing and nobody is rounding, the same bytes have two names.

A kilobyte is a thousand bytes if you take the prefix at its word, and 1,024 if you take it from the way software has used it since the 1960s. Both readings are still in circulation, in the same sentence in some documentation, and neither side has conceded. The result is that a 500 kB file is reported as 488 KiB by a tool being careful and as "488 KB" by a tool that is not, and none of the three numbers is wrong on its own terms.

The size of the disagreement is what makes this pair the hard one to notice. Twelve bytes here, twenty-four there — it looks like a rounding artefact, so people assume one tool truncates and stop investigating. It is not rounding. Every byte is accounted for; the two tools are dividing by different numbers, and the division they choose is the entire content of this page.

1,024 is 2 to the tenth power. Memory is addressed in binary, so the number of locations a chip can reach is fixed by how many address lines it has: ten lines reach 1,024 locations and there is no arrangement of wires that reaches 1,000. A memory part is therefore built and sold in powers of two because that is the only size it can be, and the same logic runs through page sizes, block sizes and buffer sizes throughout a system.

When those quantities needed a name in the 1960s, 1,024 was within 2.4 percent of a thousand and "kilo" was borrowed rather than invented. That was a reasonable choice at a scale where the error was two percent and the machines had a few thousand words of memory. It stopped being reasonable when the same borrowed prefix reached the giga and tera steps, where the same reasoning produces a gap of 7.4 and 10 percent.

Multiply the kilobytes by 1,000 to get bytes, then divide by 1,024. 500 kB is 500,000 bytes, and 500,000 ÷ 1,024 is 488.28 KiB. In one step it is a multiplication by 0.9765625, which is exact — it is 1,000 ÷ 1,024 and terminates, so no converter needs to round it and any two that are working correctly agree to as many digits as you care to print.

The sanity check is that the KiB number must always be the smaller one. Each kibibyte holds more bytes, so it takes fewer of them to hold the same file. If a conversion in this direction has made the number bigger, the two units have been swapped somewhere, which is the single most common mistake in this category and the reason the reverse pages exist separately.

The clearest evidence that the two systems were never cleanly separated is a disk millions of people used. A high-density 3.5-inch floppy held 1,474,560 bytes. That is 1,440 KiB, and somebody divided it by 1,000 once more to reach the "1.44 MB" printed on the box — so the label used a binary kilobyte and a decimal thousand in the same number.

By either consistent measure the figure is wrong: the disk is 1.47 MB decimal or 1.41 MiB binary, and 1.44 is neither. Nobody was being dishonest; the two conventions were already so entangled by then that a mixed unit could be printed on tens of millions of boxes without anyone objecting. That is the state the IEC prefixes were written to end.

In 1998 the International Electrotechnical Commission amended IEC 60027-2 to define kibi, mebi, gibi and tebi, each a contraction of the SI prefix with "binary". The symbols take a lowercase i — KiB, MiB, GiB, TiB — and they mean 1,024 and its powers, exactly and unambiguously. The definitions now live in IEC 80000-13 and are endorsed by the relevant national standards bodies.

Adoption went one way. Linux tooling, several build systems, and documentation written by people who had been bitten took the prefixes up; Windows did not, and a large amount of consumer software followed Windows. So the standard succeeded in giving the binary units a name and failed at its actual goal, which was to make "kilobyte" unambiguously mean a thousand. Twenty-odd years on, the safest assumption when reading kB is still no assumption.

Storage and networking are decimal almost without exception: drive capacities, transfer rates and quoted plan sizes are all powers of ten, and macOS has reported file sizes decimally since 2009. Memory is binary without exception, because of the addressing above. Everything else is a coin toss decided by whoever wrote the tool, and the honest ones tell you which they chose by printing KiB rather than KB.

A quick way to find out is to convert something you already know the byte count of. Take a file, read its exact size, and see what the tool reports: if 10,240 bytes is shown as 10 the tool is binary, and if 10,000 bytes is shown as 10 it is decimal. That takes a minute and settles the question for that tool permanently, which is worth more than any general rule about who uses what.

On a single small file the difference is genuinely negligible, and treating it as noise is the correct engineering judgement. It stops being noise in two situations: when the figure is a limit, and when it is multiplied. A quota of "500 kB per upload" enforced as 500,000 bytes will reject a file the user was told was 488 KiB and is 500,224 bytes, and nothing in either number explains the rejection.

Multiplication is the larger trap because the error travels up the scale rather than staying put. The same 1,024-against-1,000 substitution applied twice is 4.9 percent, three times 7.4, four times 10. A capacity estimate built by counting kilobytes and reported in terabytes carries the full 10 percent, and by then it is not a rounding error but the difference between ordering enough storage and not. The rule that avoids it entirely is to hold the byte count as the working figure and convert only at the point of display, because a byte count crossing four steps of the ladder cannot pick up a percentage error that was never applied to it.