Number Base Converter

A base is a grouping rule, and where converters lose digits

Every place in a written number is worth the base times the place to its right. Decimal groups by ten, binary by two, octal by eight, hexadecimal by sixteen. The quantity never changes: 255, 0xFF, 0o377 and 0b1111_1111 are four spellings of one number, the way a distance is the same whether you write it in miles or kilometres. Hexadecimal earns its place in computing because sixteen is two to the fourth, so one hex digit is exactly four bits and the two notations line up with no arithmetic.

The reason to use a converter rather than a language built-in is precision. Most converters, and every JavaScript function that returns a plain number, hold the value in a double precision float, which is exact for integers only up to 9,007,199,254,740,991. Above that the low bits are rounded away and you get a result that ends in zeros which were never in your input. A 64-bit register value, a Snowflake ID or a device serial all sit past that line. This page parses and prints with BigInt, which has no fixed width, so a 64-bit mask survives the round trip digit for digit.

The other failure is silent reinterpretation. A spreadsheet reads a hex value that happens to be all digits as a decimal number and drops the leading zero; C and Java read a leading zero as octal, so 010 is eight. Nothing here guesses that way: the base comes from your prefix or your button, and it is stated in words above the results.

Which base the input is read as

One box takes the input, and four results come out at once, so the only decision is what the digits you typed already mean.

• A prefix wins. Type 0b, 0o, 0d or 0x in front and the base is settled, whichever button is selected.
• Auto, with no prefix: any of the letters a to f means hexadecimal, and everything else is read as decimal. It deliberately never guesses binary, because an unprefixed 1010 is far more often one thousand and ten than it is ten.
• Press a base to be explicit. That is the mode to use for binary and octal without prefixes, and for a hex value such as 4321 that would otherwise look decimal.
• One exception worth knowing: when you have chosen Hex, a leading 0b or 0d is read as hex digits rather than as a prefix, because both are valid hexadecimal numbers in their own right.
• Spaces and underscores are ignored anywhere, so 1101 1110 and 0xDEAD_BEEF both work. Commas are not: a comma is a decimal point in much of the world, and reading 1,5 as fifteen would be worse than rejecting it.
• A leading minus sign is kept and the results carry it. Anything else, including a decimal point, is reported with the character and its position rather than being quietly dropped.

How to convert a value and take it into code

1. Paste or type the number. The sample loaded on the page, 0xDEAD_BEEF, shows the prefix and the underscore separator at the same time.
2. Check the line under the buttons. It says which base was used and why, so a wrong reading shows up before you copy the answer anywhere.
3. If the reading is wrong, press the base you meant. The four results update as you type.
4. Read the four rows. The one matching your input is tagged, which is a quick check that you and the tool agree.
5. Tick the prefix box if the value is going into source code. The copies then come out as 0b1010, 0o777 and 0xFF rather than as bare digits.
6. Press Copy on the row you need. The copy is exactly what is on screen, with no separators and no trailing spaces to clean up.

How to read the bit view

Below the results the value is drawn as a register: bits grouped in fours, boxed one byte at a time, with the hex value of each byte underneath. The small number above each group is the index of its leftmost bit, and bit 0 is on the far right.

1. Pick the width your documentation uses: 8, 16, 32 or 64 bits. The width only changes the picture, never the four results above it.
2. To check a flag, find the index above the group, count left from the rightmost bit of that group, and read the digit. Bit 6 set in a status word means that flag is on; in code the same test is a bitwise AND against a mask with only bit 6 set.
3. Compare the per-byte hex against a memory dump. Because one hex digit is one group of four bits, a mismatch shows up as a single wrong nibble rather than as a wrong number.
4. If the value is too large for the width you picked, the tool says how many bits it needs and offers the smallest width that holds it, which is the question you are really asking before writing a value into a fixed field.

Negative values and two’s complement

Hardware has no minus sign, only bits, so a negative number is stored as a pattern that behaves like a negative number under addition. The scheme in use almost everywhere is two’s complement: write the positive value, flip every bit, add 1. In 8 bits, 5 is 00000101, so -5 is 11111011. The top bit ends up acting as a sign flag, and the same adder circuit handles both signs with no special case.

The tick box under the bit view switches between that and plain sign and magnitude, which is the way people write negatives on paper: a minus sign followed by the bits of the size. Leave two’s complement on when you are matching a debugger, a memory dump or a protocol field. Turn it off when you only want to see the magnitude in binary.

The signed ranges are not symmetric. Two’s complement has a single pattern for zero, which frees the one that would be minus zero for an extra negative value, so 8 bits reach -128 but stop at 127. Hence a classic overflow: negating the most negative value returns it unchanged, because its positive twin does not exist at that width.

Getting the result out of the page

• Into code: tick the prefix box first. A bare 1010 pasted into a source file is a thousand and ten in every mainstream language; 0b1010 is ten.
• Into a spreadsheet: format the cell as text before pasting a long hex or binary value. Otherwise a value made only of digits is read as a number and the leading zeros are lost.
• On a phone: Copy puts the value on the system clipboard, so a long press and Paste works in any app. Some in-app browsers block the clipboard; there, select the text by hand.
• Into a bug report: quote the decimal and the hex together. Decimal is what a log or an API returns, hex is what the register documentation is written in, and half of these conversations go wrong because only one was given.

The same conversion in other tools

• JavaScript: (255).toString(2) and parseInt("ff", 16) are fine for small values, and both lose precision past 2^53. Use BigInt("0xffffffffffffffff") and value.toString(16) for anything wider, which is what this page does.
• Python: int("ff", 16) parses, and bin(), oct() and hex() print with the prefix already attached. Python integers are arbitrary precision, and format(n, "032b") pads to a fixed width.
• C, Java, Rust and friends: the literals are the prefixes above, with the trap that a bare leading zero means octal in C and Java, so 010 is 8. Rust and Python 3 removed that spelling and require 0o.
• Spreadsheets: HEX2DEC, BIN2DEC, DEC2HEX and their siblings work only within narrow limits, historically ten hex digits or ten bits, and they treat the top bit as a sign. Wider values return an error rather than a wrong answer.
• Shell: printf "%x" 255 prints ff, and echo $((16#ff)) parses hex in bash without a prefix.
• Calculator apps: Windows Calculator in Programmer mode and the macOS Calculator in Programmer view both show all four bases with a bit grid, fixed width and usually no wider than 64 bits.

Limits worth knowing before you trust the output

• Whole numbers only. A decimal point is rejected, with the character and position named, rather than truncated. Fractions in binary are a different job and a different set of rounding traps.
• This is not a float inspector. The bits shown are the bits of an integer. The IEEE 754 layout that a language uses to store 3.14 in 64 bits, with a sign exponent and mantissa, is not what appears here.
• Byte order is not shown. The bit view prints the most significant bit first. How those bytes sit in memory or on the wire depends on the endianness of the machine or the protocol, and a little endian dump lists them the other way round.
• Width is a display choice. Changing 32-bit to 64-bit does not sign extend or truncate the value in the results above; it only redraws the picture. A value that does not fit is reported rather than wrapped.
• Check the base you were given. The commonest error in practice is not arithmetic, it is a value copied out of a document that never said which base it was in. Confirm that before you convert.