Binary Calculator: Add, Subtract, Convert Base 2

The Binary Calculator adds, subtracts, multiplies and divides numbers written in base 2, converts between binary and decimal, and applies bitwise AND, OR, XOR, NOT and shifts. Every result includes the decimal equivalent and a column breakdown so carries and borrows can be checked by hand. Bit width can be set for two's complement work, or left unbounded for exact arithmetic with no register wrap.

All calculation runs in your browser. Nothing you enter is sent to a server.

Add, subtract, multiply and divide binary numbers

Binary arithmetic uses the same column rules as decimal, but each place holds only 0 or 1 and the carry threshold is 2 instead of 10. Enter two binary strings, choose the operation, and the calculator returns the result in binary with the decimal check beside it. Leading zeros are stripped from the output unless a bit width is selected.

Addition carries when a column sums to 2 or more. Subtraction borrows from the next higher bit when the minuend digit is smaller. Multiplication and division follow the same long-form patterns taught for decimal, built from shifts and adds. Invalid digits such as 2 or A are rejected immediately, because they are not legal in base 2.

Convert binary to decimal

Positional notation turns a binary string into a decimal integer by summing each bit multiplied by its power of two. The rightmost bit is 2⁰ (value 1), the next is 2¹ (value 2), then 4, 8, 16, and so on. Enter 10111 and the expansion is 16 + 0 + 4 + 2 + 1 = 23.

1 0 1 1 1
│ │ │ │ └─ 1 × 2⁰ = 1
│ │ │ └─── 1 × 2¹ = 2
│ │ └───── 1 × 2² = 4
│ └─────── 0 × 2³ = 0
└───────── 1 × 2⁴ = 16
                   = 23

Any binary string the calculator accepts converts this way. Grouping into nibbles of four bits makes the places easier to read aloud: 1010 1010 is clearer than eight unbroken digits when checking a subnet mask or a permission bitfield.

Convert decimal to binary

Repeated division by 2 produces binary digits as remainders. Divide the decimal value by 2, record the remainder (0 or 1), divide the quotient again, and continue until the quotient is zero. Reading the remainders from last to first yields the binary form.

For 23:

Step	Quotient	Remainder
23 ÷ 2	11	1
11 ÷ 2	5	1
5 ÷ 2	2	1
2 ÷ 2	1	0
1 ÷ 2	0	1

Reading remainders upward gives 10111. The calculator performs this conversion in either direction and shows both forms together so a mistyped digit is obvious before the arithmetic step.

Add 10101010 and 11001100

Adding 10101010 and 11001100 is the worked fixture for column addition with carries. In decimal the operands are 170 and 204, and the sum is 374, which is 101110110 in binary. Older outline notes that listed 110001110 were wrong; the arithmetic below is the correct result.

1 1 1 1 1 0 0 0     carries
            1 0 1 0 1 0 1 0   170
          + 1 1 0 0 1 1 0 0   204
          -----------------
          1 0 1 1 1 0 1 1 0   374

Column by column from the right: 0+0=0, 1+0=1, 0+1=1, 1+1=0 carry 1, 0+0+carry=1, 1+0=1, 0+1=1, 1+1=0 carry 1, and the final carry writes a ninth bit. The nine-bit result 101110110 matches 256 + 0 + 64 + 32 + 16 + 0 + 4 + 2 + 0 = 374. The Binary Calculator shows this carry row for every addition so the hand check lines up with the output.

Subtract binary numbers with borrowing

Binary subtraction borrows when a column needs to take 1 from a 0. Borrowing from the next higher bit turns the current 0 into 2 (binary 10), and the lender loses 1. If that lender is also 0, the borrow propagates until it finds a 1.

Example: 1000 minus 0001.

1 0 0 0
- 0 0 0 1
---------
  0 1 1 1

The rightmost column borrows across three zeros. After the chain settles, each borrowed column becomes 1, and the leftmost bit that lent becomes 0, leaving 0111 (decimal 7). When a bit width is set and the result would go negative, the calculator can show the two's complement wrap instead of an unbounded negative magnitude. Unbounded mode keeps the signed integer exact without wrapping.

Apply bitwise operations

Bitwise operators act on each bit independently rather than on the string as one integer. AND returns 1 only where both inputs are 1. OR returns 1 where either input is 1. XOR returns 1 where bits differ. NOT flips every bit in the selected width. Shifts move bits and fill zeros, or the sign bit for arithmetic right shift.

A	B	AND	OR	XOR
0	0	0	0	0
0	1	0	1	1
1	0	0	1	1
1	1	1	1	0

A bit mask clears or keeps selected fields. value AND mask zeros every bit where the mask is 0. value OR flag sets bits. value XOR toggle flips selected bits without disturbing the rest. These patterns appear in permission flags, status registers, and the network portion of an IPv4 address when a subnet mask is applied.

Represent negative numbers in two's complement

Two's complement is the standard way fixed-width binary stores negative integers. For an n-bit register, negate a value by inverting every bit and adding one. The high bit is the sign bit: 0 for non-negative, 1 for negative. The representable range for n bits is −2ⁿ⁻¹ through 2ⁿ⁻¹ − 1.

In 8 bits, +5 is 00000101. Invert to 11111010, add one to get 11111011, which is −5. Adding 00000101 and 11111011 yields 00000000 with an overflow carry out of the register, which is how negation checks out. Without a width, there is no fixed sign bit and two's complement is undefined; the calculator therefore requires a width (8, 16, 32 or 64) before showing complement forms.

Overflow happens when the true mathematical result does not fit the chosen width. The Binary Calculator flags wrap so a silently truncated answer is not mistaken for an exact one.

Read the binary place value table

Place values double at every step left of the binary point. Memorising the first eight is enough for most byte-level work: 1, 2, 4, 8, 16, 32, 64, 128. Four bits make a nibble; eight bits make a byte. Sixteen bits make a word on many architectures; 32 and 64 are the common register sizes today.

Bit index	Power	Value
0	2⁰	1
1	2¹	2
2	2²	4
3	2³	8
4	2⁴	16
5	2⁵	32
6	2⁶	64
7	2⁷	128

A full byte of ones, 11111111, is 255. The high bit alone, 10000000, is 128. Reading a value as the sum of its set place values is faster than converting digit by digit once the table is familiar, and the calculator's expansion view matches that mental check.

Use binary in practice

Binary shows up wherever hardware or protocols expose bitfields. Subnet masks are 32-bit patterns of leading ones. Unix file modes pack read, write and execute bits into nine permission bits. Colour channels are often eight-bit values. CPU flags and device registers pack boolean state into single bits so a mask can test or clear them without touching neighbours.

Memory addresses and machine instructions are binary underneath every hex dump. When debugging, converting a suspicious flag word to binary and lining it up against the datasheet is usually faster than guessing from the decimal form. The calculator keeps the binary and decimal views linked so that round trip stays honest.

Frequently asked questions

Summary

The Binary Calculator performs base-2 arithmetic, converts to and from decimal through powers of two, and applies bitwise AND, OR, XOR, NOT and shifts with an optional register width. Adding 10101010 and 11001100 yields 101110110 (170 + 204 = 374), with carries shown column by column.

Two's complement negation and bitwise NOT require a bit width; unbounded mode keeps results mathematically exact. Place values, nibbles and bytes are listed so binary strings used in masks, permissions and flags can be read without guessing.