Negative Binary to Decimal — Two's Complement Converter.
Convert negative binary numbers to decimal using Two's Complement. Free online signed binary to decimal calculator with step-by-step two's complement to decimal conversion, worked examples, and 8-bit range tables.
Try it: Signed Binary to Decimal Calculator
Popular Negative Binary to Decimal Reference Table
Below is an instant lookup table answering top search queries like 11111101 in decimal, negative binary to decimal, and signed binary calculator values. Click any row to load the exact conversion into the calculator above.
| 8-Bit Binary Query | Signed Decimal (Two's Comp) | Unsigned Value | Description / Meaning |
|---|---|---|---|
| 11111101 in decimal | -3 | 253 | Top GSC searched negative value |
| 11111111 in decimal | -1 | 255 | All bits set to 1 in signed binary |
| 10000000 in decimal | -128 | 128 | Minimum 8-bit negative integer |
| 11110000 in decimal | -16 | 240 | Common subnet / nibble mask value |
| 01111111 in decimal | +127 | 127 | Maximum 8-bit positive integer |
What is a signed binary number?
In standard (unsigned) binary, all numbers are positive: the 8-bit range is 0 to 255. But computers need to represent negative numbers too — for temperature readings, account balances, coordinates, and arithmetic results. Signed binary systems reserve the leftmost bit (the Most Significant Bit or MSB) as a sign indicator: 0 means positive, 1 means negative.
There are three main signed binary systems:
- Sign-Magnitude: The MSB is the sign, remaining bits are the absolute value. Simple but has two representations of zero (+0 and -0).
- One's Complement: Negative numbers are formed by inverting all bits. Also has the double-zero problem.
- Two's Complement: Negative numbers are formed by inverting all bits and adding 1. Has only one zero and is used by virtually all modern processors.
Two's Complement is the standard used in virtually every modern CPU. The rest of this guide focuses on this system. For unsigned binary conversion, see our binary to decimal converter.
Why do computers use Two's Complement?
Two's Complement is the dominant signed binary format because of three key advantages:
- Single zero: Unlike sign-magnitude and one's complement, Two's Complement has only one representation of zero (00000000). No wasted bit pattern.
- Simple arithmetic: The same addition and subtraction circuits work for both positive and negative numbers. The CPU doesn't need separate hardware for signed vs. unsigned math.
- Natural overflow: When results exceed the bit width, overflow is handled naturally by truncating extra bits, which simplifies circuit design.
These properties make processor design simpler and faster, which is why every major architecture (x86, ARM, RISC-V) uses Two's Complement for signed integer arithmetic.
How to convert negative binary to decimal (2's complement).
Follow these steps to convert any Two's Complement binary number to its signed decimal value:
- Check the MSB (leftmost bit). If it's
0, the number is positive — convert normally using standard binary-to-decimal. If it's1, the number is negative — continue to step 2. - Invert all bits. Flip every 0 to 1 and every 1 to 0. This gives the one's complement.
- Add 1 to the inverted result. This gives the absolute value in binary.
- Convert to decimal using standard positional notation.
- Prepend a negative sign. The final answer is the negative of the decimal value.
Step-by-step worked examples.
Example 1: Convert 11111101 to decimal (2's complement to decimal)
Example 2: Convert 11111111 to decimal
Example 3: Convert 10000001 to decimal
Example 4: Convert 01010101 to decimal (positive)
Example 5: Convert 10010110 to decimal
Signed binary conversion in programming.
Most programming languages handle Two's Complement natively for integer types. Here's how to explicitly convert signed binary strings. For more code snippets, visit our developer code snippets page.
# Convert 8-bit Two's Complement binary to signed decimal
def twos_comp_to_dec(binary_str, bits=8):
value = int(binary_str, 2)
if value >= (1 << (bits - 1)): # MSB is set
value -= (1 << bits)
return value
print(twos_comp_to_dec("11111101")) # Output: -3
print(twos_comp_to_dec("01010101")) # Output: 85
print(twos_comp_to_dec("10000000")) # Output: -128// Convert 8-bit Two's Complement binary string to signed decimal
function twosCompToDec(bin, bits = 8) {
let val = parseInt(bin, 2);
if (val >= (1 << (bits - 1))) val -= (1 << bits);
return val;
}
console.log(twosCompToDec("11111101")); // -3
console.log(twosCompToDec("01010101")); // 85// In C, signed integers use Two's Complement natively
#include <stdint.h>
int8_t val = 0xFD; // 11111101 in binary
printf("%d\n", val); // Output: -3
// The compiler handles Two's Complement automatically
// for int8_t, int16_t, int32_t, and int64_t types.Signed integer ranges: 8-bit, 16-bit, 32-bit, and 64-bit.
The range of a Two's Complement signed integer depends on the number of bits. For n bits, the range is -2n-1 to 2n-1 - 1. Here is a complete reference:
| Bit Width | C Type | Min Value | Max Value | Min Binary |
|---|---|---|---|---|
| 8-bit | int8_t | -128 | +127 | 1000 0000 |
| 16-bit | int16_t | -32,768 | +32,767 | 1000 0000 0000 0000 |
| 32-bit | int32_t | -2,147,483,648 | +2,147,483,647 | 1000...0 (32 bits) |
| 64-bit | int64_t | -9,223,372,036,854,775,808 | +9,223,372,036,854,775,807 | 1000...0 (64 bits) |
Note: In Java, byte is always signed 8-bit (-128 to 127). In C#, sbyte is the signed 8-bit type. Python integers have arbitrary precision and do not overflow.
One's Complement vs Two's Complement.
Before Two's Complement became universal, One's Complement was used in early computers. Here's a direct comparison with worked examples for the value -3:
| Property | One's Complement | Two's Complement |
|---|---|---|
| How to negate | Invert all bits | Invert all bits + add 1 |
| -3 in 8-bit | 1111 1100 | 1111 1101 |
| Zero representation | Two zeros: 00000000 and 11111111 | One zero: 00000000 only |
| 8-bit range | -127 to +127 | -128 to +127 |
| Used today? | Rare (some networking checksums) | Yes — all modern CPUs |
The double-zero problem in One's Complement made arithmetic trickier (you had to add an "end-around carry"). Two's Complement eliminated this entirely, which is why it won as the universal standard.
Sign extension: widening signed integers.
Sign extension is the process of increasing the bit width of a signed integer while preserving its value and sign. You do this by copying the MSB (sign bit) into all new higher-order bit positions.
Extending +5 from 8-bit to 16-bit
8-bit: 0000 0101 (MSB = 0, positive). 16-bit: copy MSB (0) into 8 new positions → 0000 0000 0000 0101. Value unchanged: +5.
Extending -3 from 8-bit to 16-bit
8-bit: 1111 1101 (MSB = 1, negative). 16-bit: copy MSB (1) into 8 new positions → 1111 1111 1111 1101. Value unchanged: -3. This is why negative numbers look like they're "full of ones" in wider types.
In C, sign extension happens automatically when you cast a smaller signed type to a larger one (e.g., int8_t → int32_t). Zero extension is used instead when casting unsigned types.
Frequently Asked Questions
How do you convert 2's complement to decimal? ▼
Check the MSB: if it's 0, the number is positive — convert normally. If the MSB is 1, the number is negative: invert all bits, add 1 to find the absolute value, convert to decimal, and prepend a minus sign. For example, 11111101 → invert → 00000010 → add 1 → 00000011 = 3 → answer is -3.
What is the signed decimal value of 11111111? ▼
In 8-bit Two's Complement, 11111111 = -1. Inverting gives 00000000, adding 1 gives 00000001 (value 1), so the result is -1. In Two's Complement, -1 is always represented by all bits set to 1 regardless of bit width.
What is the range of 8-bit signed binary? ▼
8-bit Two's Complement range: -128 (10000000) to +127 (01111111). That's 256 total values. For n-bit Two's Complement, the range is -2ⁿ⁻¹ to 2ⁿ⁻¹-1. So 16-bit is -32768 to +32767, and 32-bit is roughly -2.1 billion to +2.1 billion.
How do you convert negative decimal to binary? ▼
Convert the absolute value to binary and pad to the desired width (e.g. 8 bits). Then invert all bits and add 1. For example, -5: absolute value 5 = 00000101, invert = 11111010, add 1 = 11111011. This is the reverse of the Two's Complement to decimal conversion. See our decimal to binary converter for more.
Why do computers use Two's Complement? ▼
Two's Complement allows the CPU to use the same addition and subtraction hardware for both positive and negative numbers. It also has only one representation of zero (unlike one's complement which has +0 and -0), and arithmetic overflow is handled naturally by truncating extra bits. This simplifies processor design significantly.
What is the decimal value of signed binary 10000001? ▼
In 8-bit Two's Complement, 10000001 = -127. MSB is 1 (negative). Invert: 01111110. Add 1: 01111111 = 127. So the signed value is -127.
What is a signed binary number? ▼
A signed binary number can represent both positive and negative integers. The most common encoding is Two's Complement, where the leftmost bit (MSB) indicates the sign: 0 = positive, 1 = negative. Unsigned binary can only represent non-negative values (0 and up).
8-Bit Two's Complement
| Binary | Signed Dec |
|---|---|
| 01111111 | +127 (max) |
| 01000000 | +64 |
| 00000001 | +1 |
| 00000000 | 0 |
| 11111111 | -1 |
| 11111101 | -3 |
| 11111100 | -4 |
| 11000000 | -64 |
| 10000000 | -128 (min) |
Signed Ranges by Bit Width
| Bits | Min | Max |
|---|---|---|
| 8 | -128 | 127 |
| 16 | -32768 | 32767 |
| 32 | -2.1B | 2.1B |