Multiplying binary numbers follows the same long multiplication process you learned in school, but it’s simpler because you only work with two digits: 0 and 1. That means each partial product is either a copy of the top number or a row of zeros. Once you know the four single-digit results and how to add partial products, you can multiply any two binary numbers by hand.
The Four Rules of Binary Multiplication
Binary multiplication has just four possible outcomes for any single pair of bits:
- 0 × 0 = 0
- 0 × 1 = 0
- 1 × 0 = 0
- 1 × 1 = 1
These are identical to regular multiplication rules. The key difference from decimal is that there’s no result larger than 1 for any single-digit product, so you never carry during the multiplication step itself. Carries only show up later, when you add the partial products together.
Step-by-Step Long Multiplication
Let’s multiply 101 (which is 5 in decimal) by 110 (which is 6). The process works exactly like decimal long multiplication: multiply the top number by each digit of the bottom number, shift each row one position to the left, then add everything up.
Step 1: Multiply by the rightmost digit of the bottom number. The rightmost digit of 110 is 0. Multiply every digit of 101 by 0, and you get 000.
Step 2: Multiply by the next digit. The second digit (the “twos place”) of 110 is 1. Multiply 101 by 1, giving 101. Because you’re in the twos place, shift this row one position to the left by placing a 0 at the right end: 1010.
Step 3: Multiply by the next digit. The third digit (the “fours place”) of 110 is also 1. Multiply 101 by 1 again, giving 101. Since you’re in the fours place, shift two positions left by adding two zeros at the right end: 10100.
Step 4: Add all partial products.
101
× 110
-----
000 (101 × 0)
1010 (101 × 1, shifted left once)
10100 (101 × 1, shifted left twice)
-----
11110
The result is 11110, which equals 30 in decimal. And 5 × 6 = 30, so it checks out.
How Binary Addition Works During Multiplication
Adding the partial products is where most mistakes happen. Binary addition has three rules to remember: 0 + 0 = 0, 0 + 1 = 1, and 1 + 1 = 10. That last one is the tricky part. In binary, 1 + 1 equals 2, but 2 is written as “10” in binary, so you write down 0 and carry 1 to the next column.
When three 1s land in the same column (which happens when you’re summing multiple partial products), the result is 3. In binary, 3 is written as “11,” so you write 1 and carry 1. If a column has a carry plus two 1s, that’s also 3, same deal. When you’re adding three or more rows of partial products, work from right to left and track your carries carefully, just like you would in decimal.
A Shortcut That Speeds Things Up
Notice something about binary long multiplication: when the bottom digit is 0, the entire partial product row is zeros. When the bottom digit is 1, the partial product is just a copy of the top number, shifted left. This means you can skip all the zero rows entirely and only write down the shifted copies for each 1 in the multiplier. For a number like 10001, that’s only two rows to add instead of five.
Multiplying Binary Fractions
Binary fractions work just like decimal fractions during multiplication. You ignore the binary point (the equivalent of a decimal point), multiply the numbers as whole numbers, then count up the total fractional digits from both numbers and place the point that many positions from the right.
For example, if you multiply two 4-bit numbers that each have 3 fractional digits (a format sometimes called Q3), the product has 6 fractional digits in an 8-bit result. That leaves 2 bits to the left of the binary point. The rule is simple: if the first number has M fractional bits and the second has N fractional bits, place the binary point M + N positions from the right of your final answer.
Handling Negative Numbers
Most computers represent negative numbers using a format called two’s complement, where the leftmost bit indicates the sign. Multiplying signed binary numbers requires extra care. The standard approach is called sign extension: you pad each number out to the full width of the expected product before multiplying. A 4-bit number multiplied by a 4-bit number can produce up to an 8-bit result, so both operands need to be extended to 8 bits by repeating their sign bit (0 for positive, 1 for negative).
A practical tip when working by hand: if one number is negative, convert it to positive, multiply normally, then negate the result back to two’s complement. If both numbers are negative, you can multiply their positive equivalents and keep the result positive.
Overflow: When the Result Doesn’t Fit
Multiplying two numbers always produces a result that can be much larger than either input. Specifically, the product of two N-bit numbers can require up to 2N bits. Two 3-bit numbers can need up to 6 bits for the result. Two 8-bit numbers might need 16 bits.
Overflow happens when the product exceeds the available space. A quick way to estimate whether overflow will occur is to find the position of the highest 1 in each number and add those positions together. If the sum exceeds your result’s bit width, the multiplication will overflow. In programming, you can detect this before multiplying by checking whether either operand exceeds the maximum value divided by the other operand.
How Computers Multiply in Hardware
Inside a processor, binary multiplication is built from two basic components: AND gates and adders. Each AND gate takes one bit from each number and produces a single partial product bit. For a 2-bit multiplier, that’s 4 AND gates generating 4 partial products. For a 4-bit multiplier, it’s 16 AND gates arranged in a grid.
Once the partial products are generated, half adders and full adders sum them column by column, propagating carries from right to left. This is called an array multiplier, and it mirrors exactly what you do by hand. The main bottleneck is carry propagation: each column has to wait for the carry from the column to its right.
Faster designs, called Wallace tree multipliers, group partial products into sets of three and compress them using full adders in a tree structure rather than a flat array. This reduces the number of addition stages and speeds up the calculation significantly, which is why modern processors can multiply large numbers in just a few clock cycles.