About

Binary-Coded Decimal (BCD) represents each decimal digit (0 - 9) as a fixed 4-bit binary nibble. This encoding differs fundamentally from pure positional binary. A decimal value like 93 occupies 8 BCD bits (1001 0011) but only 7 bits in pure binary (1011101). BCD wastes roughly 20 - 25% of bit space because nibbles 1010 through 1111 are illegal. However, BCD avoids rounding errors in decimal arithmetic, which is why financial hardware (POS terminals, COBOL systems, certain FPGAs) still uses it. Feeding an illegal nibble into a BCD adder circuit produces undefined behavior. This tool validates every nibble before conversion.

The converter handles both directions: BCD → pure binary and pure binary → BCD. It flags invalid BCD nibbles, shows the intermediate decimal value, and provides a step-by-step breakdown of each nibble. This tool approximates no intermediate floating-point values. All arithmetic is integer-based. Note: for numbers exceeding 2⁵³ − 1 (JavaScript’s safe integer limit), results may lose precision. Use BigInt-capable environments for cryptographic-scale BCD.

Formulas

BCD encoding maps each decimal digit d (0 ≤ d ≤ 9) independently to a 4-bit nibble. Given a decimal number N with digits d_kd_k−1…d₁d₀, the BCD representation concatenates each digit’s 4-bit form:

BCD(N) = bin₄(d_k) ‖ bin₄(d_k−1) ‖ … ‖ bin₄(d₀)

where bin₄(d) is the 4-bit binary representation of digit d, and ‖ denotes concatenation.

To convert BCD back to pure binary, first recover the decimal value:

N = k∑i=0 d_i ⋅ 10ⁱ

Then convert N to positional binary via successive division by 2:

bin(N) = N mod 2 , N = ⌊N2⌋ (repeat until N = 0)

A nibble is invalid BCD if its decimal value exceeds 9:

{

VALID if 0000₂ ≤ nibble ≤ 1001₂INVALID if 1010₂ ≤ nibble ≤ 1111₂

where d_i = individual decimal digit, k = number of digits − 1, N = reconstructed decimal integer, bin₄ = zero-padded 4-bit binary function.

Reference Data

Decimal Digit	BCD (4-bit)	Pure Binary	Hex	BCD Valid
0	0000	0	0x0	✓
1	0001	1	0x1	✓
2	0010	10	0x2	✓
3	0011	11	0x3	✓
4	0100	100	0x4	✓
5	0101	101	0x5	✓
6	0110	110	0x6	✓
7	0111	111	0x7	✓
8	1000	1000	0x8	✓
9	1001	1001	0x9	✓
-	1010	1010	0xA	✗ Invalid
-	1011	1011	0xB	✗ Invalid
-	1100	1100	0xC	✗ Invalid
-	1101	1101	0xD	✗ Invalid
-	1110	1110	0xE	✗ Invalid
-	1111	1111	0xF	✗ Invalid
Multi-digit BCD Examples
42	0100 0010	101010	0x2A	✓
99	1001 1001	1100011	0x63	✓
100	0001 0000 0000	1100100	0x64	✓
255	0010 0101 0101	11111111	0xFF	✓
1000	0001 0000 0000 0000	1111101000	0x3E8	✓
9999	1001 1001 1001 1001	10011100001111	0x270F	✓

Frequently Asked Questions

BCD arithmetic circuits (e.g., the 74xx83 adder with correction logic) expect each nibble to map to a decimal digit 0 - 9. Nibbles above 1001 produce carry/correction signals at wrong times. In a BCD adder, when a nibble sum exceeds 9, the circuit adds 0110 (6) to correct back into valid BCD range. If your input already contains illegal nibbles, this correction produces garbage. The tool flags any nibble where the decimal equivalent exceeds 9.

BCD uses 4 bits per decimal digit. A k-digit decimal number requires 4k BCD bits. Pure binary needs only ⌈log₂(10^k)⌉ ≈ 3.32k bits. The overhead is roughly 20%. For a 3-digit number (max 999): BCD uses 12 bits, pure binary uses 10 bits. For 16 digits: BCD uses 64 bits, pure binary needs 54 bits.

This tool works with standard 8421 BCD (also called packed BCD), where each decimal digit occupies exactly 4 bits. Unpacked BCD (where each digit occupies 8 bits with the upper nibble zeroed) should first be stripped of its padding. Simply remove leading 0000 prefixes from each byte to get packed BCD before feeding into the converter.

The converter left-pads the input with zeros to make the total length a multiple of 4. For example, input 10010 (5 bits) becomes 00010010 (8 bits), yielding nibbles 0001 and 0010, which decode to decimal 12. This matches the convention used in hardware BCD registers.

Standard 8421 BCD has no native sign or radix point. Signed BCD typically uses a sign nibble (1100 for positive, 1101 for negative) appended at the end, as in IBM mainframe packed decimal format. Fractional BCD simply places a virtual decimal point between nibbles. This tool handles unsigned integer BCD only. For signed or fractional BCD, split the input manually at the sign/radix boundary.

Financial systems (COBOL, IBM System/360 descendants, POS terminals, tax calculators) require exact decimal arithmetic. Pure binary cannot represent 0.1 exactly (it becomes 0.0001100110011... repeating). BCD avoids this by encoding decimal digits directly. The 20% storage overhead is acceptable when rounding errors mean regulatory non-compliance. Modern x86 CPUs still include BCD instructions (DAA, DAS) for legacy compatibility.