Simple binary addition: 10 + 1
Two bits, one carry. This is the smallest case where 1 + 1 appears.
- Ones column: 0 + 1 = 1, no carry.
- Twos column: 1 + 0 = 1.
Result: 11 (decimal 3).
Add two binary numbers accurately, see carry and overflow for your bit width, and check decimal equivalents instantly. Built for computer science coursework, digital electronics labs, programming practice, and mathematics review.
You can write a binary number with no more than 8 digits. You don't have to input leading zeros.
Result
Binary number 1 (decimal):
Binary number 2 (decimal):
Sum in decimal:
Binary sum for the selected bit width. Decimal values help you verify the result in base 10.
Enter two valid binary values to see the sum.
Carry out of the selected width. Full binary sum:
Using this calculator
Binary addition is base-2 arithmetic: you combine two binary numbers by adding each column of bits and propagating carries, exactly like column addition in decimal except digits are limited to 0 and 1.
Definition: the sum of two binary values is another binary value whose each bit is determined by the column rules below plus any incoming carry from the previous (less significant) column.
Meaning in practice: when a column totals 2 in decimal terms, you write 0 in that bit position and carry 1 to the next column. That carry-over rule is what makes multi-digit binary addition reliable.
The binary number system uses powers of two for place values (…8, 4, 2, 1). Base-2 arithmetic is the foundation for data representation, digital logic, and processor operations.
Registers, pointers, and machine instructions rely on fixed-width binary addition.
Adder circuits implement the same column and carry rules in hardware.
Bit masks, flags, and low-level math trace back to binary sums.
Number-system units use binary addition to teach structure and proof.
Every column uses only these four outcomes. Memorize the table first; carries handle every multi-digit problem.
Carry-over rules: a carry of 1 always moves to the next more significant column on the left. Never skip a column when a carry is pending.
When three inputs meet in one column (bit A, bit B, and incoming carry), add them as base-10 integers, write sum mod 2, and pass carry 1 if the total is 2 or 3.
Column method (right to left):
result_bit = (bit_a + bit_b + carry_in) mod 2
carry_out = floor((bit_a + bit_b + carry_in) / 2)
Multi-digit binary addition repeats the pair for each column.
Arithmetic logic view: sum = A XOR B XOR carry_in; carry_out = majority(A, B, carry_in).
The carry bit concept is what links columns together. Each stage outputs one sum bit and one carry bit to the next stage, which is how half adders and full adders are chained in digital systems.
Formula explanation in words: add the column, record the least significant bit of that total as the result, and send any remaining value leftward as carry.
Follow this step-by-step method every time. Accuracy comes from column discipline, not speed.
Line up bits by place value. Leading zeros may be omitted in writing but are implied when you pad to a fixed width.
Start at the least significant bit. Apply the four rules (0+0, 0+1, 1+0, 1+1) including any carry from the previous column.
Write each result bit under the column. If carry_out is 1, place it above the next column to the left before you add that column.
Convert to decimal or use the calculator above to confirm. Check overflow if you are working inside a register width.
Worked examples from simple single-column carries to multi-digit sums you might see in labs or homework.
Two bits, one carry. This is the smallest case where 1 + 1 appears.
Result: 11 (decimal 3).
Four-bit style alignment with carries in three columns.
Result: 11000 (decimal 24). A 4-bit register would show overflow.
Incrementing a four-bit counter value by one.
Result: 1000 (decimal 8).
Carry generation happens whenever a column sum reaches 2 or 3 (when an incoming carry is present). Carry propagation moves that 1 left until it is absorbed in a column with room.
Common mistakes include forgetting an incoming carry, misaligning columns after the first carry, and dropping the final carry-out when interpreting overflow.
1 + 1 and 1 + 1 + 1 are the usual triggers.
A chain of 1s can ripple carries across every column (example: 0111 + 0001).
A full adder implements sum and carry_out with XOR and AND/OR networks.
1111 + 0001 ------- 10000
The final carry-out is the fifth bit. In four bits the stored result is 0000 with overflow.
Both systems use column addition and carries. The difference is the base: binary columns only allow 0 and 1 before carry, while decimal columns allow 0 through 9.
Base-2 vs base-10: place values are powers of two instead of powers of ten. The procedure is parallel; only the digit alphabet and carry threshold change.
Practical applications: humans often think in decimal while machines store binary. Converting results helps you catch alignment errors quickly.
| Topic | Binary | Decimal |
|---|---|---|
| Digits per column | 0, 1 | 0 through 9 |
| Carry when column is full | sum reaches 2 | sum reaches 10 |
| Typical use | hardware, logic design | everyday arithmetic |
Result validation: convert each binary input and the sum to decimal and check whether input₁ + input₂ equals the sum in base 10. If they match, your bit alignment and carries are likely correct.
Accuracy checks matter in exams and labs where a single misaligned column flips the answer.
Educational use cases include grading homework, explaining place value to beginners, and cross-checking simulator output.
1011 is (8+2+1)=11 and 0101 is 5. Sum 16 matches binary 10000.
The tool at the top of this page is the fastest way to add binary numbers online. Enter binary number 1, enter binary number 2, and read the instant binary sum plus decimal equivalents.
Select 4, 8, 12, 16-bit, or a custom width to mirror how your assignment or hardware treats overflow.
Most errors are bookkeeping, not misunderstanding the four rules.
Hardware implements the same rules you use on paper. A half adder sums two bits without carry-in. A full adder adds two bits plus carry-in and produces sum plus carry-out.
Chaining full adders builds a ripple-carry adder for multi-bit words. That is the physical form of binary addition in processors and FPGA labs.
This page stays focused on adding numbers accurately first. Explore our blog for deeper articles on logic gates and arithmetic circuits when you are ready to connect math to schematics.
Two inputs, sum and carry outputs.
Three inputs (A, B, carry-in), two outputs.
Serial connection of full adders across bit positions.
It is adding two base-2 numbers column by column, writing each result bit, and carrying 1 whenever a column totals 2 (or more when a carry-in is included).
0+0=0, 0+1=1, 1+0=1, and 1+1=10 (zero with carry one). Every multi-digit problem uses only these outcomes plus carry propagation.
Align bits by place value, start at the rightmost column, apply the four rules with any incoming carry, move left, and verify by converting to decimal or using the calculator on this page.
No. Leading zeros are optional in inputs. The calculator pads internally to your selected bit width when showing fixed-width results.
A carry is a 1 passed to the next left column when the current column sum is 2 or 3. It is the same idea as carrying in decimal, but carries trigger more often because columns fill after 1.
The process is the same (columns and carries). Binary uses only digits 0 and 1, so carries happen whenever a column sum hits 2 instead of 10.
Convert both inputs and the result to decimal and confirm the sum matches base-10 addition. The calculator shows decimal values under the binary result for quick checks.
Overflow means the true sum needs more bits than your width allows. A carry-out remains after the most significant bit of the selected representation.
No. All arithmetic runs locally in your browser. Nothing is uploaded to a server.
Share this page