Number Base Converter

Paste a long hexadecimal value into most free base converters and there's a decent chance the number that comes back is quietly wrong, and it'll look completely fine on the page. It usually ends in a tidy run of zeros where the real value should have messy digits, with nothing to warn you. A lot of these tools do their arithmetic the way a pocket calculator does, in floating point, and that kind of math starts silently dropping whole integers past about nine quadrillion. Run a 256-bit key or a big file offset through one and it hands back a rounded answer you have no reason to distrust.

This one refuses to round. It does exact whole-number math with no ceiling, so a four-bit f and a 256-bit crypto value convert with identical precision. Nothing rounds your number without telling you. And instead of the usual pick-a-from-base, pick-a-to-base, read-one-answer routine, it shows all four bases at once, binary, octal, decimal, and hex, updating live as you type. The card matching your input base gets a ring around it so you always know which column you started from. The whole thing runs in your browser and nothing you type is sent anywhere, so a private key or an internal offset stays on your machine instead of on some stranger's server.

Two caveats up front, because both trip people. It handles integers only, no decimal point. And it shows negatives as sign-and-magnitude, a plain minus out front, not two's complement, which matters if you're decoding a signed value out of a register, and there's a section on that further down.

1. Pick the input base from the dropdown: binary, octal, decimal, or hex. That tells the tool how to read your digits. It starts on decimal.
2. Type the number. The placeholder shows an example for whichever base you chose. Leave off the prefix, so in hex you type ff, not 0xff. Case doesn't matter, FF and ff read the same.
3. Read the four cards. As soon as the input is valid they fill with the binary, octal, decimal, and hex versions, each with its usual prefix (0b, 0o, 0x, nothing for decimal) so you can paste a result straight into code.
4. For a negative, put a minus in front (-255, or -ff in hex). Every card keeps the sign, and the digits after it get checked exactly like a positive number.
5. Switch bases whenever you want. The field clears on purpose when you do, so you don't drag a value from the old base into a new one where it means something else.

There's no submit button, so every keystroke redraws all four cards. Editing a hex string one character at a time and watching which bits flip over in the binary column is the quickest way I know to build a real feel for what a value is doing.

On small values almost anything works and none of this shows up. The gap only opens on large integers, and it opens wide. Take a long hex hash or a 64-bit address, convert it in some basic tool, then check the decimal against a second source. A lot of the time they won't agree, and the wrong one is the tool that rounded. The giveaway is a decimal ending in a clean string of zeros where a real number would be messy.

Because the math here is exact, that failure mode is gone. There's no largest number it handles, only how much you feel like typing. Hashes, fat bitmasks, page-table entries, arbitrary-length IDs, all exact.

The live all-columns view is the other half of the reason to reach for this one. You're not configuring one conversion and reading a single answer, you type once and see the value in every base at once, so checking a hex number against its binary bits takes no second lookup.

Negatives are the one spot where a careless converter will hand you a confident wrong answer. This tool shows a negative as sign-and-magnitude: it takes the absolute value, converts that, and puts a minus in front. So -10 in decimal is -1010 in binary and -a in hex. Clean, readable, and the form you want for math or a number literal in almost any language.

Hardware doesn't store negatives that way, though. Real machines use two's complement, where there's no separate sign character, the top bit carries the sign, and a negative gets encoded by flipping every bit of the positive value and adding one. In an 8-bit byte, -1 is stored as 11111111, which read as an unsigned number is 255. So pull 0xFF out of a register wondering whether it's meant to be -1, and this tool tells you 255, because it has no idea how wide your register is or whether you meant the value as signed. Neither answer is wrong, they're just answers to two different questions.

For decoding a raw signed value out of a fixed-width register, you need to know the bit width and apply two's complement yourself. No general four-base converter can guess that context, and one that pretends to is quietly making an assumption you ought to be questioning.

Worth memorizing, because it makes half of this tool optional. Sixteen is two to the fourth, so one hex digit maps to exactly four binary bits with nothing left over. 1111 is f, 0000 is 0, and two hex digits cover a full byte from 00 to ff. That's why 0xDEADBEEF is a compact way to write 32 bits, four at a time instead of thirty-two. Group any binary number into fours from the right, translate each group, and you've gone to hex without touching decimal. Those same byte pairs are how web colors work, #1e90ff is three bytes of red, green, and blue, and if you juggle colors a lot our hex to rgb converter splits one directly.

Octal hangs on in one stubborn corner, Unix file permissions. When you run chmod 755, that 755 is octal and each digit is three bits, read is 4, write is 2, execute is 1. Convert 755 from octal here and you get 111101101, and those nine bits are the permission switches in order, owner then group then others. If you'd rather tick boxes than count bits, our chmod calculator builds the string for you.