Binary Converter

Convert a decimal number to binary and a binary number back to decimal.

Supports 4–64-bit signed representations with two's complement for negative values.

Updated August 11, 2026

CreatorFrank Zhao

Loading calculator…

Introduction / overview

Binary Converter translates a decimal integer into its fixed-width binary pattern and back again. You pick the representation — 4, 8, 12, 16, 32, or 64 bits, or a custom size — and the tool produces the exact bit pattern, including the part people usually stumble on: how negative numbers are stored.

The two directions are separate converters that share the bit-width setting. Type a decimal in “Decimal to binary” and read the padded pattern below it; type a binary string in “Binary to decimal” and read its decimal value below that.

It is the tool to reach for when you need to know exactly how a value such as $-87$ fits into eight bits — whether you are studying number systems, checking a bit pattern in a microcontroller register, decoding a value from a file format, or working out octets for IP addresses. Because every conversion is exact, the pattern you see is the pattern a real $n$ -bit register would hold.

How to use / quick start

Choose the bit width

Pick a preset such as 8-bit or 16-bit from Binary number representation. For a size that is not listed, choose Other and type the number of bits (anywhere from 2 to 70).

Convert decimal to binary

In Decimal to binary, type a whole decimal number. The result below shows the pattern padded to the full width, with the caption telling you the representation (for example, “Number in 8-bit representation.”).

Convert binary to decimal

In Binary to decimal, type a string of 0s and 1s — leading zeros are optional. Positive values give a single Decimal result. When the leftmost bit is 1 the value is negative, so the calculator shows both the 1’s complement and 2’s complement readings of that same pattern.

Example 1 — convert 3 to 8-bit binary

Type $3$ in the Decimal field. The calculator expands it by place value, then pads the two-bit result out to the full width:

3_{10}

=

1\cdot 2^1 + 1\cdot 2^0

=

11_2

\ \to\

0000\ 0011

So the Binary result reads 0000 0011, and the caption confirms it is an 8-bit representation.

Example 2 — a negative value, −87 in 8 bits

Type $-87$ in the Decimal field. Because the value is negative, the tool encodes it with two’s complement: take the pattern for $87$ , flip every bit, then add 1.

87_{10} = 0101\ 0111_2

\ \xrightarrow{\text{flip}}\

1010\ 1000

\ \xrightarrow{+1}\

1010\ 1001

The Binary result shows 1010 1001. As an unsigned number that pattern equals $169$ ; as a signed two’s-complement value it equals $169 - 256 = -87$ .

Calculation method

Every bit in the pattern carries a power of two. For $n$ bits, the leftmost bit is position $n-1$ and the rightmost is position 0:

B = \sum_{i=0}^{n-1} b_i \cdot 2^i

Decimal to binary (two’s complement)

B = N

\ \text{for } N \ge 0

\qquad\qquad

B = N + 2^n

\ \text{for } N < 0

Binary to decimal (two’s complement)

N = B

\ \text{for } B < 2^{n-1}

\qquad\qquad

N = B - 2^n

\ \text{for } B \ge 2^{n-1}

1’s complement reading of a pattern with a leading 1

N = B - \left(2^n - 1\right)

\ \text{for } B \ge 2^{n-1}

Variables

$N$ — the decimal value you enter or read
$B$ — the unsigned value of the $n$ -bit pattern
$n$ — the number of bits (2 to 70)
$b_i$ — the bit at position $i$ (0 or 1)

Where the limits come from

With $n$ bits you can represent exactly $2^n$ patterns. A signed $n$ -bit integer therefore runs from $-2^{n-1}$ up to $2^{n-1}-1$ . A decimal outside that range triggers the “not in the workable range” error, and a binary string whose value reaches $2^n$ needs more than $n$ bits and is reported as too long.

Signed binary and complements

Binary has no minus sign, so negative numbers have to be encoded. The leftmost bit is used as a sign indicator: 0 means “not negative”, and 1 means the pattern should be read as a negative value under a signed scheme. That is why the same pattern can mean two different things depending on how you read it — $1111\ 1111$ is $255$ as an unsigned byte, but $-1$ in two’s complement.

One’s complement — flip every bit

Take the positive pattern and change each 0 to 1 and each 1 to 0. Its quirk is that zero appears twice: $0000\ 0000$ is $+0$ and $1111\ 1111$ is $-0$ . That is exactly why the 1’s complement row for $1111\ 1111$ reads 0.

Two’s complement — flip every bit, then add 1

This is the scheme almost all modern hardware uses. It has a single zero, and adding and subtracting share the same circuits. $1111\ 1111$ plus 1 rolls over to $0000\ 0000$ , so the pattern represents $-1$ .

Why $1111\ 1111$ shows 0 and −1

Read as an unsigned number, $1111\ 1111$ equals $255$ . The two signed rows subtract that pattern’s magnitude from the two different “full” values for 8 bits:

\text{1's: } 255 - (2^8 - 1)

=

255 - 255

=

0

\text{2's: } 255 - 2^8

=

255 - 256

=

-1

What fits in each representation

Representation	Minimum	Maximum
4-bit	-8	7
8-bit	-128	127
12-bit	-2,048	2,047
16-bit	-32,768	32,767
32-bit	-2,147,483,648	2,147,483,647
64-bit	-9,223,372,036,854,775,808	9,223,372,036,854,775,807

Binary is just one numeral system. If you need to move between octal, hexadecimal, base64, or any custom base from 2 to 64, the Integer Base Converter extends the same idea to every common base.

Frequently asked questions

Why does 1111 1111 (8-bit) show 0 for 1’s complement and −1 for 2’s complement?

Because the pattern equals $255$ as an unsigned number. One’s complement subtracts $255$ , giving $255 - 255 = 0$ (the “negative zero” this scheme has). Two’s complement subtracts $256$ , giving $255 - 256 = -1$ .

Do I have to type the leading zeros?

No. Type $1$ and the result pads it to the selected width — for 8-bit you get 0000 0001. The calculator only cares about the value, not how many digits you wrote.

Why do I get “not in the workable range” or “too long”?

“Not in the workable range” means the decimal value does not fit the signed range for the chosen width (for example, $200$ is too large for 8-bit signed, which tops out at $127$ ). “Too long” means the binary string has more digits than the selected width allows. In both cases, switch to a larger representation such as 16-bit.

Limitations

This calculator works with whole numbers only: the Decimal field accepts integers, and the Binary field accepts only the digits 0 and 1. The bit width is limited to 2–70 bits, and values must fit the signed range of the selected width — a decimal must fall within $-2^{n-1}$ to $2^{n-1}-1$ , and a binary string must need no more than $n$ digits. Conversions are exact, so results are never rounded, but they always include the leading zeros needed to fill the chosen width. For fractional numbers, other numeral systems such as octal or hexadecimal, or bases beyond 2, use a dedicated base converter instead.

Related Calculators

Scale Calculator

Calculate scale factors and convert scaled or real dimensions for length, area, and volume.

Try Now

Text to ASCII binary

Convert text to ASCII (8-bit) binary and convert ASCII binary back to text. Clean input automatically and copy results instantly.

Try Now

Text to Unicode

Convert text to Unicode decimal HTML entities (e.g., A) and convert them back to text. Runs locally in your browser with one-click copy.

Try Now

Integer Base Converter

Convert an integer between bases 2–64 (binary, octal, decimal, hexadecimal, base64, and custom). Runs locally in your browser.

Try Now

IPv4 address converter

Convert an IPv4 address into decimal, binary, hexadecimal, and IPv4-mapped IPv6 representations. Runs locally in your browser with one-click copy.

Try Now

Fraction to Percent Calculator

Convert fractions to percentages and vice versa instantly

Try Now