About

Binary-Coded Decimal (BCD) encodes each decimal digit (0 - 9) into a fixed 4-bit binary nibble. A valid BCD nibble never exceeds 1001 (9 in decimal). Nibbles from 1010 through 1111 are illegal in BCD and indicate corrupted data or an encoding error. Misinterpreting BCD as straight binary produces incorrect values that cascade through financial systems, industrial PLCs, and legacy COBOL data stores. This tool validates every nibble before conversion and flags illegal codes immediately.

Packed BCD stores two decimal digits per byte, making it space-efficient for applications like mainframe transaction records and seven-segment display drivers. The conversion from packed BCD to hexadecimal requires first recovering the decimal value, then re-encoding in base-16. This tool handles arbitrarily long BCD strings. Note: leading zeros in the decimal intermediate are preserved to maintain digit alignment with the original BCD word length.

Formulas

Packed BCD encodes one decimal digit per 4-bit nibble. A BCD string of length n bits represents n ÷ 4 decimal digits. The decimal recovery formula:

D = k−1∑i=0 d_i ⋅ 10ⁱ

where d_i is the decimal value of the i-th nibble (from least significant), and k is the total number of nibbles. Each d_i must satisfy 0 ≤ d_i ≤ 9.

Once the decimal value D is recovered, the hexadecimal conversion uses repeated division:

D = m−1∑j=0 h_j ⋅ 16^j

where h_j ∈ {0 - 9, A - F} are the hex digits and m is the number of hex digits. The validity constraint per nibble is:

{

VALID if nibble ≤ 1001₂INVALID if nibble ≥ 1010₂

where D = recovered decimal value, d_i = decimal digit from nibble i, h_j = hexadecimal digit at position j, k = total nibble count, m = hex digit count.

Reference Data

Decimal Digit	BCD (4-bit)	Hex	Binary (True)	Valid BCD?
0	0000	0	0000	Yes
1	0001	1	0001	Yes
2	0010	2	0010	Yes
3	0011	3	0011	Yes
4	0100	4	0100	Yes
5	0101	5	0101	Yes
6	0110	6	0110	Yes
7	0111	7	0111	Yes
8	1000	8	1000	Yes
9	1001	9	1001	Yes
-	1010	A	1010	No (illegal)
-	1011	B	1011	No (illegal)
-	1100	C	1100	No (illegal)
-	1101	D	1101	No (illegal)
-	1110	E	1110	No (illegal)
-	1111	F	1111	No (illegal)
42	0100 0010	2A	0010 1010	Yes (packed)
99	1001 1001	63	0110 0011	Yes (packed)
128	0001 0010 1000	80	1000 0000	Yes (packed)
255	0010 0101 0101	FF	1111 1111	Yes (packed)
1000	0001 0000 0000 0000	3E8	0011 1110 1000	Yes (packed)
9999	1001 1001 1001 1001	270F	0010 0111 0000 1111	Yes (packed)

Frequently Asked Questions

Nibbles from 1010 (10) through 1111 (15) are illegal in standard 8421 BCD. This tool flags each invalid nibble and refuses conversion, because processing illegal nibbles as valid digits produces silently wrong results. Some legacy systems use these codes for sign indicators (e.g., 1100 for + and 1101 for − in IBM mainframes), but this converter treats them as errors per the ISO/IEC 7811 standard.

In straight binary, 0001 0000 equals decimal 16 (hex 10). In BCD, the same bit pattern represents decimal 10 (two nibbles: 1 and 0), which converts to hex A. The intermediate decimal step is what makes BCD unique. Confusing the two encoding schemes causes off-by-six errors per nibble, compounding across multi-byte values.

A 4-bit nibble can represent 16 values (0 - F), but BCD only uses 10 of them (0 - 9). That wastes 6 codes per nibble, or roughly 37.5% of the encoding capacity. An 8-bit byte in binary can hold values 0 - 255, but in packed BCD it only holds 0 - 99. The tradeoff is that BCD preserves exact decimal fractions, which is critical for financial arithmetic where IEEE 754 floating-point rounding is unacceptable.

Yes. If the input length is not divisible by 4, the tool automatically pads the leftmost (most significant) side with leading zeros to form a complete nibble. For example, input 110 is treated as 0110 (decimal 6, hex 6). This matches the convention used in hardware BCD registers where partial nibbles are zero-extended.

This tool uses JavaScript BigInt internally for arbitrarily large decimal intermediates. Practically, inputs up to several hundred nibbles (hundreds of decimal digits) convert without precision loss. Standard IEEE 754 numbers lose precision beyond 15 - 17 significant digits, so the BigInt approach is essential for realistic BCD payloads from mainframe data dumps or industrial sensor logs.

Switch the mode to Hex → BCD. The tool parses the hex string, converts it to a decimal integer (via BigInt), then encodes each decimal digit as a 4-bit BCD nibble. For example, hex FF = decimal 255 = BCD 0010 0101 0101. The output nibbles are space-separated for readability.