About

Every hex digit maps exactly to a 4-bit binary nibble. This relationship is not approximate. It is a mathematical identity rooted in the fact that 16 = 2⁴. A single misread bit flips a nibble and corrupts memory addresses, color codes, MAC addresses, or firmware payloads. Manual grouping errors account for a disproportionate share of embedded-systems bugs during code review. This converter normalizes your binary input, pads it to the nearest 4-bit boundary, and produces the exact hexadecimal equivalent with a nibble-by-nibble breakdown so you can audit each step.

The tool handles arbitrary-length binary strings. It strips whitespace and validates that every character is 0 or 1 before conversion. Limitation: this is an unsigned integer converter. It does not interpret two's complement sign bits or IEEE 754 floating-point layouts. Pro tip: when working with register dumps, paste the full binary word including leading zeros to preserve alignment in the hex output.

Formulas

The conversion from base-2 to base-16 exploits the identity 16 = 2⁴. Each group of 4 binary digits (a nibble) maps to exactly one hexadecimal digit.

H_i = map(b_4i+3b_4i+2b_4i+1b_4i)

The positional value of each nibble is computed as:

d = b₃ × 2³ + b₂ × 2² + b₁ × 2¹ + b₀ × 2⁰

Where b_k ∈ {0, 1} is the bit at position k within the nibble, d is the resulting decimal value (0 - 15), and H_i is the hex character for that value. The binary string is right-aligned and zero-padded on the left so its length is a multiple of 4.

Reference Data

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

Frequently Asked Questions

Hexadecimal digits map one-to-one with 4-bit nibbles. If the binary string length is not a multiple of 4, the leftmost group has fewer than 4 bits. Padding with leading zeros on the left preserves the numeric value while ensuring every group is exactly 4 bits wide. For example, 11010 (5 bits) becomes 0001 1010 and converts to 1A.

No. This tool treats the input as an unsigned binary integer. It does not interpret the most significant bit as a sign bit. If you have an 8-bit two's complement value like 11111110 (which represents −2 in signed notation), the converter will output FE, which is the unsigned hexadecimal equivalent (decimal 254). You must apply two's complement interpretation separately.

The converter operates on the string representation, not on JavaScript's Number type, so it is not limited to 53-bit integers. You can input binary strings of several thousand bits. The nibble-by-nibble mapping is O(n) and does not lose precision because no numeric parsing occurs - each 4-character substring is looked up directly.

Yes. The converter strips all whitespace before processing. You can paste formatted binary such as 1010 0011 1111 0001 and it will be normalized to 1010001111110001 before conversion. Only characters 0, 1, and whitespace are accepted. Any other character triggers a validation error.

The step-by-step breakdown shows each 4-bit nibble alongside its hex digit. You can cross-reference each group with the reference table. Additionally, converting the hex result back to binary should yield the original (zero-padded) input. For quick checks: A = 1010, F = 1111, 0 = 0000.

Hex is a compact representation. An 8-bit byte like 11010110 becomes D6 - two characters instead of eight. In memory dumps, register views, MAC addresses, and color codes (#FF8800), hex is the standard notation because it reduces visual clutter while maintaining a trivial relationship with the underlying bits.