Type a number in any field and the others update instantly — binary, octal, decimal, hexadecimal, and any base from 2 to 36. The thing that makes this worth using over the first result you find is precision. Most base converters are built on parseInt, which holds integers exactly only up to about nine quadrillion and rounds silently above that: ask one for the decimal value of FFFFFFFFFFFFFFFF and you will get an answer whose last four digits are wrong, with nothing to tell you. Those large values are exactly what people convert — 64-bit IDs, hashes, flag masks, nanosecond timestamps. Everything here uses arbitrary-precision integers, so the result is exact at any size. Prefixes like 0x and 0b are accepted and ignored, as are spaces and underscores, so you can paste a literal straight from your code. Binary is also shown grouped in eights so it lines up with bytes.
| Base | 255 | FFFFFFFFFFFFFFFF |
|---|---|---|
| Decimal | 255 | 18446744073709551615 |
| Hexadecimal | ff | ffffffffffffffff |
| Octal | 377 | 1777777777777777777777 |
| Binary | 11111111 | 64 ones |
| Base 36 | 73 | 3w5e11264sgsf |
| parseInt would give | 255 | 18446744073709552000 — wrong |
No. Everything runs in your browser.
Because they use parseInt, which returns a double. Doubles hold integers exactly only to 2^53, roughly nine quadrillion, and round beyond it without any error. FFFFFFFFFFFFFFFF should be 18446744073709551615; parseInt gives 18446744073709552000. This tool uses arbitrary-precision integers, so it is exact.
There is no practical limit — hundreds of digits convert exactly. It is not restricted to 32 or 64 bits.
Yes. The 0x, 0b and 0o prefixes are accepted and ignored, as are spaces and underscores, so a literal copied out of source code works without editing.
Yes, with a leading minus, and the sign is preserved across bases. Note this is a signed value, not a two's-complement bit pattern — if you want the bit pattern of a negative integer, convert the unsigned value instead.
So the groups line up with byte boundaries. Grouping from the left would put a partial group at the end and make the last byte hard to read, which defeats the purpose.
Every conversion runs through arbitrary-precision integers rather than JavaScript numbers, and that single decision is the point of the tool. A JavaScript number is a double, so it holds integers exactly only up to 2 to the power of 53 — about nine quadrillion. Above that, parseInt and Number both start rounding, and they do it silently: parseInt of FFFFFFFFFFFFFFFF in base 16 returns 18446744073709552000, where the correct answer is 18446744073709551615. The last four digits are simply wrong, with no error and no warning, and the values where this happens — 64-bit identifiers, hashes, flags, addresses, timestamps in nanoseconds — are exactly the ones people reach for a base converter to inspect. Working in BigInt throughout means the answer is exact at any size, whether that is 64 bits or 600. Parsing is tolerant in the ways that save retyping: 0x, 0b and 0o prefixes are accepted and ignored, as are spaces and underscores, so a literal copied straight out of source code works; case is irrelevant; and a leading minus is handled. Validation is per digit and names the character that does not belong along with the base it was rejected for, which is more useful than a generic failure when the cause is usually one wrong character in a long string. Any base from 2 to 36 is available, not only the familiar four, and binary output is additionally shown grouped in eights from the right so the grouping aligns with byte boundaries rather than with the start of the string. Nothing is uploaded.