What is the difference between a carry and overflow?

A carry (C flag) indicates that an unsigned addition exceeded the bit width — e.g., 255 + 1 in 8-bit produces a carry because the unsigned result (256) needs 9 bits. Overflow (V flag) indicates that a signed addition produced an incorrect signed result — e.g., 127 + 1 in 8-bit signed = -128, which is wrong because the sign bit flipped unexpectedly. The two flags serve different purposes: carry for unsigned arithmetic, overflow for signed arithmetic. Our calculator highlights both when they occur.

Why learn binary arithmetic when calculators do it automatically?

Binary arithmetic is essential for anyone working close to hardware: embedded systems engineers configuring microcontroller registers, systems programmers reading kernel code, network engineers calculating subnet masks, and security researchers analysing binary exploits. Even for higher-level developers, understanding binary arithmetic explains why certain bugs exist — like integer overflow vulnerabilities (Ariane 5 explosion, Y2K, Gangnam Style breaking YouTube's 32-bit view counter).

How does binary multiplication compare to decimal multiplication?

Binary multiplication is actually simpler than decimal. The times table has exactly 4 entries: 0×0=0, 0×1=0, 1×0=0, 1×1=1. To multiply two binary numbers: for each 1-bit in the multiplier, write the multiplicand shifted left by that bit's position, then add all partial products. This is precisely how a shift-and-add multiplier works in hardware — and the same algorithm implemented in software on early microprocessors that lacked a hardware multiplier.

Can I perform division that produces a fractional result in binary?

Our calculator performs integer division (quotient and remainder). For fractional binary results, after exhausting the whole part, you add a binary point and continue dividing: multiply the remainder by 2, the whole part is the next fractional bit, repeat. This is analogous to long division in decimal. Many decimal fractions (like 0.1) produce infinite repeating binary fractions — this is the root cause of floating-point precision issues.

How do I mentally convert small decimal numbers to binary?

Find the largest power of 2 less than your number, subtract it, mark a 1 at that bit position, then repeat with the remainder. Example: decimal 42. Powers: 32, 16, 8, 4, 2, 1. 42-32=10 (mark bit 5). 10-8=2 (mark bit 3). 2-2=0 (mark bit 1). Unmarked bits are 0. Result: 32+8+2 = 101010₂. With practice, numbers under 256 become instant. Also useful: memorise the hex-to-binary nibble mapping — every hex digit maps to exactly 4 bits.

Calculators2026-05-10

Binary Calculator: Master Binary Arithmetic, Bitwise Operations, and Two's Complement

Q: How does two's complement actually work?

Two's complement encodes negative numbers so that addition works identically for signed and unsigned values using the same hardware. To represent -N in k bits: compute 2ᵏ − N and write the result in binary. Equivalently: write N in binary, flip all bits (bitwise NOT / ones' complement), then add 1. Example: -5 in 8 bits → 2⁸−5 = 256−5 = 251 → 11111011. When you add 5 (00000101) and -5 (11111011) in 8 bits, you get 00000000 with a carry out of the 8th bit — exactly zero, as expected. That carry is the overflow/carry flag, not part of the result.

Binary arithmetic looks alien the first time you see it: 1010 + 0110 = 10000, no column ever exceeds 1, and subtraction is done by adding the negative version of a number. But this is the exact arithmetic happening billions of times per second inside every processor core of the device you're using right now. A binary calculator brings this hidden layer to the surface — not just converting numbers to binary, but performing addition, subtraction, multiplication, and division directly in base-2, complete with overflow detection, two's complement representation for negative numbers, and configurable bit widths from 8 to 64 bits. Whether you're debugging a low-level firmware routine, teaching a computer architecture course, or calculating subnet masks for a network configuration, our free online binary calculator handles binary arithmetic with the precision and visual clarity that a standard pocket calculator cannot.

computer

Binary Calculator

Free · No registration

Try this tool for free →open_in_new

Step-by-Step Guide

Enter Your Operands in Binary, Decimal, or Hex

Type your numbers in any supported representation — binary (1010), decimal (10), or hexadecimal (A). The calculator shows all three formats simultaneously for each operand, so you always have cross-referencing. For negative numbers, toggle the two's complement mode and select your bit width (8, 16, 32, or 64 bits). In 8-bit two's complement, -5 is represented as 11111011, not just "5 with a minus sign." The tool automatically computes the correct two's complement encoding.

Select Your Operation and Bit Width

Choose from addition, subtraction, multiplication, or division, and set the bit width for the computation. Bit width matters: adding two 8-bit numbers that produce a 9-bit result triggers overflow, and the calculator highlights this in red. For multiplication, the result bit width doubles (two 8-bit inputs can produce up to a 16-bit product). The calculator lets you view results at the natural width or any wider width, which is critical for understanding how CPUs handle carry bits and overflow flags.

Read the Step-by-Step Breakdown

Below each result, the calculator shows the arithmetic worked column by column in binary — just like long addition or multiplication in decimal. For addition: each column's sum (0+0=0, 0+1=1, 1+0=1, 1+1=10 with carry) is annotated. For subtraction using two's complement: the tool shows how the subtrahend is negated (flip bits, add 1), then added. Division shows the long-division steps directly in binary. This level of detail is invaluable for learning and verification.

Tips & Best Practices

check_circle

Binary addition rules: 0+0=0, 0+1=1, 1+0=1, 1+1=10 (write 0, carry 1). This is the same as decimal addition except you carry at 2 instead of 10. Practice on two 4-bit numbers until the carry pattern becomes automatic — then longer widths are just the same pattern repeated.

check_circle

Two's complement is the universal way computers represent negative integers. To negate a number: flip all bits (ones' complement), then add 1. Example: 5 in 8-bit is 00000101. Flip bits: 11111010. Add 1: 11111011 — that's -5. The beauty of two's complement: addition and subtraction use the exact same hardware circuit, no special case for negative numbers.

check_circle

Overflow occurs when a result doesn't fit in the target bit width. In 8-bit unsigned, 255 + 1 = 0 (wraps around). In 8-bit signed (-128 to 127), 127 + 1 = -128 (the most negative value). CPUs set an overflow flag for signed overflow and a carry flag for unsigned overflow — different flags for different interpretations of the same bits.

check_circle

Multiplication by 2ᵏ in binary is simply a left shift by k positions: 101 (5) << 2 = 10100 (20). Division by 2ᵏ is a right shift by k positions: 10100 (20) >> 2 = 101 (5). This is why C compilers replace `x * 8` with `x << 3` — bit shifts are orders of magnitude faster than multiplication in hardware.

check_circle

Bitwise AND can test if a number is even or odd: number & 1 = 0 means even, = 1 means odd. Bitwise OR can set specific bits to 1: setting bit 3 of a value means value | 0b1000 = value | 8. Bitwise XOR can toggle bits: value ^ (1 << n) flips the nth bit. These operations are how device drivers, embedded systems, and performance-critical code interact with hardware registers.

check_circle

In 32-bit arithmetic, the range for unsigned is 0 to 4,294,967,295; for signed (two's complement) it's -2,147,483,648 to 2,147,483,647. Why the asymmetry? Zero takes one of the 2³² possible bit patterns (000...000) on the non-negative side, leaving 2,147,483,647 positive values and 2,147,483,648 negative values.

check_circle

Network subnet masks rely heavily on binary arithmetic. A subnet mask like 255.255.255.0 in binary is 11111111.11111111.11111111.00000000 — exactly 24 ones followed by 8 zeros. Logical AND between an IP address and its subnet mask extracts the network portion. Understanding binary bitwise operations makes IP subnetting intuitive rather than arcane.

Frequently Asked Questions

Two's complement encodes negative numbers so that addition works identically for signed and unsigned values using the same hardware. To represent -N in k bits: compute 2ᵏ − N and write the result in binary. Equivalently: write N in binary, flip all bits (bitwise NOT / ones' complement), then add 1. Example: -5 in 8 bits → 2⁸−5 = 256−5 = 251 → 11111011. When you add 5 (00000101) and -5 (11111011) in 8 bits, you get 00000000 with a carry out of the 8th bit — exactly zero, as expected. That carry is the overflow/carry flag, not part of the result.

Binary arithmetic is not an esoteric skill — it's the layer directly beneath every line of code you write. Our binary calculator makes that layer visible with step-by-step breakdowns, two's complement handling, and overflow detection across 8 to 64 bits. Whether you're debugging, teaching, or learning, see exactly what the silicon is doing.

Try this tool for free →open_in_new