Endianness (big vs little): Visual walkthrough — Hardware deep dive

This page rebuilds the parent note Endianness (big vs little) from absolute zero. Everything used is defined before it appears.

Step 1 — What is a byte, and what is an address?

WHAT. Memory is a long row of tiny boxes. Each box holds exactly one byte — a number from $0$ to $255$ . Each box has a numbered label called its address: $0, 1, 2, 3, \dots$ Because every box has its own address, we call memory byte-addressable.

WHY. Before we can talk about the order of bytes, we must agree on what a byte is (one box, holding $0$ – $255$ ) and what an address is (the box's numeric label). Order only means anything once boxes are lined up and numbered.

PICTURE. Look at the row of white boxes. The number under each box (grey) is its address; that address only counts boxes, not bits.

Why $0$ – $255$ ? A byte is $8$ bits, and $2^{8} = 256$ distinct patterns, i.e. the values $0$ through $255$ . This links to Data Representation.

Step 2 — Why one box is not enough

WHAT. Take the 32-bit value $V = 0x12345678 .$ Here "32-bit" means it needs $32$ bits $= 4$ bytes. One box holds only $8$ bits, so $V$ cannot fit in a single box.

WHY. This is the entire reason endianness exists: the value spans $4$ boxes, and boxes sit at consecutive addresses, so something must decide which quarter of $V$ goes in which box.

PICTURE. The full 32-bit bar is sliced into four 8-bit chunks. Each chunk is a byte we must place somewhere.

byte 3 12 byte 2 34 byte 1 56 byte 0 78

$12$ — the leftmost two hex digits; the highest-weight chunk.
$78$ — the rightmost two hex digits; the lowest-weight chunk.

Step 3 — Significance: why the chunks are not equal

WHAT. The four chunks do not count the same. Reading $V$ as a real number: $V = 0x12 \cdot 2^{24} + 0x34 \cdot 2^{16} + 0x56 \cdot 2^{8} + 0x78 \cdot 2^{0} .$

Term by term:

$0x12 \cdot 2^{24}$ — the top byte, multiplied by $2^{24}$ (shifted left $24$ bits). Biggest contribution → most significant byte (MSB).
$0x34 \cdot 2^{16}$ — next byte, weight $2^{16}$ .
$0x56 \cdot 2^{8}$ — weight $2^{8} = 256$ .
$0x78 \cdot 2^{0}$ — the "ones" byte, weight $1$ → least significant byte (LSB).

WHY. We need this weighting before choosing a storage order, because the two conventions are literally defined by which weight lands at the lowest address. Without knowing which byte is "biggest," the words big-endian and little-endian have no meaning.

PICTURE. A bar chart of the four weights $2^{0}, 2^{8}, 2^{16}, 2^{24}$ on a log scale — you can see that $12$ dominates and $78$ is tiny.

Step 4 — Big-endian: put the big end first

WHAT. Store $V$ starting at base address $A$ . Big-endian rule: the MSB goes at the lowest address. $A + 0 : 12 A + 1 : 34 A + 2 : 56 A + 3 : 78$

WHY. "Big-endian" = "big end first." Since the box at $A + 0$ is the first box, we drop the biggest byte there. This makes a memory dump read left-to-right exactly like the human-written number $12345678$ .

PICTURE. Watch the four coloured chunks fall straight down into the boxes in the same order they appear in the number — no crossing wires.

In formula form, at offset $i$ : $mem [i] = b_{N - 1 - i} (N = 4) .$

$N - 1 - i$ — the reversed index. At $i = 0$ we want the top byte $b_{3}$ ; at $i = 3$ we want $b_{0}$ . So $mem [0] = b_{3} = 12$ . ✓

Step 5 — Little-endian: put the little end first

WHAT. Same value, same base $A$ . Little-endian rule: the LSB goes at the lowest address. $A + 0 : 78 A + 1 : 56 A + 2 : 34 A + 3 : 12$

WHY. "Little end first." The ones-byte $78$ sits at the smallest address. Notice the elegant match: the byte at offset $i$ is exactly $b_{i}$ — offset equals significance index.

PICTURE. Now the chunks cross over: the rightmost chunk $78$ swings to the leftmost box. The crossing wires are the visual signature of little-endian.

$mem [i] = b_{i} .$

$b_{i}$ — no reversal. $mem [0] = b_{0} = 78$ , $mem [3] = b_{3} = 12$ . ✓

Step 6 — The payoff case: reading fewer bytes

WHAT. Take the small value $V = 0x00000005$ at address $100$ , and ask: what if I read only 1 byte at address 100?

Little-endian: $100 : 05, 101 : 00, 102 : 00, 103 : 00$ . Reading $1$ byte at $100$ gives $05$ — the correct value!
Big-endian: $100 : 00, 101 : 00, 102 : 00, 103 : 05$ . Reading $1$ byte at $100$ gives $00$ — wrong; the $05$ hides at $103$ .

WHY. In little-endian the byte at the lowest address is always the low-order part, so widening an $8$ -bit read to $32$ -bit is "free": the extra high bytes already sit at higher addresses. This is one practical reason little-endian is common (see Memory Addressing).

PICTURE. The green arrow reads one box at address $100$ . Little-endian's arrow lands on $05$ ; big-endian's lands on $00$ .

Step 7 — Degenerate & edge cases (never leave a gap)

WHAT & WHY. Every scenario, so nothing surprises the reader:

A single byte ( $N = 1$ ). Then $N - 1 - i = 0 - 0 = 0 = i$ , so big and little give the identical layout $mem [0] = b_{0}$ . A one-byte value has no endianness.
A byte array / string ${’H’, ’i’}$ . Each element is its own one-byte scalar. So H then i on both machines — array element order is not endianness. (See Pointers and Type Punning.)
The value $V = 0$ . All bytes are $00$ ; both conventions store $00000000$ — indistinguishable.
Bits inside a byte are never touched. $0x12 = 00010010$ stays $00010010$ ; only whole boxes move.

PICTURE. Left: the $N = 1$ case, both rules agree. Right: the string case, H/i in the same order on both — with a red "✗ not endianness" stamp.

Step 8 — The detection trick, derived

WHAT. Store int x = 1;, then read the single byte at the lowest address.

If that byte is $01$ → little-endian.
If that byte is $00$ → big-endian.

WHY. The value $1$ has exactly one nonzero byte: its LSB is $01$ , and $b_{1} = b_{2} = b_{3} = 00$ . So the location of the lone $01$ byte reveals the rule. Little-endian puts LSB (the $01$ ) at the lowest address; big-endian buries it at the highest.

PICTURE. Both layouts of the number $1$ ; a pointer reads box $0$ and the result ( $01$ vs $00$ ) labels each machine.

The one-picture summary

Everything at once: the number $0x12345678$ split by significance, the reconstruction weights, and the two storage orders side by side — big-endian straight-down, little-endian crossed-over.

Recall Feynman retelling of the whole walkthrough

A number too fat for one mailbox gets sliced into four byte-chunks. The chunks aren't equal: the leftmost is the "big" chunk (worth $2^{24}$ ), the rightmost the "ones" chunk (worth $1$ ) — that's what the formula $b_{k} = ⌊ V /25 6^{k} ⌋ mod 256$ measures, dividing away low chunks and keeping the bottom one. Now line up four mailboxes. Big-endian drops the big chunk in the first mailbox, so a memory dump reads like a normal number. Little-endian drops the little (ones) chunk first, which crosses the wires but means the first mailbox is always the low-order part — so reading just one byte gives you the small value for free. A one-byte value or a text string looks identical either way, because there's nothing to reorder. And the classic test: store the number $1$ ; its only nonzero byte is $01$ — whichever mailbox that $01$ lands in tells you the machine's rule. Same number every time; only the mailbox-order changes.

Recall

Why does a single-byte value have no endianness?

With

N = 1

, the offset formula gives

N - 1 - i = 0 = i

, so big and little store the identical byte at address 0.

In the formula

b_{k} = ⌊ V /25 6^{k} ⌋ mod 256

, what does dividing by

25 6^{k}

do?

Shifts away (divides out) the low

k

bytes so byte

k

becomes the lowest remaining one.

Little-endian: byte at offset

i

equals?

b_{i}

(offset equals significance index, LSB at lowest address).

Big-endian: byte at offset

i

equals?

b_{N - 1 - i}

(reversed index, MSB at lowest address).

Why is widening an 8→32-bit read "free" in little-endian?

The lowest address always holds the low-order byte, so the extra high bytes already sit at higher addresses.

Store int 1; byte at lowest address is 0x01 — which endianness?

Little-endian (LSB 0x01 sits at the lowest address).

Is {'H','i'} reordered by endianness?

No — each element is its own 1-byte scalar; array order is unchanged on both machines.

Connections

Endianness (big vs little) — parent topic; this page is its picture-by-picture derivation.
Data Representation — the weighting $V = \sum b_{k} 25 6^{k}$ used in Steps 2–3.
Bitwise Operations — shift = divide by power of two, mask = mod, used to extract bytes.
Memory Addressing — byte-addressable boxes and lowest-address ordering.
Pointers and Type Punning — reading one byte at the lowest address (detection trick).
Network Protocols — big-endian is "network byte order" for multi-byte fields.