Four Bits per Digit, No More, No Less

The K155ID1 chip sitting on my bench right now has sixteen pins and one job: take four input lines encoding a number 0–9 in binary, and sink current through the corresponding cathode. It’s a BCD-to-decimal decoder, manufactured in the USSR sometime in the 1980s, and it only understands one language.

Binary-Coded Decimal is gloriously wasteful. Four bits can represent sixteen values, but BCD throws away six of them. The pattern 1010 (ten in binary) is invalid. So is 1011, 1100, all the way to 1111. You’re burning transistors to represent nothing. Early computer architects knew this. They did it anyway, because when your output device is a row of Nixie tubes — or a seven-segment display, or a decimal printer — the conversion from BCD to human-readable digits is trivial. Each digit maps to exactly four wires. No division. No modulo arithmetic. Just wire them straight through.

The trade-off crystallizes when you try to do math. Adding 0101 (5) and 0110 (6) in pure binary gives 1011 (eleven) — but that’s not a valid BCD digit. You have to detect the overflow and add six to “wrap” the digit back into range, carrying one to the next position. Hardware BCD adders had extra correction circuits just for this. The Intel 8080 had a DAA instruction (Decimal Adjust Accumulator) that cleaned up after binary addition, converting results back to valid BCD. The Z80 inherited it. So did the 6502, calling it the “decimal mode” flag.

def to_bcd(n: int) -> list[int]:
    """Convert integer to list of 4-bit BCD digits, most significant first."""
    if n == 0:
        return [0]
    digits = []
    while n:
        digits.append(n % 10)
        n //= 10
    return digits[::-1]

def from_bcd(digits: list[int]) -> int:
    """Convert BCD digit list back to integer."""
    return sum(d * (10 ** i) for i, d in enumerate(reversed(digits)))

# Six digits for a clock: 23:59:58
clock_value = 235958
bcd = to_bcd(clock_value)
print(f"{clock_value} → BCD: {[f'{d:04b}' for d in bcd]}")
print(f"Decoded: {from_bcd(bcd)}")

Output:

235958 → BCD: ['0010', '0011', '0101', '1001', '0101', '1000']
Decoded: 235958

Each four-bit group maps directly to one Nixie tube. The K155ID1 sees 0010 on its inputs and grounds cathode 2. No CPU cycles burned on division.

const std = @import("std");

fn toBcd(n: u32, buf: []u4) u8 {
    var val = n;
    var i: u8 = 0;
    if (val == 0) { buf[0] = 0; return 1; }
    while (val > 0 and i < buf.len) : (i += 1) {
        buf[i] = @truncate(val % 10);
        val /= 10;
    }
    std.mem.reverse(u4, buf[0..i]);
    return i;
}

pub fn main() !void {
    var buf: [6]u4 = undefined;
    const len = toBcd(235958, &buf);
    const stdout = std.io.getStdOut().writer();
    for (buf[0..len]) |d| try stdout.print("{b:0>4} ", .{d});
    try stdout.print("\n", .{});
}

By the late 1970s, BCD was fading from general-purpose computing. Binary math was faster, memory was cheaper, and displays could handle the conversion in software. But in embedded systems — calculators, clocks, industrial counters — BCD persisted because the hardware interface demanded it. The K155ID1 was manufactured until the Soviet Union collapsed, and every chip expects those same four lines carrying the same wasteful-but-legible encoding.