Binary to Decimal Converter

How Binary-to-Decimal Conversion Works

Binary (base-2) uses only the digits 0 and 1. Each position represents a power of 2, doubling from right to left. To convert binary to decimal, multiply each binary digit by its place value and sum the results.

Example: Convert 1011₂ to decimal

• Position 3 (leftmost): 1 × 2³ = 1 × 8 = 8
• Position 2: 0 × 2² = 0 × 4 = 0
• Position 1: 1 × 2¹ = 1 × 2 = 2
• Position 0 (rightmost): 1 × 2⁰ = 1 × 1 = 1
• Total: 8 + 0 + 2 + 1 = 11

For decimal to binary, repeatedly divide by 2 and record remainders from bottom to top. 11 ÷ 2 = 5 R1, 5 ÷ 2 = 2 R1, 2 ÷ 2 = 1 R0, 1 ÷ 2 = 0 R1 → reading remainders upward: 1011.

This positional notation system works the same way as decimal — just with a different base. In decimal (base-10), the number 347 means 3×10² + 4×10¹ + 7×10⁰ = 300 + 40 + 7. Binary uses the same principle with powers of 2 instead of powers of 10.

Binary Place Values Reference

The 8-bit byte is the fundamental unit of computer storage. Here's the complete place value table for 8-bit numbers (0–255):

A byte can represent any value from 0 (00000000₂) to 255 (11111111₂). Two bytes (16 bits) cover 0–65,535. Four bytes (32 bits) cover 0–4,294,967,295.

Extended Powers of 2 Table

For programmers and computer scientists, knowing powers of 2 up to 2⁶⁴ is essential for understanding memory addressing, data types, and system limits:

Note the difference between binary prefixes (KiB, MiB, GiB — powers of 2) and SI prefixes (KB, MB, GB — powers of 10). 1 GB = 1,000,000,000 bytes; 1 GiB = 1,073,741,824 bytes. This ~7% difference explains why a "500 GB" hard drive shows as ~465 GiB in your OS (which typically uses binary units internally).

Common Binary Values in Computing

These binary values appear frequently in programming, networking, and system administration:

Binary, Hexadecimal, and Octal Comparison

Programmers use different number bases depending on context. Here's how the same values appear in each system:

Hexadecimal is the most common shorthand for binary because each hex digit maps to exactly 4 binary bits — making conversion trivial. Octal maps 3 bits per digit and is primarily used for Unix file permissions (e.g., chmod 755 = 111 101 101 in binary = rwxr-xr-x).

Signed Binary Numbers (Two's Complement)

Computers represent negative numbers using two's complement — the standard defined by IEEE and used by virtually all modern processors. In an 8-bit two's complement system:

To negate a number in two's complement: invert all bits and add 1. For example, +5 = 00000101 → invert → 11111010 → add 1 → 11111011 = −5.

The ranges for common integer types:

Binary in Everyday Technology

Binary is the foundation of all modern computing because transistors have two stable states (on/off, 1/0). Key applications:

• File sizes: 1 kilobyte = 2¹⁰ = 1,024 bytes; 1 megabyte = 2²⁰ = 1,048,576 bytes; 1 gigabyte = 2³⁰ bytes
• Colors: RGB colors are three 8-bit values. #FF5733 in hex = (255, 87, 51) in decimal = (11111111, 01010111, 00110011) in binary
• ASCII encoding: The letter 'A' = decimal 65 = binary 01000001; 'a' = 97 = 01100001
• Unicode: Most text characters fit in 16-bit binary (0–65,535 range)
• IP addresses: IPv4 addresses are four 8-bit binary groups: 192.168.1.1 = 11000000.10101000.00000001.00000001

Understanding binary directly helps in programming (bitwise operations, flags), networking (IP/subnet calculations), and working with low-level hardware.

Binary Arithmetic: Addition and Subtraction

Binary arithmetic follows the same rules as decimal, but with only two digits. The addition table is:

Example: 1011 + 0110

Working right to left: 1+0=1, 1+1=10 (write 0 carry 1), 0+1+1=10 (write 0 carry 1), 1+0+1=10 (write 0 carry 1). Result: 10001 (decimal: 11+6=17 ✓)

Subtraction in hardware is typically performed by adding the two's complement of the subtrahend. To compute A−B, the processor calculates A + (−B), where −B is the two's complement of B. This allows a single adder circuit to handle both addition and subtraction.

Bitwise Operations

Programming languages provide bitwise operators that manipulate individual bits. These are fundamental for low-level programming, embedded systems, and performance optimization:

Bit shifting is significantly faster than multiplication/division in many processors. x << 1 is equivalent to x × 2, and x >> 1 is equivalent to x ÷ 2 (integer division). Game engines and embedded firmware use these operations extensively for performance.

Binary-Coded Decimal (BCD)

Binary-Coded Decimal represents each decimal digit using its own 4-bit binary pattern. Unlike pure binary, BCD preserves the decimal structure:

BCD is less space-efficient than pure binary (10 of the 16 possible 4-bit combinations are used), but it simplifies decimal display — each nibble maps directly to a displayed digit. BCD is used in digital clocks, calculators, financial systems (where exact decimal representation matters), and older mainframe databases (COBOL, IBM EBCDIC).

Floating-Point Binary (IEEE 754)

Decimal numbers with fractional parts (like 3.14) are stored in binary using the IEEE 754 standard. A 32-bit (single-precision) float has three parts:

Example: The decimal number −6.5 in IEEE 754 single-precision:

1. Sign = 1 (negative)
2. 6.5 in binary = 110.1₂ = 1.101 × 2² (normalized)
3. Exponent = 2 + 127 (bias) = 129 = 10000001₂
4. Mantissa = 10100000000000000000000 (23 bits, implicit leading 1 omitted)
5. Full representation: 1 10000001 10100000000000000000000

This is why 0.1 + 0.2 ≠ 0.3 in most programming languages — the decimal fraction 0.1 has an infinite repeating representation in binary (like 1/3 in decimal = 0.333…), so it must be rounded, introducing tiny errors. For financial calculations, use decimal arithmetic libraries (Python's decimal module, Java's BigDecimal) instead of floating-point.

Character Encoding: From ASCII to UTF-8

Text is stored as binary numbers mapped to characters. The evolution of character encoding reflects the global expansion of computing:

UTF-8 encodes ASCII characters in a single byte (identical to plain ASCII), European characters in 2 bytes, CJK characters in 3 bytes, and emoji in 4 bytes. Over 98% of all web pages use UTF-8 encoding (per W3Techs, 2024).

Binary Logic Gates

Logic gates are the physical building blocks of all digital circuits. Each gate performs a simple binary operation on one or two input bits:

The NAND gate is called a universal gate because any other logic function can be built using only NAND gates. Modern CPUs contain billions of transistors arranged into NAND and NOR gates, which are then combined into adders, multiplexers, flip-flops, and all the other building blocks of a processor. The Apple M3 chip contains approximately 25 billion transistors — each one a microscopic binary switch that is either on (1) or off (0).

The XOR gate has a special property: it outputs 1 when the two inputs are different. This makes it the foundation of binary addition (the sum bit of a half adder), error detection (parity checks), and simple encryption (XOR cipher).

History of Binary: From Leibniz to Modern Computing

The binary number system has a rich intellectual history:

Leibniz's insight that all numbers could be expressed using only 0 and 1 was purely mathematical — he never imagined electronic computers. Shannon's 1937 master's thesis connected Boolean (binary) logic to electrical relays, creating the theoretical foundation for all digital electronics. It has been called "possibly the most important master's thesis of the twentieth century."

Binary in Networking: IP Addresses and Subnet Masks

Understanding binary is essential for network administration. IPv4 addresses and subnet masks are 32-bit binary numbers:

The network address is calculated by ANDing the IP with the subnet mask. The broadcast address sets all host bits to 1. The number of usable host addresses = 2^{(32−prefix)} − 2. For a /24 network: 2⁸ − 2 = 254 usable hosts.

Common subnet sizes: