Byte

A byte is a group of eight bits treated as a single unit, and the smallest unit of memory that most computers can individually name and fetch. Where a bit is a unit of information, a byte is a unit of organization: it gives memory a grain size, lets one character, one small number, or one color channel fit in a single slot, and supplies the "B" in the megabytes and gigabytes used to describe files, memory, and storage.

The byte was named before it was standardized, and for years its size was not fixed at eight. Werner Buchholz of IBM coined the word in 1956 during the design of the Stretch supercomputer, deliberately respelling "bite" to avoid confusion with "bit." Early machines used groups of six, seven, or nine bits, depending on the character set they supported. IBM's System/360, announced in 1964, settled the matter commercially by using eight-bit bytes with byte-addressable memory, and the rest of the industry followed. Because the size was once variable, standards documents, including internet RFCs, often use "octet" for an unambiguous eight-bit unit.

Eight bits give 256 distinct patterns, enough to be a useful building block. That is enough for the 128 codes of ASCII, published in 1963, with room for extensions, for one channel of a pixel's color at 256 brightness levels, or for an unsigned number from 0 to 255. Larger values use several bytes together: a 32-bit integer occupies four, a 64-bit floating-point number eight. Text is where the byte-versus-character confusion arises. In UTF-8, designed by Ken Thompson and Rob Pike in 1992, a character takes one to four bytes, so the letter e takes one byte, an e with an accent takes two, and many emoji take four. The number of bytes in a string is therefore not the number of characters it shows.

The byte: a grouping, an address, a unit of size eight bits travel together, each byte has its own address, and prefixes count bytes Grouping: 8 bits = 1 byte 0 1 0 0 0 0 0 1 as a number: 65 as ASCII text: the letter A as a pixel channel: dark gray 256 possible values (0 to 255) Addressing: one address per byte 32-bit integer 0x12345678 stored in memory little-endian 78 56 34 12 1000 1001 1002 1003 big-endian 12 34 56 78 1000 1001 1002 1003 x86 and most ARM systems: little-endian Size: two ways to count Decimal prefixes (SI) 1 KB = 1,000 bytes 1 GB = 1,000,000,000 bytes Binary prefixes (IEC, 1998) 1 KiB = 1,024 bytes 1 GiB = 1,073,741,824 bytes a 500 GB drive holds about 466 GiB
Memory as a long row of numbered slots
each slot holds one byte and has its own address
Reading a 4-byte integer at address 1000
Fetch bytes 1000 to 1003
four consecutive addresses
Apply the byte order
little-endian puts the least significant byte first
Combine into one value
78 56 34 12 becomes 0x12345678
The program receives 305,419,896
the decimal value of the hexadecimal number 12345678

Addressing is the byte's second job: every byte in memory has its own numbered location. A pointer or memory address is simply the number of a byte, and the width of that number limits how much memory a program can reach. A 32-bit address can name 2^32 bytes, which is 4 GiB, a ceiling that pushed mainstream systems to 64-bit addressing in the 2000s. Multi-byte values raise the question of order: little-endian machines such as x86 store the least significant byte at the lowest address, while big-endian systems, and the network byte order used in internet protocols, store the most significant first. The terms come from Danny Cohen's 1980 essay "On Holy Wars and a Plea for Peace," borrowing the egg-cracking factions in Gulliver's Travels, and mixing them up when reading files or network data is a classic source of bugs.

Byte counts are written with two competing sets of prefixes, a common source of small but real discrepancies. The SI prefixes kilo, mega, and giga mean powers of one thousand, and storage vendors use them: a 500 GB drive holds 500 billion bytes. Operating systems and memory sizes have traditionally used powers of 1,024, so the same drive shows up as about 466 GiB. The International Electrotechnical Commission introduced the binary prefixes kibi, mebi, and gibi in 1998 to make the distinction explicit, and tools that use KiB, MiB, and GiB are unambiguous. A further trap is the capital letter: network speeds are quoted in bits per second, so a 100 Mbps link moves at most 12.5 megabytes per second.

In modern work, the byte remains the practical unit of data handling even as hardware widens. Files, network packets, and database records are sequences of bytes; a program reading them must know the encoding to make sense of the content. Processors fetch memory in larger blocks, such as 64-byte cache lines, and arrange data in aligned multiples of the item size for speed, so the layout of bytes in a structure affects performance. In machine learning, model size is counted in bytes: a model with seven billion parameters stored at two bytes each needs about 14 gigabytes for its weights alone, which is why reduced-precision formats matter.

Read a byte as the unit that turns loose bits into addressable memory — eight bits grouped so each one has a numbered place, a size for characters and small values, and a count that always needs its prefix, order, and encoding spelled out.

Take byte further

Ask the copilot about this term, or have our engineers assess it against your process.

Ask CFSGPT about this → Request a technical assessment → Open the CFS app