Number Base Converter

JavaScript's regular Number type can only represent integers exactly up to 2^53 - 1 (about 9 quadrillion) before it silently starts losing precision — well within reach of a 64-bit hexadecimal or binary value a developer might actually need to convert. This tool uses JavaScript's built-in BigInt type instead, which supports arbitrary-precision integers of any size, limited only by available memory — so a 128-bit or even far larger value converts with complete accuracy rather than silently rounding.

These are simply different counting systems (bases 2, 8, 10, and 16 respectively) for representing the exact same numeric value — decimal is what humans use day to day, binary is how computers store and process data at the hardware level (every bit is a 0 or 1), and octal and hexadecimal exist as more compact, human-readable shorthand for binary, since each octal digit maps to exactly 3 binary bits and each hex digit maps to exactly 4. Hexadecimal in particular shows up constantly in real development work — color codes (#FF5733), memory addresses, hash digests, MAC addresses, and binary file dumps are all conventionally written in hex specifically because it's a much shorter, easier-to-read stand-in for the underlying binary.

Any positional numeral system works the same way regardless of its base: each digit position represents a power of the base, so converting a value simply means repeatedly dividing by the target base and reading off the remainders (for encoding a decimal value into another base), or, in reverse, multiplying by the base and adding each digit's value as you read through the string (for decoding a value from another base back to decimal). Base 36 is a common practical choice because it uses the full set of digits 0-9 plus letters a-z, giving the most compact representation possible using only alphanumeric characters — it shows up in URL shorteners, unique ID generators, and anywhere a short, case-insensitive-friendly identifier is useful.

This tool represents negative numbers using a leading minus sign across every base, the same simple, direct way most calculators and everyday tools represent negative values, rather than an implicit fixed-width two's complement encoding — so -42 in decimal converts to -101010 in binary, not the two's complement bit pattern a specific 8-bit or 32-bit signed integer would use in memory. Two's complement is a hardware/language-specific storage convention for a value with a defined bit width, which is a genuinely different question from 'what is the base-2 representation of this negative number' — if you need a specific fixed-width two's complement bit pattern, that requires knowing the exact bit width you're targeting first.

It's the minimum number of binary bits required to represent the magnitude of the current value — for example, 255 needs exactly 8 bits (11111111) while 256 needs 9 (100000000), since 8 bits alone can only reach 255 unsigned. The 'fits within' indicator then rounds up to the next common storage width (8, 16, 32, 64, or 128 bits) — useful for quickly sanity-checking whether a value will safely fit in a given integer type in a language like C, Java, or Rust, where fixed-width types have hard upper limits.

Prefixes like 0x (hex), 0b (binary), and 0o (octal) are a programming-language convention that tells a compiler or interpreter how to interpret a numeric literal written directly in source code — they aren't part of the number's actual value, just a marker disambiguating which base a bare sequence of digits should be read as. This tool's fields are already explicitly labeled by base, so no prefix is needed; if you're pasting a value copied from code that includes a 0x or 0b prefix, simply drop the prefix before pasting it in, or leave it — most such prefixes will simply be rejected as invalid characters for that field's base, making the mistake obvious immediately.

No — this tool works exclusively with whole integers, since it's built around JavaScript's BigInt type, which by design only represents integers. Converting a fractional value between bases is a meaningfully different, more involved problem (the fractional part is converted separately from the integer part, using repeated multiplication rather than division, and many fractional values that terminate cleanly in one base become infinitely repeating in another) — if you need that, you'll need a tool purpose-built for base conversion of real (non-integer) numbers.