Binary to Decimal Converter

Imagine a row of light switches, each wired to a bulb of a different brightness. The rightmost switch controls a bulb worth 1 lumen. The next controls one worth 2, then 4, then 8 — each position doubles the previous. When you read a binary number, you are looking at a snapshot of those switches: 1 means on, 0 means off. The total light in the room is your decimal number.

This doubling pattern is what defines base 2. In the familiar decimal system, each position is worth ten times the one to its right. In binary, that multiplier is 2 instead of 10. Both systems are positional — the value of a digit is inseparable from where it sits. The digit 1 in the leftmost position of an 8-bit number is worth 128; the same digit in the rightmost position is worth exactly 1.

Converting a binary number to decimal is the act of reading those positions, multiplying each active digit by its positional weight, and adding up the contributions. No information is lost or gained in the translation — it is the same quantity expressed in a different notation. A file size of 11010110 in binary and 214 in decimal are describing the exact same count of bytes.

Use this converter when you encounter a binary value in a technical context and need its decimal equivalent to reason about it — reading memory addresses, interpreting permission bits in a Unix file system, decoding colour channel values in an image file, or checking the output of a bitwise operation in code. It is also useful for verifying manual conversions done as a learning exercise.

It is the right tool when the binary string is an unsigned integer — a straightforward count or index. It is not appropriate for signed integers stored in two's complement notation, where the leftmost bit signals negativity rather than a large positive power of 2. It also does not handle binary fractions (numbers with a binary point), floating-point IEEE 754 representations, or binary-coded decimal formats used in some older systems. For those cases, a format-specific decoder is the correct choice.

Mistake 1 — Reading the positions in the wrong direction. The most common error is assigning the weight of 2 raised to the power of 0 to the leftmost digit instead of the rightmost. The rightmost bit is always the least significant bit and always carries the weight of 1. Reversing this assignment produces a completely different decimal value with no obvious error signal, making it hard to catch without a reference check.

Mistake 2 — Treating leading zeros as significant digits that change the value. A binary number like 00001010 has the same decimal value as 1010. Leading zeros are valid input and common in fixed-width formats (an 8-bit register always shows all bit positions), but they do not increase the magnitude of the number. Stripping them before converting is fine; including them is also fine — both produce the same result.

Mistake 3 — Confusing binary representation with binary arithmetic. Students new to the topic sometimes apply decimal addition rules directly to binary strings, treating a 1 next to another 1 as 11 (eleven) rather than two separate bits at different positional weights. Binary notation is not decimal shorthand — each digit must be evaluated at its own positional power of 2 before anything is summed.

The formal conversion formula is a positional sum: for each digit at index i (counting from the right, starting at 0), the contribution to the decimal total is that digit multiplied by 2 raised to the power of i. Written as a sum, the decimal result equals the sum over all positions of (digit at position i) times (2 raised to the power of i).

For the example input 11010110, the bit count is 8 bits and the calculation proceeds position by position. Starting from the left (position 7 down to position 0): the first bit is 1 at position 7, contributing 128; the second is 1 at position 6, contributing 64; the third is 0 at position 5, contributing 0; the fourth is 1 at position 4, contributing 16; the fifth is 0 at position 3, contributing 0; the sixth is 1 at position 2, contributing 4; the seventh is 1 at position 1, contributing 2; the eighth is 0 at position 0, contributing 0. Summing the active contributions gives 214.

The key insight is that only the positions carrying a 1 matter. A long binary number with many zeros is often a small decimal number. Conversely, a short binary number with all 1s can be surprisingly large — an 8 bits-bit number with every position set to 1 would equal the sum of all powers of 2 from 0 through 7, which is 214 when one bit is unset, or 255 when all are set. That upper bound of 255 for a full byte is one of the most important numbers in computing.

The conversion formula assumes an unsigned integer, but real systems often store the same bit pattern with a different contract. In two's complement — the near-universal format for signed integers — a leading 1 bit signals a negative number, and the decimal value is computed by a different algorithm entirely. The same bit pattern 11010110 that this tool correctly reports as 214 would be interpreted as negative 42 in an 8-bit two's complement signed integer context. Knowing which representation applies is a precondition of meaningful conversion, and that context lives in the hardware or language spec, never in the bits themselves.