About

Binary Coded Decimal (BCD) encodes each decimal digit 0 - 9 as a fixed-width 4-bit binary nibble. This encoding is standard in financial hardware, real-time clocks (RTCs), and BIOS date registers where decimal readability matters more than storage efficiency. A common error is treating raw BCD bit patterns as pure binary, which produces incorrect decimal values and corrupts downstream hex representations. This tool parses packed BCD input, validates that no nibble exceeds 1001₂ (9₁₀), reconstructs the decimal integer, and converts it to hexadecimal. It assumes standard 8421-weighted BCD. Excess-3 and Aiken codes are not supported.

Formulas

The 8421 BCD encoding maps each decimal digit to a 4-bit nibble weighted by powers of 2. Given a BCD bit string of n nibbles, the decimal reconstruction is:

D = n−1∑i=0 d_i × 10ⁱ

where d_i is the decimal value of the i-th BCD nibble (counting from the least significant). Each nibble is decoded as:

d_i = b₃ × 8 + b₂ × 4 + b₁ × 2 + b₀ × 1

A nibble is valid only if d_i ≤ 9. The final hexadecimal output is computed by converting the decimal integer D to base 16:

H = D.toString(16)

where D = decimal integer, H = hexadecimal string, b₃…b₀ = individual bits in a nibble (MSB to LSB), n = number of nibbles.

Reference Data

Decimal Digit	BCD (8421)	Hex Equivalent	Excess-3 BCD	Aiken (2421)
0	0000	0	0011	0000
1	0001	1	0100	0001
2	0010	2	0101	0010
3	0011	3	0110	0011
4	0100	4	0111	0100
5	0101	5	1000	1011
6	0110	6	1001	1100
7	0111	7	1010	1101
8	1000	8	1011	1110
9	1001	9	1100	1111
Nibbles 1010 - 1111 are invalid in 8421 BCD
10	0001 0000	A	-	-
15	0001 0101	F	-	-
16	0001 0110	10	-	-
99	1001 1001	63	-	-
100	0001 0000 0000	64	-	-
127	0001 0010 0111	7F	-	-
255	0010 0101 0101	FF	-	-
256	0010 0101 0110	100	-	-
999	1001 1001 1001	3E7	-	-
1000	0001 0000 0000 0000	3E8	-	-
4096	0100 0000 1001 0110	1000	-	-
9999	1001 1001 1001 1001	270F	-	-
65535	0110 0101 0101 0011 0101	FFFF	-	-

Frequently Asked Questions

Nibble values from 1010 (10) through 1111 (15) are undefined in standard 8421 BCD. This converter flags them as invalid and halts the conversion, because interpreting them would produce incorrect decimal digits. Some legacy systems use these codes for sign indicators (e.g., 1100 for positive, 1101 for negative in IBM mainframes), but that is a non-standard extension.

Packed BCD stores two decimal digits per byte (8 bits, two nibbles). Unpacked BCD wastes the upper nibble of each byte, storing one digit per byte (often with the upper nibble zeroed or set to 0011 for ASCII compatibility). This tool accepts raw 4-bit nibbles sequentially, which is equivalent to packed BCD. If your source data is unpacked, strip the upper 4 bits of each byte before entering.

BCD and pure binary are different encodings. For example, decimal 25 in BCD is 0010 0101 (two nibbles: 2 and 5). Interpreted as pure 8-bit binary, 00100101 equals decimal 37, which is hex 25. But the correct BCD interpretation yields decimal 25, which is hex 19. The discrepancy grows with larger values. Always clarify whether your source data is BCD-encoded or raw binary before converting.

JavaScript safely represents integers up to 2⁵³ − 1 (9007199254740991), which is a 16-digit decimal number. This tool uses BigInt internally for values exceeding that threshold, supporting arbitrarily large BCD strings. Practically, inputs up to 64 nibbles (16 bytes of packed BCD) are handled without precision loss.

Yes. Switch the direction toggle to Hex → BCD mode. The converter parses the hex string, converts it to a decimal integer, then encodes each decimal digit as a 4-bit BCD nibble. Note that not every hex value maps to a "round" BCD output. For example, hex FF equals decimal 255, which becomes BCD 0010 0101 0101.

This tool left-pads the input to the nearest 4-bit boundary. If you enter 10101 (5 bits), it becomes 00010101 (8 bits, two nibbles: 1 and 5). Leading zero nibbles are preserved in the breakdown display but do not affect the decimal or hex result. This matches how hardware BCD registers handle alignment.