Number Base Converter

Multiply each digit by two raised to its position, counting from zero at the right, then add the results. For 1011 that is 1×8 + 0×4 + 1×2 + 1×1, which is 11. The doubling method is quicker for long values: start at the leftmost digit, then repeatedly double the running total and add the next digit. For 1011 that runs 1, then 2+0 = 2, then 4+1 = 5, then 10+1 = 11. The working panel on this page lays out the first method digit by digit, so you can check your own arithmetic against it.

Because base 16 needs sixteen distinct digits and the decimal system only supplies ten. A through F fill the gap, standing for ten through fifteen. The reason to want sixteen in the first place is that 16 is 2 to the fourth power, so exactly four binary digits map to one hex digit with no remainder and no carrying between them. A byte is therefore always two hex characters, which is why memory dumps, colour codes, and MAC addresses are all written that way. Octal has the same property with three bits per digit, and it lost to hex mainly because bytes are eight bits rather than nine.

Two's complement stores a negative number as the pattern that, added to its positive counterpart, wraps the register back to zero. In eight bits, negative one is 11111111, because 11111111 plus 00000001 overflows to 00000000. The reason to prefer it over a plain sign bit is that addition and subtraction then need no special cases: the same adder circuit handles both signs, and comparison still works. A sign-magnitude representation also produces two zeros, positive and negative, which every piece of code then has to remember to handle.

For the same reason a third is not exact in decimal. A fraction terminates in a given base only when the denominator's prime factors all divide that base. Ten factors into two and five, so tenths, fifths, and halves all terminate in decimal. Two has only itself, so a binary fraction terminates only when the denominator is a power of two. A tenth is not, so 0.1 becomes 0.000110011001100… repeating forever, and any fixed-width format has to cut it somewhere. That truncation is what makes 0.1 plus 0.2 come out as 0.30000000000000004 in most languages. Type 0.1 here with decimal as the source base and the binary row shows the repetition directly.

It is the largest base that fits in the digits 0 to 9 plus the twenty-six letters of the Latin alphabet, so it is the densest way of writing a number that is still case-insensitive and typeable. That makes it useful for short identifiers and URL slugs: a value that needs ten decimal digits fits in six base-36 characters. Base 32 is often preferred in practice because it drops the visually confusing characters and maps cleanly onto five bits, and base 62 goes further by making letter case significant, at the cost of identifiers that cannot be dictated over a phone.

Yes. Type a leading minus and every base shows the same sign, since a minus sign is a property of the value rather than of the notation. The register panel is where it gets interesting, because a fixed-width register has no sign character: it stores the two's complement pattern instead, so negative 42 in eight bits is 11010110, which read as unsigned is 214. Both readings are shown together, along with a note explaining which one your language will give you depending on whether the type is signed.

It wraps, and the page says so. Three hundred does not fit in eight bits, so the register holds 44, which is 300 minus 256. That is not an error in the converter, it is what the hardware does, and reproducing it is more useful than refusing to answer. The conversions above the register panel are unaffected: those are exact and unbounded, up to the 512-character input ceiling.

Yes, when the prefix matches the base you have selected. 0x1F in a box set to hexadecimal reads as 31; the same string with the base set to binary is a genuine mismatch, so the x is reported as an invalid digit rather than being quietly ignored. Output prefixes are a separate switch: turn them on when the value is going into source code, off when it is going into prose or a spreadsheet cell.

Because the digit count is a logarithm. Writing a number n in base b takes about log base b of n digits, so raising the base lowers the count, but only slowly: doubling the base saves you a single digit per binary digit's worth of growth. That is why 255 needs eight binary digits, three decimal digits, and two hex digits, and why the all-bases table on this page shrinks quickly from base 2 to base 10 and then barely changes from base 20 to base 36.

No. All the arithmetic runs in this tab in JavaScript's built-in BigInt, and there is no request involved in a conversion. Values pasted from a debugger, an internal id, or a private key fingerprint stay on your machine.