Megabytes versus mebibytes — where the units with an "i" came from

The first time you spot MiB or GiB in a partition manager, the instinct is natural: it's a typo, someone fumbled the keyboard. It is exactly the opposite. It is the megabyte and gigabyte that are the "shorthand" units, while the mebibyte and gibibyte — those strange words with an "i" in the middle — are the only ones telling the truth about how many bytes actually fit in your memory. This seemingly cosmetic difference is the fruit of sixty years of engineering compromises, marketing, and a few reform attempts that failed spectacularly.

How "kilo" came to mean 1024

In the 1950s and 60s computers did not even agree on how to address memory. The IBM 701 of 1952 was a binary machine addressing 2048 words of 36 bits; the IBM 702, unveiled a year later, was decimal and worked on 10,000 seven-bit characters. Memory sizes back then were simply described by an exact number.

The turning point came in the mid-1960s, when binary addressing became the standard and main memory began to grow in powers of two. Engineers noticed a mathematical coincidence that would shape the decades to come: the tenth power of two, 2¹⁰ = 1024, sits very close to a thousand (10³ = 1000). Since the metric prefix "kilo-" meant exactly a thousand, it was pressed — for convenience — into service for the value 1024. The mismatch was a trivial 2.4%, and every engineer understood the binary context anyway. The shorthand caught on in the documentation of the era's iconic machines: the IBM System/360, CDC 7600, DEC PDP-11.

The catch is that with every higher order of magnitude that small error multiplies. As early as the late 1960s, when disks measured in millions of bytes appeared, the danger was noticed. Rescue proposals came thick and fast:

• Donald Morrison (1968) wanted to mark 1024 with the Greek letter kappa (κ), and its powers with successive orders.
• Wallace Givens countered with the abbreviation "bK" (for binary kilo), pointing out that Greek letters could not be printed on the era's printers anyway.
• Bruce Alan Martin of Brookhaven National Laboratory went furthest: he proposed abandoning metric prefixes and writing exponentially in base 2, so that 3B20 would mean 3 × 2²⁰.

None of these ideas won industry backing. The ambiguity stayed with us for another three decades.

The birth of the bibytes: IEC versus JEDEC

The chaos eventually had to be tidied up — but first it was... legalised. JEDEC, the association that standardises semiconductor memory, officially defined the kilobyte, megabyte and gigabyte as powers of 1024 in its JESD100B.01 standard. This reflected the real practice of RAM makers, but clashed head-on with the SI system, in which "kilo", "mega" and "giga" are strictly powers of a thousand.

The conflict was settled by the International Electrotechnical Commission (IEC). In December 1998 (published January 1999) it approved new binary prefixes as an amendment to standard IEC 60027-2. The naming recipe was simple and clever: take the first two letters of the SI prefix and add the syllable "bi" (for binary). So kilo + binary gave kibi, mega → mebi, giga → gibi. In 2009 the prefixes entered the international standard ISO/IEC 80000, finally stripping the SI symbols of any right to a binary meaning. They were endorsed by the International Committee for Weights and Measures (CIPM) and the IEEE.

The table below shows the full binary ladder — precisely the factors that power the NebulaMath binary data converter. The last column is the crux of the whole muddle: how much larger the binary unit is than its decimal namesake.

The ladder does not stop at pebibytes. Above them sit exbi (Ei), zebi (Zi) and yobi (Yi), and when the decimal prefixes ronna and quetta were added to SI in November 2022, the IEC 80000-13:2025 standard supplied their binary counterparts: robi (Ri, 2⁹⁰) and quebi (Qi, 2¹⁰⁰). The higher you climb, the more it hurts: at the yobibyte level the gap between binary and decimal counting already exceeds 20%.

Where "i" is the only right choice

If binary prefixes are so troublesome, why keep them at all? Because there is a world in which powers of two are not a convenient approximation but the hard physics of the hardware — and there a decimal megabyte simply makes no sense.

That world is main memory (RAM). Memory chips are addressed by binary lines, so their capacity is by nature a power of two. A chip labelled "8 GB" is in fact 8 × 2³⁰ bytes, that is, correctly, 8 GiB — and here, unlike on drives, no manufacturer "rounds down". For the same reason binary units are used by tools that operate on physical memory blocks: partition managers (GParted), resource monitors, and programs that keep sectors aligned to block boundaries. There MiB and GiB are not pedantry but a condition of correctness — a sector falling mid-block means a genuine performance hit.

The same logic governs file sizes and block allocation in file systems. That is why the official units policy in Ubuntu and Debian is strict: if a program divides by 1024, it must write KiB/MiB/GiB; if it divides by 1000 — kB/MB/GB. Writing "1 kB = 1024 B" is treated there as an ordinary bug.

Hybrids and anomalies of physical media

Before the IEC tidied up the naming, the market had already produced labels that are neither honestly binary nor honestly decimal. The most famous is the 3.5" HD floppy "1.44 MB" — and its label is probably the most absurd unit in the history of computing.

The disk physically holds 2880 sectors of 512 bytes, that is 2880 × 512 = 1,474,560 bytes. Divided by a pure decimal megabyte (10⁶) it gives 1.47 MB; divided by a pure mebibyte (2²⁰) it gives 1.41 MiB. So where does "1.44" come from? From an operation that cannot be defended methodologically: the maker divided the capacity by 1000 × 1024 = 1,024,000 — one "megabyte" defined as the product of a thousand (decimal) and 1024 (binary). It is a mutant megabyte, a hybrid of both systems at once.

Similar oddities turn up on discs. The "700 MB" on a CD-R is really about 703 MiB of user data (that is, ~737 MB decimal) — a figure expressed in mebibytes but signed with the "MB" symbol. DVDs, by contrast, are labelled honestly in decimal, which is why an operating system counting in binary will always show a "shortfall" on them.

The network knows no binary

There is, however, one field that never let itself be drawn into this dispute: data transmission. Link bandwidth is measured strictly in decimal, in bits per second — 1 Mb/s is exactly 1,000,000 bits per second, no exceptions. The reason is twofold. First, network devices send raw pulses — individual bits — and the abstraction of an eight-bit byte has no structural meaning for the line itself. Second, it is simply more convenient for providers: "300 Mb/s" sounds better than the same transfer honestly converted to bytes.

And it is exactly at the seam between these two worlds that the greatest user confusion is born. Take a Gigabit Ethernet link, that is 1,000,000,000 bits per second. Convert it into the binary mebibytes in which the system shows download progress (assuming an ideal absence of overhead):

• divide by 8 (bits → bytes): 125,000,000 B/s,
• divide by 1024 (bytes → KiB): 122,070.31 KiB/s,
• divide by 1024 (KiB → MiB): 119.21 MiB/s.

That is why a download manager on a "gigabit" link will never show a round 125 MB/s, but some strange 119 — and that in the best case. In practice protocol overhead is added: every packet carries TCP/IP headers, and the physical layer uses error-correction coding. Fast Ethernet, for instance, uses the 4B5B scheme, in which every 4 data bits are encoded as 5 bits on the wire — hence a raw 125 megabaud to yield a useful 100 Mb/s. After subtracting those overheads, real transfer rarely exceeds 110–112 MiB/s. A user who expected "125" sees 112 and again feels cheated — even though nobody stole anything.

Why the mebibyte is still an orphan

The standard is a quarter of a century old, correct and logical — and yet almost no one ever sees it. The main reason is a single one: Microsoft Windows, the system of hundreds of millions of people, consistently divides by 1024 but labels the result with the decimal "GB". This entrenches bad habits on a mass scale. On top of that comes an image risk: if a manufacturer switched overnight to correct notation, users' files would "shrink" by a few percent in numerical terms — and a flood of unjustified complaints would follow.

You can live with that inconsistency as long as we are talking about a USB stick. But we are entering an era of clouds measured in exabytes and zettabytes, where the difference between binary and decimal counting exceeds 15–20%. At that scale a "small imprecision" turns into an error that cannot be tolerated in storage bills or memory allocation. The discipline is therefore simple, though still rarely observed: IEC units (KiB, MiB, GiB) wherever addressing is binary — RAM, file-system blocks — and SI prefixes (kB, MB, GB) for the raw capacity of media and for network speeds. The letter "i" is not a typo. It is a declaration that this time the count was honest.

Further reading

• IEC 80000-13, Quantities and units – Part 13: Information science and technology — the official standard defining the binary prefixes.
• NIST, Definitions of the SI units: The binary prefixes — the concise position of the US metrology institute.
• Wikipedia, Timeline of binary prefixes — the history of reform attempts (kappa, "bK", Martin's notation) and standardisation.
• Ubuntu Wiki, UnitsPolicy — the model, strict policy separating SI and IEC units in an operating system.