Binary Addition: A Simple Step-by-Step Guide

Binary addition is the arithmetic that runs every digital device, from a £2 calculator to a server room full of GPUs. Before you touch a worked example, you need the four rules that make the whole system work. In decimal, you have ten digits; in binary, you have two, and the carry behaviour is the only real twist. The first three rules are straightforward: 0 plus 0 gives 0, 0 plus 1 gives 1, and 1 plus 0 gives 1. The fourth rule is where beginners trip: 1 plus 1 gives 0 in the current column and carries 1 to the next column, because the result 2 is written as the two-bit pattern 10.

The rule you must memorise before starting any addition is the carry rule for three ones. When a column has 1 plus 1 plus an incoming carry of 1, the sum is 3, which in binary is 11. So the column writes 1 and carries 1. That single rule, 1+1+1 gives 1 carry 1, is the difference between a correct answer and a result that is off by a power of two. Practice it until it is automatic, because every multi-bit addition with a carry will hit it eventually.

The binary addition rules are the same for every column, no matter how large the numbers get. Write the two binary numbers one above the other, aligning them at the rightmost bit, the least significant bit. If one number is shorter, pad it with leading zeros on the left so both have the same length; this prevents misalignment and is the most common avoidable error. Start at the rightmost column and work left, exactly as you would in decimal addition.

For each column, add the two bits and any carry that came from the column to the right. The carry from the previous step is not optional; forgetting to include it changes the result by 2 to the power of that column's position. After you finish the leftmost column, you may have a final carry that creates one extra bit on the left of the result. That is not a mistake; it is the natural outcome when the sum exceeds the largest value the original bit-width could hold. Write it down and move on.

Binary addition with carry is best learned as a fixed procedure, not as intuition. Begin by writing the two numbers, padded to the same length. Draw a line underneath, leaving room for a carry row above the top number if you need it. Start at the rightmost column. Apply the four rules: 0+0=0, 0+1=1, 1+0=1, and 1+1=0 with a carry of 1. Write the sum bit directly below the line, and write the carry bit above the next column to the left.

Move one column left. Now add the two original bits plus the carry you just wrote. If the sum is 0 or 1, write it and carry 0. If the sum is 2 or 3, write the low bit (0 or 1) and carry 1. Repeat this for every column, working left. When you reach the final column, write any extra carry as the leftmost bit of the result. That is the whole procedure; there is nothing else to it.

Adding binary numbers examples are where the rules become second nature. Take 1010 (which is 10 in decimal) and add 0110 (which is 6). Start at the rightmost column: 0 plus 0 gives 0, no carry. Next column: 1 plus 1 gives 0, carry 1. Third column from the right: 0 plus 1 plus the carry 1 gives 0, carry 1. Leftmost column: 1 plus 0 plus carry 1 gives 0, carry 1. Write the final carry as the new leftmost bit. The result is 10000. Check it: 10 plus 6 equals 16. The arithmetic works.

Now try 1101 (13) plus 1011 (11). Rightmost column: 1 plus 1 gives 0, carry 1. Second column: 0 plus 1 plus carry 1 gives 0, carry 1. Third column: 1 plus 0 plus carry 1 gives 0, carry 1. Leftmost column: 1 plus 1 plus carry 1 gives 1, carry 1. Write the final carry. The result is 11000. Check: 13 plus 11 equals 24. In both cases, the decimal conversion confirms the binary addition. Always verify at least one example by hand in decimal until the process feels boring, because boredom is the signal that you have internalised it.

Adding more than two binary numbers follows the same rules but requires a small adjustment. When you have three or four numbers, you cannot just add a carry from one column to the next; you may have multiple carries. The practical method is to add the numbers two at a time, or to add all the bits in a single column and count how many ones are present. For example, adding 101, 011, and 110 gives a rightmost column with 1 plus 1 plus 0, which is 2, so write 0 and carry 1. The next column has 0 plus 1 plus 1 plus the carry 1, totalling 3, so write 1 and carry 1.

The rule for three or more ones in one column is simple: count the ones. A sum of 4 writes 0 and carries 2, which means a carry into the next column plus another into the column after that. A sum of 5 writes 1 and carries 2, and so on. Do not try to do it in your head; write every carry explicitly.

Column Sum	Written Bit	Carry to Next Column
0 + 0	0	0
0 + 1	1	0
1 + 0	1	0
1 + 1	0	1
1 + 1 + 1 (with carry)	1	1

The most frequent error in binary addition is dropping a carry, especially the final one. If you add 111 (7) and 001 (1), the result should be 1000 (8), but a careless adder writes 000 and forgets the leading 1. Always write the final carry as the leftmost bit, even if it feels odd. Another common mistake is misaligning numbers of different lengths; pad the shorter one with zeros first. A third error is treating 1 plus 1 as 2 written as a single digit, but binary has no digit 2, so you must write 0 and carry 1.

To catch these mistakes, convert the operands and the result to decimal after every calculation. If the decimal check fails, redo the addition column by column, writing each carry above the next column. Do not erase your work; cross out the old carry and write the new one, because seeing the correction helps you spot the pattern. If you are adding numbers with more than 8 bits, break the work into 4-bit chunks and add each chunk separately, carrying into the next chunk, which reduces the chance of a slip.

Work these five problems on paper before looking at the answers. First: add 1010 and 0101. Second: add 1111 and 0001. Third: add 1100 and 0011. Fourth: add 10101 and 01111. Fifth: add 1001, 0110, and 0011. For each, align the numbers, add from the right, write every carry, and then convert both the operands and the result to decimal to confirm. The answers are: 1111 (15), 10000 (16), 1111 (15), 100100 (36), and 10010 (18).

If you got any of these wrong, go back to the column where the error occurred. Redo the problem with a fresh sheet, writing the carry row explicitly. If you got all five correct, you are ready for binary subtraction, which builds directly on these rules, and for two's complement, which is the standard way computers represent negative numbers and makes subtraction a form of addition.

The single most practical action to take is to set a timer for ten minutes and solve ten random binary addition problems, checking each one in decimal.

Do not use a calculator until after you have written your answer; the point is to build the manual habit, not to verify the machine.

When you are confident, move to binary subtraction, which uses the same carry concept but with borrows, and then to two's complement, which turns subtraction into addition. If you make a mistake, do not just fix it; redo the entire column from the right to find where the carry went wrong, because that is where the learning lives.