Bytes to Kilobytes (B to KB)

One byte equals exactly 8 bits, encoding 2⁸ = 256 distinct values (0–255 unsigned, or −128 to +127 in two's-complement signed representation). The byte is the smallest individually-addressable unit of memory in essentially all modern computer architectures, and is the unit in which file sizes, memory capacities, and storage media capacities are reported. The IEC formal name for the 8-bit byte is the "octet" (IEC 60027-2:2005, IEC 80000-13:2008), used in international standards documents and in networking RFCs to disambiguate from historical machines where "byte" meant other widths. ASCII (ANSI X3.4-1968) encodes a single character in 7 bits within an 8-bit byte; UTF-8 (RFC 3629, 2003) encodes the full Unicode code-point repertoire in 1 to 4 bytes per code point, with the ASCII subset occupying 1 byte for backward compatibility. By IEC 80000-13, the symbol B denotes the byte and is distinguished from the bit (symbol b) by capitalisation alone — a typographic distinction that survives intact through internet-speed advertising in Mbps (megabits per second) and storage capacities in MB (megabytes).

The byte was coined in June 1956 by Werner Buchholz, an IBM engineer working on the IBM Stretch (7030), the company's first transistorised supercomputer project. Buchholz needed a name for an addressable group of bits smaller than a machine word, and proposed "byte" — deliberately respelled from "bite" so a single typographical slip could not collapse the new unit into "bit". The respelling was not cosmetic: in early documentation handwritten and typed in mixed lower- and upper-case, "bit" and "bite" were dangerously similar, and the "y" gave the word a unique fingerprint at a glance. Through the late 1950s the byte was variable-width — Stretch's byte ranged from 1 to 8 bits depending on the operation, and contemporary machines such as the IBM 7090 used 6-bit characters. The 8-bit byte was standardised by the IBM System/360 architecture announced on 7 April 1964, which addressed memory in 8-bit bytes and grouped four bytes into a 32-bit word. System/360's commercial success made the 8-bit byte the de facto industry standard, and ANSI X3.4-1968 (ASCII) ratified the 7-bit character within an 8-bit byte for North American computing. The IEC formalised the 8-bit byte as the "octet" in 1998 (IEC 60027-2) to remove the residual ambiguity in international standards work, although in everyday English-language usage "byte" universally means 8 bits. The byte's defining structural problem appeared once storage capacities scaled past the kilobyte: SI prefixes (kilo, mega, giga) are powers of 1000 by long-standing physics convention, but powers of 1024 are mathematically natural for byte-addressed memory and were used by every operating system from CP/M onwards. The IEC 80000-13 standard published in March 2008 introduced the unambiguous binary prefixes — kibibyte (KiB = 1024 B), mebibyte (MiB = 1024² B), gibibyte (GiB), tebibyte (TiB) — but adoption outside Linux distributions and a handful of standards-conscious vendors has been slow.

The byte is the foundational unit of digital information across every computing system in use. Character encoding is its most universal application: every plain-text file, source-code file, email body, JSON document and HTTP header is denominated in bytes, with ASCII assigning 1 byte per English-language character and UTF-8 using 1–4 bytes depending on the Unicode code point (Latin letters and digits remain 1 byte; Cyrillic and Greek 2 bytes; CJK ideographs 3 bytes; emoji and supplementary planes 4 bytes). File-system sizes, memory allocations, network buffer sizes and CPU cache lines are all reported in bytes or byte multiples. The byte is also where the binary/decimal prefix war originates and propagates. Storage manufacturers (Seagate, Western Digital, SanDisk, Samsung) follow the SI convention literally, advertising 1 TB = 10¹² = 1,000,000,000,000 bytes — the convention that gives the largest possible marketing number. Operating systems historically use binary multiples: Microsoft Windows reports a "1 TB" drive as 931 GB because Windows interprets "GB" as 2³⁰ = 1,073,741,824 bytes, exposing a 7.4% gap that has launched a generation of consumer-support escalations. Apple macOS realigned with the SI convention in OS X 10.6 Snow Leopard (2009), reporting drive capacities in decimal gigabytes that match the manufacturer's marketing. Linux distributions vary by tool: `ls -h` and `df -h` use binary kibibyte/mebibyte/gibibyte semantics with SI-style "K/M/G" symbols, while `ls --si` and the GNU `coreutils` documentation expose the IEC distinction explicitly. Network engineering, by long convention, uses decimal multiples for bandwidth (Mbps in millions of bits per second) — a convention covered in detail under the bit, mbps and gbps entries.

One kilobyte (KB) equals 1,000 bytes under the SI decimal convention or 1,024 bytes (= 2¹⁰) under the historical binary convention used by operating systems and embedded-firmware tooling. The IEC 80000-13:2008 standard introduced the kibibyte (KiB) as the unambiguous name for 1,024 bytes, leaving "kilobyte" formally restricted to the decimal 1,000-byte meaning, but adoption outside Linux distributions and standards-conscious documentation has been limited. In practice, storage manufacturers and network engineers use 1 KB = 1,000 bytes; Microsoft Windows file managers and most legacy desktop software use 1 KB = 1,024 bytes; the resulting 2.4% gap is small at the kilobyte level but propagates upward — at the megabyte level the gap reaches 4.9%, at gigabyte 7.4%, and at terabyte 10.0%, the source of the famous "my 1 TB drive only shows 931 GB" complaint covered under the byte and tb entries. The kilobyte symbol KB (uppercase B) is distinct from the kilobit symbol Kb (lowercase b), an 8:1 ratio whose typographic ambiguity is the dominant unit-confusion source in network-versus-storage documentation.

The kilobyte entered general computing usage in the 1960s as the natural multiple of the 8-bit byte for the early-mainframe and early-minicomputer era, and became the consumer-facing unit of digital storage roughly from the late 1970s through the mid-1990s — the era of personal microcomputers, dial-up bulletin boards, and removable magnetic media. Through that period the kilobyte was the unit users encountered daily: a TRS-80 Model I shipped with 4 KB of RAM in 1977, the original IBM PC offered 16–64 KB in 1981, and the Commodore 64 took its name from its 64 KB of addressable memory. The kilobyte's defining hardware artefact is the 3.5-inch high-density floppy disk introduced by Sony in 1987 and standardised across the PC industry by the early 1990s. The disk's marketed capacity of "1.44 MB" is one of the most famous unit-labelling errors in computing history: the formatted capacity is 2,880 sectors of 512 bytes each, totalling 1,474,560 bytes — which is exactly 1,440 KiB (using the binary 1 KiB = 1,024 bytes), or 1.4400 mebibytes when correctly labelled. Marketing collapsed the figure to "1.44 MB" using a hybrid convention nobody else uses: 1,440 × 1,024 bytes, mixing decimal thousands at the megabyte level with binary kilobytes underneath. The actual decimal value is 1.474 MB; the actual binary value is 1.406 MiB; the marketed "1.44 MB" is neither. This single label trained an entire generation of PC users to ignore unit-suffix precision, and is the cleanest single example of the binary/decimal mess at the kilobyte level — small here (a 2.4% gap between 1 KB decimal and 1 KiB binary), but compounding upward through every higher prefix as data scales grew.

Embedded systems and microcontroller firmware are the kilobyte's primary active domain in 2026. The Arduino Uno R3, the most widely-deployed hobbyist microcontroller, ships with 32 KB of flash program memory and 2 KB of SRAM; the ESP8266 and ESP32 Wi-Fi modules used in the IoT-product industry expose flash in 1 MB or 4 MB packages partitioned into 4 KB sectors that firmware-development toolchains report and erase in kilobyte units. The STM32 family from STMicroelectronics, the dominant 32-bit microcontroller line in industrial and automotive applications, spans 16 KB to 2 MB of flash with KB-precision linker scripts for boot loaders, bootloader-update partitions, and OTA-update staging buffers. Real-time operating system images for safety-critical avionics and automotive ECUs (FreeRTOS, VxWorks, AUTOSAR-classic stacks) are routinely sized in tens to hundreds of KB and qualified against KB-level memory budgets per ISO 26262 and DO-178C functional-safety processes. Email and web infrastructure denominate routine payloads in kilobytes. A typical SMTP message body without attachments runs 1–10 KB; the Base64 MIME encoding required for binary attachments adds 37% overhead, so a 100 KB photograph travels as ~137 KB on the wire. A favicon.ico at 16×16 or 32×32 pixels is typically 1–15 KB; a stock CSS stylesheet for a content-managed website runs 10–50 KB minified; a single JavaScript framework chunk after tree-shaking runs 30–80 KB compressed. HTTP/2 and HTTP/3 header-compression budgets, browser network-panel waterfall views, and CDN-billing tiers all expose payload sizes in KB, and front-end performance budgets for the 2024 Core Web Vitals targets (Largest Contentful Paint resource size) are routinely specified in tens of KB per critical-path resource. Retrocomputing and legacy-systems work — vintage-PC restoration, BBS archiving, demoscene productions, vintage-game ROM preservation through MAME and the No-Intro database — denominate ROM and disk images in KB exclusively, since the original media (cartridges, floppy disks, cassette tapes) were sized in KB. The Internet Archive's software-library uploads and the various preservation projects organised through the Software Preservation Network maintain KB-precision metadata for every artefact.