Kibibyte

Formal Definition

The kibibyte (symbol: KiB) is a unit of digital information storage defined by the International Electrotechnical Commission (IEC) as exactly 2¹⁰ bytes, or 1,024 bytes. The kibibyte was introduced in 1998 as part of the IEC 80000-13 standard to provide an unambiguous binary prefix system that distinguishes binary multiples (powers of 1024) from decimal multiples (powers of 1000). The name "kibibyte" is a portmanteau of "kilo binary byte," abbreviated as KiB.

The kibibyte exists to resolve a longstanding ambiguity in computing. For decades, the prefix "kilo-" was used informally to mean 1024 in computing contexts, even though its SI definition is exactly 1000. This dual usage caused confusion: a "kilobyte" could mean either 1,000 bytes (SI definition) or 1,024 bytes (binary convention). The IEC binary prefixes — kibi (2¹⁰), mebi (2²⁰), gibi (2³⁰), tebi (2⁴⁰), pebi (2⁵⁰), and exbi (2⁶⁰) — were created specifically to eliminate this ambiguity.

Relationship to Other Units

One kibibyte equals exactly 1,024 bytes, or 8,192 bits. It is 2.4% larger than the decimal kilobyte (1,000 bytes). While the difference at the kibibyte level is small — just 24 bytes — the discrepancy compounds significantly at larger scales: a mebibyte (1,048,576 bytes) is 4.86% larger than a megabyte (1,000,000 bytes), and a tebibyte is 9.95% larger than a terabyte. This escalating difference is the primary reason why IEC binary prefixes were deemed necessary.

Creation of Binary Prefixes

The term "kibibyte" was coined by the International Electrotechnical Commission in December 1998 as part of an effort to standardize binary prefix nomenclature. The IEC's Technical Committee 25 (TC 25) on "Quantities and units" proposed the new prefix system after years of discussion about the confusion caused by using SI prefixes for binary quantities. The prefix "kibi-" is constructed from the first two letters of "kilo" and the first two letters of "binary," yielding "kibi." The same construction principle applies to all IEC binary prefixes: mebi (mega-binary), gibi (giga-binary), tebi (tera-binary), pebi (peta-binary), and exbi (exa-binary).

Adoption Challenges

Despite being standardized for over 25 years, the kibibyte and its sibling units have seen uneven adoption. The IEEE, NIST, and ISO all formally endorse the IEC binary prefixes. Linux operating systems, the GNOME and KDE desktop environments, and many open-source tools use KiB consistently. However, Apple switched macOS to decimal prefixes in 2009, and Microsoft Windows continues to use "KB" to mean 1,024 bytes as of 2024. The computing industry remains divided, with many developers and system administrators preferring the familiar "KB" over the technically correct "KiB."

The Binary Kilobyte Problem

From the earliest days of computing in the 1950s, engineers used the term "kilobyte" to mean 1,024 bytes because computer memory was organized in powers of two. Early computers such as the IBM 7030 (1961) had memory sizes like 32K words, where K meant 1,024. This convention persisted for decades through the personal computer revolution of the 1980s and 1990s: a computer advertised as having "640 KB of RAM" actually had 640 × 1,024 = 655,360 bytes.

The conflict emerged when storage manufacturers began using the SI definition. A "1.44 MB" floppy disk held 1,440 × 1,024 = 1,474,560 bytes — neither 1,440,000 bytes (1.44 MB in SI) nor 1,048,576 bytes (1 MiB). Hard drive manufacturers also adopted the SI definition, advertising "500 GB" drives that held 500,000,000,000 bytes — about 465 GiB. This discrepancy led to consumer confusion and even class-action lawsuits against storage manufacturers.

The IEC Solution

In response, the IEC proposed the binary prefix system in 1996, publishing it formally in 1998 as Amendment 2 to IEC 60027-2. The proposal was developed primarily by the IEC's Technical Committee 25. The intent was clear: reserve SI prefixes (kilo, mega, giga) exclusively for powers of 1000, and use the new binary prefixes (kibi, mebi, gibi) for powers of 1024. The standard was further refined in IEC 80000-13, published in 2008.

Mixed Adoption

Adoption has been gradual and inconsistent. The Linux kernel and associated tools adopted KiB notation early. Ubuntu and other distributions display file sizes in KiB, MiB, and GiB. Apple's macOS switched to decimal kilobytes (1 KB = 1,000 bytes) in Snow Leopard (2009), avoiding the issue entirely by using SI definitions. Microsoft Windows, the most widely used desktop OS, continues to display "KB" meaning 1,024 bytes, creating an ongoing inconsistency with the standard. In practice, the computing world remains split, though technical documentation increasingly uses the correct IEC notation.

Operating Systems and File Managers

The kibibyte is directly relevant whenever file sizes are displayed on a computer. Linux-based systems (Ubuntu, Fedora, Arch Linux) and their file managers generally use KiB, MiB, and GiB when displaying file sizes. The GNOME Files application and KDE Dolphin both use IEC binary prefixes. However, many command-line tools default to powers of 1024 while displaying "K" or "KB" unless specifically configured to use IEC notation.

Programming and Software Development

In programming, the kibibyte is used in memory allocation, buffer sizing, and performance tuning. Memory pages on most architectures are 4 KiB (4,096 bytes). Network packet buffers, file system block sizes, and cache line alignments are all specified in powers of two. Languages such as Python, Go, and Rust have formatting libraries that support KiB notation. The GNU coreutils (ls, du, df) support the --si flag for decimal and -h for binary-with-IEC-prefix output.

Technical Documentation

Technical standards, hardware specifications, and academic papers increasingly use the IEC binary prefixes to avoid ambiguity. JEDEC memory standards, IETF networking RFCs, and Linux kernel documentation all use or recommend KiB notation. The trend toward correctness in technical communication continues, even as everyday usage lags behind.

Storage and Networking

At the kibibyte scale, practical applications include email message sizes (a typical plain-text email is 2-10 KiB), configuration files (often 1-50 KiB), small images and icons (4-256 KiB), and embedded system firmware. Network MTU sizes (typically 1,500 bytes, or approximately 1.46 KiB) and TCP window sizes are often discussed in terms of kibibytes.

File Sizes You Encounter Daily

The kibibyte is the appropriate unit for many common digital files. A typical plain-text email without attachments is 2 to 10 KiB. A favicon (the small icon in a browser tab) is usually 1 to 4 KiB. A short text document or configuration file ranges from 1 to 50 KiB. A single page of formatted text in a word processor is approximately 20 to 40 KiB. Source code files typically range from 1 to 100 KiB, with most individual files falling between 5 and 30 KiB.

Understanding File Size Displays

When you see a file listed as "48 KB" on your computer, the actual byte count depends on your operating system. On Windows, "48 KB" means 48 × 1,024 = 49,152 bytes (which should technically be written as 48 KiB). On macOS (since 2009), "48 KB" means 48 × 1,000 = 48,000 bytes. On most Linux distributions, you would see "48 KiB" meaning 49,152 bytes. This inconsistency is one of the most persistent sources of confusion in everyday computing.

The Kibibyte in Context

To put the kibibyte in perspective: one KiB can store approximately 1,024 ASCII characters — roughly one-fifth of a standard printed page. A typical SMS text message (160 characters) uses about 0.16 KiB if stored in ASCII, or about 0.31 KiB in UTF-16 encoding. A high-resolution smartphone photo (12 megapixels, JPEG compressed) is approximately 3,000 to 8,000 KiB (3-8 MiB). A one-minute MP3 audio file at 128 kbps is roughly 960 KiB.

Computer Science and Memory Architecture

In computer science, the kibibyte is fundamental to understanding memory architecture. Virtual memory pages on x86 and ARM processors are typically 4 KiB (4,096 bytes). The translation lookaside buffer (TLB), which caches virtual-to-physical address translations, operates on these 4 KiB pages. Huge pages, used for performance optimization in databases and virtual machines, are typically 2 MiB (2,048 KiB) or 1 GiB. CPU cache lines are usually 64 bytes (0.0625 KiB), and L1 cache sizes on modern processors range from 32 KiB to 128 KiB per core.

Information Theory

In information theory, precise measurement of data quantities is essential. When calculating entropy, compression ratios, or channel capacity, the distinction between 1,000 and 1,024 can affect results. Researchers in information theory and coding theory use kibibytes (and other IEC units) to ensure unambiguous reporting of data sizes. Published papers in IEEE and ACM venues increasingly require IEC binary prefixes.

Embedded Systems

Embedded systems — the microcontrollers inside cars, appliances, medical devices, and industrial equipment — often have memory measured in kibibytes. A typical ARM Cortex-M0 microcontroller might have 32 KiB of flash memory and 4 KiB of RAM. Firmware engineers must account for every byte, making the precise definition of KiB (versus kB) critical for resource planning. A misunderstanding of 2.4% at these scales could mean the difference between firmware that fits in memory and firmware that does not.