Binary converter: binary, decimal, hex and octal

A base (or radix) is how many different digits a number system uses. Decimal has ten (0-9), binary two (0 and 1), octal eight (0-7) and hexadecimal sixteen (0-9 and A-F). Each position is worth the base times the position to its right. In decimal the places are 1, 10, 100; in binary they are 1, 2, 4, 8; in hex 1, 16, 256.

So 1011 in binary is 1×8 + 0×4 + 1×2 + 1×1 = 11, and B in hex is also 11. The value is the same; only the way it is written changes. Programmers use hex because one hex digit is exactly four bits, so a byte is always two hex digits.

Any base to decimal: multiply each digit by its place value and add. 7DE in hex is 7×256 + 13×16 + 14 = 2014. The hex to decimal and binary to decimal pages walk through this for those bases.

Decimal to any base: divide by the base, keep the remainder, and repeat with the quotient until it is 0. The remainders read from the last to the first are the digits. See decimal to binary for the steps in detail.

Binary, octal and hex between each other: no arithmetic needed. Each hex digit is 4 bits and each octal digit is 3 bits, so you group the bits from the right and swap each group for its digit. 1011 0110 is B6 in hex; 10 110 110 is 266 in octal.

Written by hand, a negative binary number just gets a minus sign: -10 is -1010. Inside a computer, integers have a fixed width (8, 16, 32 or 64 bits) and negatives are stored in two’s complement: invert every bit of the positive value and add 1.

The top bit tells you the sign. The same 8 bits 11111111 are 255 to an unsigned byte and -1 to a signed one; the bits do not say which. The converter shows both readings, and you can click any bit in the grid to flip it.

JavaScript. toString(radix) and parseInt(string, radix) take any base from 2 to 36. Plain numbers lose precision above 2^53 - 1 (9,007,199,254,740,991), so use BigInt for anything larger.

(255).toString(2);          // '11111111'
(255).toString(16);         // 'ff'
parseInt('ff', 16);         // 255
parseInt('11111111', 2);    // 255
BigInt('0xFFFFFFFFFFFFFFFF').toString(10); // '18446744073709551615' (exact)
parseInt('FFFFFFFFFFFFFFFF', 16);          // 18446744073709552000 (rounded)

Python. int() takes a base from 2 to 36, or 0 to read the prefix. bin(), oct() and hex() go the other way, and integers never overflow.

int('ff', 16)        # 255
int('0b1010', 0)     # 10, base from the prefix
bin(10), hex(255)    # ('0b1010', '0xff')
format(10, '08b')    # '00001010'

Go

n, _ := strconv.ParseInt("ff", 16, 64)  // 255
strconv.FormatInt(255, 2)                // "11111111"
fmt.Sprintf("%08b %x %o", 10, 255, 8)    // "00001010 ff 10"

Bash

echo $((16#FF))            # 255
echo $((2#1010))           # 10
printf '%x\n' 255          # ff
echo "obase=2; 10" | bc    # 1010

Place values in binary are powers of two, and so are most limits you meet in code: 2^8 values in a byte, 2^31 - 1 as the largest signed 32-bit integer, 2^53 as the edge of exact integers in a JavaScript number.

For subnet masks, which are binary too, use the subnet calculator. To turn letters into bits, use text to binary. More command-line helpers are in the CLI tools on DevHunt.