Binary addition carries when a column reaches two. 1011 + 1101 = 11000, which is 11 + 13 = 24. There are only four single-digit sums to know, and one of them carries — which is fewer facts than the decimal addition table has rows.
Four sums to learn
Binary addition is easier than decimal, not harder. There are four single-digit sums in total.
0 + 0 = 0. 0 + 1 = 1. 1 + 0 = 1. 1 + 1 = 0 carry 1.
That last one is the only interesting case, and it is the same idea as 5 + 5 = 0 carry 1 in decimal: the column has reached its base, so it resets and passes one along.
Compare that with the decimal addition table, which has a hundred entries. Binary needs four. The cost is that numbers get long — but a machine does not mind length, and it very much minds having to store a hundred facts in silicon.
The tool above shows the carry row, because seeing which columns carried is the entire content of the method.
How hardware subtracts
A processor does not subtract. It adds.
To compute a − b it forms the two’s complement of b — flip every bit and add one — and then adds that. The result is correct, and no subtraction circuit was involved.
That is why two’s complement is the representation everything uses. The alternative, sign-and-magnitude, needs a separate subtractor, a comparator to decide which operand is larger, and it has two representations of zero.
One adder and one inverter do both jobs. On a chip where every gate costs area and power, halving the arithmetic hardware is a very large saving, and it has been the standard design since the 1960s.
Shift and add
Binary multiplication has no times table, because multiplying by a single bit is either copying or nothing.
Each 1 in the multiplier contributes the multiplicand shifted left by that bit’s position. Each 0 contributes nothing. Add the contributions and you are done.
So 101 × 11 is 101 shifted zero places plus 101 shifted one place: 101 + 1010 = 1111. Five times three is fifteen.
It is why multiplying by a power of two is a single shift, and why compilers turn “× 8” into “shift left 3” without being asked. Division by a power of two is the same in reverse.
Real hardware does not do it one bit at a time — a Booth or Wallace-tree multiplier processes several bits per step — but the shift-and-add picture is what those are optimising.
Octal and hex
Hexadecimal is not a different system. It is binary, written four bits at a time.
Sixteen is 2⁴, so every hex digit is exactly four binary digits, with no arithmetic needed to convert — just grouping. FF is 1111 1111, and reading that off is a lookup rather than a calculation.
Octal does the same with three bits, being 2³. It was common when machines had word sizes divisible by three; hex won because bytes are eight bits and eight divides by four.
This is why memory addresses, colour codes and byte values are written in hex. 32 binary digits are unreadable; eight hex digits are not, and the mapping between them is mechanical.
The arithmetic is identical in every base — carry when a column reaches the base. This page handles all three the same way for exactly that reason.
Where it gets used
Learning computing. Binary arithmetic is the first thing a computer architecture course covers, because everything above it is built on this.
Embedded work. Register values, bit fields and hardware protocols are all specified in binary or hex, and arithmetic on them has to be done in that form.
Networking. Subnet masks and address ranges are binary operations, and CIDR notation is a count of leading one bits.
Debugging. Reading a hex dump, checking a checksum by hand, or working out what a corrupted value used to be.
Sources and methodology
Positional arithmetic in base two is standard; these are the references.
Method. Everything runs on arbitrary-precision integers, so a number far beyond what a register holds is handled exactly rather than being pushed through a double. The addition path reconstructs the carry row column by column rather than deriving it from the answer, so the working shown is the working done. The suite re-derives two thousand generated operations in base ten and requires the binary result to agree. That engine is verified on every change against 90 hand-written assertions, including that binary arithmetic matches decimal arithmetic across two thousand generated cases in all four operations. The count and the per-case breakdown are published on the formula verification page.
Read the guide
Subtraction is really addition of a two’s complement — the Two’s Complement Calculator shows that representation directly.