Hexadecimal

In simple terms

Hexadecimal is base 16 instead of base 10. Its 16 digits are 0-9 and then A-F (for 10-15). It’s everywhere in computing because one hex digit is exactly four bits — so you can read a hex string off a screen and convert it to or from binary in your head, four bits at a time.

The Visual Map

flowchart LR
  B["byte: 11010110"] --> N1["high nibble: 1101"]
  B --> N2["low nibble: 0110"]
  N1 --> H1["D"]
  N2 --> H2["6"]
  H1 --> R["0xD6 = 214"]
  H2 --> R

More detail

Each hex digit maps cleanly to four binary digits:

Hex	Binary	Decimal
0	0000	0
4	0100	4
8	1000	8
A	1010	10
F	1111	15

So a byte (8 bits) is exactly two hex digits, from 00 to FF (0 to 255). A 32-bit integer is 8 hex digits, a 64-bit one is 16.

Conventions you’ll see:

• 0x prefix — 0xFF means 255 in hex in most programming languages.
• # prefix — common in CSS for colors (#1f6feb).
• No prefix — addresses in objdump output, memory dumps in debuggers.

Hex dominates wherever you need to look at bits without losing your mind: memory addresses, machine code, hash digests, network captures, RGB colors, encoded characters, hardware registers. Pretty much any time a computer wants to show you a number the size of a byte or larger in a way that maps to bits, it uses hex — debugging crash dumps, reading docs for hardware registers, inspecting checksums, even picking a brand colour.

Under the Hood

Reading and writing hex from code:

n = 214
print(hex(n))             # '0xd6'
print(f"{n:02X}")         # 'D6'  — formatted, upper-case, zero-padded
print(int("d6", 16))      # 214  — parse hex back to a number

# a colour is just three bytes
r, g, b = 0x1F, 0x6F, 0xEB
print(f"#{r:02x}{g:02x}{b:02x}")   # '#1f6feb'

The conversions are trivial precisely because 16 is a power of 2 — each hex digit is an independent 4-bit group, no carrying across digit boundaries.

Engineering Trade-offs

• Hex vs binary. Both show you the bits; hex is 4× denser (0xFF vs 0b11111111). Binary literals only win when individual bit positions matter visually, like documenting a flags register.
• Hex vs decimal. Decimal is natural for quantities, hopeless for bit patterns: you can’t tell from 214 which bits are set, but 0xD6 decodes at a glance. Use decimal for counts, hex for identities, addresses, and masks.
• Hex vs octal. Octal (base 8, 3-bit groups) lost because hardware standardised on 8-bit bytes, which octal splits awkwardly. It survives in one niche — Unix file permissions (chmod 755) — where the three rwx bits per owner/group/world fit octal digits exactly.

Real-world examples

• A SHA-256 hash is 64 hex digits (256 bits / 4).
• A Git commit ID is displayed as 7-40 hex characters.
• An IPv6 address (2001:0db8::1) is groups of hex digits.
• An RGBA colour like #1F6FEBcc packs four bytes: R=1F, G=6F, B=EB, A=cc.
• A MAC address (a4:5e:60:01:23:45) is six hex bytes.

Common misconceptions

• “Hex is a different kind of number.” It’s the same number, just written in base 16 instead of base 10. 0xFF and 255 and 0b11111111 are all the same value.
• “Hex digits go up to G or H.” Just A-F. Six letters.

Try it yourself

Dump any data as hex with od (part of coreutils):

echo "Hi!" | od -A x -t x1z
# 000000 48 69 21 0a    >Hi!.<

H is 0x48, i is 0x69, ! is 0x21, and the newline is 0x0a. Convert in both directions in your shell:

printf '%x\n' 214        # d6
echo $((16#d6))          # 214

Learn next

• Binary numbers — the underlying base hex is shorthand for.
• Bits — the smallest unit hex helps us read.
• Character encoding — why 0x48 means “H” in the first place.