Hexadecimal number system

The hexadecimal number system is base $16$. It uses sixteen distinct digit symbols: $0,1,2,3,4,5,6,7,8,9$ and then $A,B,C,D,E,F$ for values $10$ through $15$.

Hex is everywhere in computing because it lines up cleanly with binary: every hex digit corresponds to exactly $4$ bits ($2^4=16$). Reading or writing memory addresses, machine code, byte values — anything binary that’s more than a few bits — is easier in hex than in binary.

Hex digit table

Decimal	Binary	Hex
0	0000	0
1	0001	1
2	0010	2
3	0011	3
4	0100	4
5	0101	5
6	0110	6
7	0111	7
8	1000	8
9	1001	9
10	1010	A
11	1011	B
12	1100	C
13	1101	D
14	1110	E
15	1111	F

Notation

Hex literals are typically prefixed to mark the base:

• 0xFF — common in C, JavaScript, Python.
• \$FF or #FF — assembly.
• ${\text{FF}}_{16}$ — math notation.

The prefix is purely a label; the value is the same regardless of how you write it. $\text{0xFF}={\text{FF}}_{16}=255_{10}$.

Conversion to decimal

Standard positional expansion: each hex digit times its place value.

$\text{0xFF}=15\cdot 16^1+15\cdot 16^0=240+15=255$

$\text{0x5C6}=5\cdot 16^2+12\cdot 16^1+6\cdot 16^0=1280+192+6=1478$

Conversion to/from binary

The killer feature of hex: every digit is exactly 4 bits. To convert hex → binary, replace each hex digit with its 4-bit pattern. Concatenate the results — no decimal in the middle.

$\text{0xFEAE}=\text{F E A E}=1111111010101110=1111111010101110_2$

To go binary → hex, group the bits into chunks of 4 starting from the right (the radix point), then map each chunk to its hex digit.

$11100011_2\to 11100011\to \text{E 3}\to \text{0xE3}$

If the leftmost group is short, pad with leading zeros: $1100101_2=01100101=\text{0x65}$.

Why it’s useful

Three places hex shows up constantly:

1. Memory addresses. A 32-bit address has 8 hex digits — much easier to read and write than 32 binary digits.

2. Byte values. Each byte fits in 2 hex digits ($00$ to $FF$). Color codes (#FF8800), MAC addresses (AA:BB:CC:DD:EE:FF), checksums — all conventional in hex.

3. Bit patterns in code. When you need a specific 32-bit constant in software, writing 0xFFFF0000 is far less error-prone than writing $\underset{16}{\underbrace{1111111111111111}}\underset{16}{\underbrace{0000000000000000}}$.

For the general theory of converting between any two bases, see Base Conversion.