Add two binary numbers with step-by-step carry method. View results in binary, decimal, hexadecimal, and octal. Includes bit-by-bit breakdown table, overflow detection, and visual carry chain.
The **Binary Addition Calculator** performs binary (base-2) addition with full step-by-step visualization of the carry method, just as you would work it out on paper. Whether you are a computer science student learning digital logic, a programmer debugging bitwise operations, or an electronics engineer verifying adder circuits, this tool gives you instant, detailed results.
Binary addition follows simple rules: 0+0=0, 0+1=1, 1+0=1, and 1+1=10 (write 0, carry 1). When both bits and a carry-in are all 1, the result is 11 (write 1, carry 1). These four rules are the foundation of every digital adder circuit, from simple half-adders to complex ALU pipelines inside modern CPUs. Understanding them thoroughly is essential for courses in computer architecture, digital design, and low-level programming.
This calculator accepts two binary strings of any length and computes their sum. It displays the result in binary, decimal, hexadecimal, and octal formats simultaneously, so you can cross-check conversions instantly. A detailed bit-by-bit breakdown table shows the carry-in, the two input bits, the sum bit, and the carry-out for every column — mirroring the pencil-and-paper process exactly. A visual carry chain highlights how carries propagate across bit positions, helping you spot patterns and understand ripple-carry behavior. Overflow detection warns you when the result exceeds a chosen bit width (8, 16, or 32 bits), which is critical for embedded systems and fixed-width integer programming.
Load preset examples to explore classic cases — adding powers of two, maximum 8-bit values, cascading carries, and more. Choose signed or unsigned mode to see how two's complement affects the interpretation of your result.
This calculator is useful when you need to verify binary addition at the bit level instead of only converting everything to decimal. It accepts two binary strings, pads them to equal length, performs the addition column by column, and reports the binary result alongside decimal, hexadecimal, and octal conversions. It also exposes the carry chain, bit-by-bit breakdown, and overflow checks for fixed widths such as 8, 16, and 32 bits.
That combination makes it practical for digital logic students, programmers working with bit patterns, and anyone learning how ripple-carry addition works. The signed versus unsigned interpretation setting is especially important because the same bit pattern can represent very different values depending on whether you read it as a two's-complement integer or a plain unsigned number.
Binary addition rules: 0+0=0, 0+1=1, 1+0=1, 1+1=10 (carry 1). For each bit position i: sum_i = A_i ⊕ B_i ⊕ C_in; C_out = (A_i · B_i) + (C_in · (A_i ⊕ B_i)).
Result: For these inputs, the calculator returns the binary addition result plus supporting breakdown values shown in the output cards.
This example reflects the built-in binary addition workflow: enter values, apply options, and read both the main answer and supporting metrics.
The calculator does more than add two base-2 numbers and display the answer. It sanitizes the inputs to binary digits, pads both strings to the same width, then processes each column from right to left. For every position, it records the input bits, the carry-in, the resulting sum bit, and the carry-out. That information is then shown in the breakdown table, so you can inspect exactly where carries begin and how they propagate toward the most significant bit.
This is useful for learning the rules of binary arithmetic and for checking manual work from class or from circuit-design exercises. Problems like 1111 + 0001 are easy to misread without a clear carry trace, and the calculator makes that propagation visible column by column.
The same raw sum can have different implications depending on the selected bit width and interpretation mode. In unsigned mode, the calculator compares the decimal result against the maximum representable value for the chosen width and flags overflow when the sum no longer fits. In signed mode, it interprets the result using two's complement and separately checks for signed overflow by comparing the expected signed sum with the masked fixed-width result.
Those settings matter in programming and hardware contexts where 8-bit, 16-bit, or 32-bit behavior is part of the problem. The output cards and the carry visualization therefore do two jobs at once: they teach the arithmetic itself and help you reason about whether a binary result is valid, overflowing, or being reinterpreted under a signed representation.
Binary addition follows the same rules as decimal but with only two digits: 0+0=0, 0+1=1, 1+0=1, 1+1=10 (0 carry 1). For example, 1011 + 1101 = 11000.
A carry occurs when the sum of a column equals 2 or more. In binary, 1+1=10, so you write 0 and carry 1 to the next column, similar to carrying in decimal addition.
Binary addition is the foundation of computer arithmetic. CPUs use adder circuits to perform all calculations, and understanding binary addition helps explain how hardware computes.
A carry occurs when the sum of two binary digits equals or exceeds 2. Because binary uses only 0 and 1, a sum of 2 is represented as 0 in the current position with a carry of 1 to the next position.
Overflow occurs when the result exceeds the maximum value representable in the available bit width. For example, adding two 8-bit values that sum to more than 255 causes an overflow in unsigned arithmetic.
You process carries the same way as in decimal column addition, propagating each carry to the next higher bit position. Multiple carries can cascade across several bit positions in a single operation.