About

Two's complement is the standard encoding for signed integers in virtually every modern CPU architecture. A single misinterpreted sign bit propagates through arithmetic pipelines and corrupts downstream results - buffer overflows, incorrect sensor readings, and financial miscalculations all trace back to this error class. This tool converts between decimal integers and their two's complement binary representation across 4, 8, 16, 32, and 64-bit widths. It validates that your value falls within the representable range [−2ⁿ⁻¹, 2ⁿ⁻¹ − 1] and generates a step-by-step breakdown of the conversion process.

The converter handles both directions: decimal to two's complement and two's complement back to decimal. It assumes standard binary positional notation with the most significant bit (MSB) serving as the sign bit. Limitation: this tool operates on fixed-width integers only. Floating-point representations (IEEE 754) require a different encoding scheme not covered here. Pro Tip: when debugging embedded firmware, always verify your compiler's assumed word width matches your target - a 16-bit int on an AVR is not the same as a 32-bit int on ARM Cortex.

Formulas

Two's complement encoding for an n-bit signed integer maps a decimal value d to a binary string B of exactly n bits. The representable range is constrained to:

−2^{n − 1} ≤ d ≤ 2^{n − 1} − 1

For non-negative values (d ≥ 0), the binary representation is the standard positional expansion zero-padded to n bits:

B = pad(d₂, n)

For negative values (d < 0), the encoding applies three steps:

B_abs = pad(|d|₂, n)

B_inv = ¬B_abs (invert every bit)

B = B_inv + 1 (binary addition with carry)

The reverse conversion (binary to decimal) inspects the MSB (bit n − 1):

{

d = B₁₀ if MSB = 0d = −(¬B + 1)₁₀ if MSB = 1

The weighted sum formula expresses the decimal value directly from bit positions:

d = −b_n−1 ⋅ 2ⁿ⁻¹ + n−2∑i=0 b_i ⋅ 2ⁱ

Where b_i is the bit at position i (0 or 1), n is the total bit width, and b_n−1 is the sign bit carrying negative weight.

Reference Data

Bit Width	Min Value	Max Value	Unsigned Max	Total Values	Common Use
4-bit	−8	7	15	16	Nibble, BCD digits
8-bit	−128	127	255	256	int8_t, Java byte
16-bit	−32,768	32,767	65,535	65,536	int16_t, short
32-bit	−2,147,483,648	2,147,483,647	4,294,967,295	4,294,967,296	int32_t, C int
64-bit	−9,223,372,036,854,775,808	9,223,372,036,854,775,807	18,446,744,073,709,551,615	18,446,744,073,709,551,616	int64_t, long long
Common Two's Complement Values (8-bit)
Decimal	Binary		Hex	Notes
0	0000 0000		0x00	Zero
1	0000 0001		0x01	Smallest positive
127	0111 1111		0x7F	Largest positive (8-bit)
−1	1111 1111		0xFF	All bits set
−2	1111 1110		0xFE
−128	1000 0000		0x80	Most negative (8-bit)
42	0010 1010		0x2A	ASCII asterisk
−42	1101 0110		0xD6
100	0110 0100		0x64
−100	1001 1100		0x9C

Frequently Asked Questions

A sign-magnitude scheme requires the ALU to check the sign bit before every addition and handle +0 / −0 as separate cases. Two's complement eliminates this: the same adder circuit handles both signed and unsigned addition identically. The MSB carries a weight of −2^(n−1), so overflow detection reduces to comparing carry-in and carry-out of the MSB - a single XOR gate. This is why every mainstream architecture since the IBM System/360 (1964) adopted it.

The tool rejects the input and displays the valid range. For example, an 8-bit signed integer represents −128 to 127. Entering 200 in 8-bit mode is invalid because 200 requires 8 data bits but the sign bit is already consumed. You would need at least 16-bit width. In real hardware, exceeding the range causes integer overflow - the value wraps around silently in C/C++ (undefined behavior for signed types) or throws an exception in languages like Rust or Ada.

No. This is a key advantage over sign-magnitude and ones' complement, which both have distinct +0 and −0 representations. In two's complement, zero is uniquely represented as all bits cleared (e.g., 0000 0000 in 8-bit). Inverting and adding 1 produces a carry that overflows back to 0000 0000. This means the negative range has one extra value: 8-bit covers −128 to +127, not −127 to +127.

Yes. The converter uses BigInt internally for all arithmetic operations. Standard JavaScript Number type loses precision beyond 2^53 − 1 (about 9 × 10^15), but BigInt supports arbitrary-precision integers. A 64-bit signed range of −9,223,372,036,854,775,808 to 9,223,372,036,854,775,807 is handled exactly.

Bitwise NOT (~) in most languages flips every bit of the stored value. For a two's complement integer, ~x equals −x − 1. This follows directly from the identity: x + ~x = −1 (all bits set = −1 in two's complement). Therefore, to negate a value, you compute ~x + 1. The converter's step-by-step display shows this invert-then-add-one process explicitly.

Yes. Sign extension replicates the MSB into the new higher bits. For example, −5 in 4-bit is 1011. Extending to 8-bit copies the sign bit: 1111 1011, which still equals −5. The converter automatically applies this if you switch to a wider bit width. Truncating (narrowing) is lossy and may change the value - the tool warns if the value doesn't fit the target width.