Binary, octal, decimal, hexadecimal and any base from 2 to 36, with fractions, step by step, two's complement and IEEE 754.
This converter works with exact arithmetic. Integers use BigInt, JavaScript's arbitrary-precision type, so a number with hundreds of digits converts without losing any, and fractions are handled as ratios of integers, never as floats. That is why it can show 0.1 in binary as 0.0(0011), with the repeating part in parentheses, instead of a truncated approximation. Converter mode accepts any base from 2 to 36, a sign, 0b, 0o and 0x prefixes, _ and space separators, a decimal point or comma, and shows binary, octal, decimal, hexadecimal, base 32 and base 36 at once, plus a base of your choice. If a character is invalid, the message says which one and at what position. Step by step mode shows successive divisions, successive multiplications for the fraction, and the sum of digit times base to the power of position, for any pair of bases. Two's complement and bits mode shows how a negative integer is stored in 8, 16, 32, 64 or another width, whether it overflows, and runs AND, OR, XOR, NOT and shifts. IEEE 754 mode opens a float32 or float64 into sign, exponent and mantissa, with the exact stored value and the rounding error. Text and codes mode turns characters into Unicode code points and UTF-8 bytes. Everything runs in your browser. In the bitwise operations, operands can be decimal or use the 0x, 0b and 0o prefixes, and negatives become two's complement at the chosen width.
Every positional system works the same way: a digit is worth itself times the base to the power of its position, counting from the right starting at zero. So from any base to decimal you just add up. Binary 1011 is 1x8 + 0x4 + 1x2 + 1x1 = 11. Hexadecimal 1F4 is 1x256 + 15x16 + 4x1 = 500, remembering that A to F are 10 to 15.
From decimal to another base, divide the number by the target base, write down the remainder and repeat with the quotient until you reach zero. The remainders, read from bottom to top, are the digits: 13 divided by 2 gives remainders 1, 0, 1, 1, which is 1101. For the part after the point the process flips: multiply the fraction by the base, the digit is the integer part of the product, and what is left gets multiplied again. If the remainder reaches zero, the fraction ends. If a remainder repeats, the cycle of digits repeats forever, as with 0.1, which in binary is 0.0001100110011... The Step by step tab does exactly this arithmetic, with the full table.
There is a shortcut between binary and bases 4, 8, 16 and 32, which are powers of 2: each hexadecimal digit is 4 bits and each octal digit is 3. To turn 11111111 into hexadecimal, split it into groups of 4 from the right (1111 1111) and swap each group for a digit: FF.
A fraction only ends when written in a base if every prime factor of its denominator (in lowest terms) divides the base. In decimal, 1/10 ends because 10 = 2 x 5. In binary the base only has the factor 2, and 1/10 has the factor 5 in its denominator, so the expansion never ends: 0.1 is 0.0001100110011..., with the block 0011 repeating, written here as 0.0(0011). The same goes for 0.2, 0.3 and most short decimal fractions.
Computers store numbers with a fractional part as binary floating point (IEEE 754), with a fixed number of bits. To store 0.1 the repeating expansion has to be cut and rounded, and the value stored in float64 is 0.1000000000000000055511151231257827..., slightly larger than 0.1. The IEEE 754 tab shows that exact value and the rounding error. That is where 0.1 + 0.2 giving 0.30000000000000004 in many languages comes from: it is not a bug, it is the result of adding two approximations.
Two's complement is how almost every processor stores signed integers. With N bits, the top bit has a negative weight, so the range goes from -2^(N-1) to 2^(N-1) - 1: in 8 bits, from -128 to 127. To negate a number, flip the bits and add 1, which gives -1 as 11111111 in 8 bits and FFFF in 16. The advantage is that addition and subtraction use the same circuit, with no separate sign handling. The same bit pattern can be read signed or unsigned: 11001000 is 200 unsigned and -56 signed.
IEEE 754 defines how to store real numbers in 32 bits (float32) and 64 bits (float64) with three fields: 1 sign bit, the exponent with a bias (8 bits and bias 127 in float32, 11 bits and bias 1023 in float64) and the mantissa (23 and 52 bits). In normal numbers there is an implicit 1 before the mantissa. The standard also reserves special values: signed zero, infinity, NaN and subnormals, which fill the gap between zero and the smallest normal number. In the IEEE 754 tab you can edit each bit and follow the decimal.
Binary is the hardware's natural base, but unreadable in long numbers. Hexadecimal fixes that because 16 is 2 to the power of 4: each hex digit is exactly 4 bits, and two digits are a byte. That is why it shows up in colors (#FF8800), memory addresses, hashes and dumps. Octal does the same with 3 bits per digit and survives in Unix file permissions, where chmod 755 packs the read (4), write (2) and execute (1) bits into each digit. Octal gained ground on old machines with 12, 18 or 36 bit words, which are multiples of 3. Base 36, with digits 0 to 9 and letters A to Z, appears in short identifiers and shortened URLs.
Base64 and base58 look like bases, but they are not positional number systems. They are encodings that turn bytes into text using an alphabet: base64 packs 3 bytes (24 bits) into 4 characters of 6 bits, and uses the = sign as padding. The number 1 in positional base 64 would be the digit 1, but the byte 0x01 in Base64 becomes AQ==. Likewise, the RFC 4648 Base32 text uses the alphabet A to Z and 2 to 7, while the positional base 32 in this tool uses 0 to 9 and A to V. If you need to encode bytes or files as text, use a base64 encoder. Here, the subject is the numeric value.
Paste the code into your HTML and the tool shows up on your page, without J-Kit's navigation and ads. It still runs in the browser of whoever visits your site.
<iframe
src="https://jkit.tools/embed/en-US/base-converter"
width="100%"
height="600"
style="border:0"
loading="lazy"
title="Number Base Converter"
></iframe>These references help contextualize formulas, standards, APIs and limitations used on this page. They do not replace professional validation when a result has legal, financial, medical or operational impact.
Multiply each bit by its weight, which is a power of 2 counted from the right starting at 2 to the power of 0, and add the results. For example, binary 1011 is 1x8 + 0x4 + 1x2 + 1x1 = 11. A quick check: 11111111 is always 255, because it is eight set bits, 2^8 - 1. To see the weight table laid out, use the Step by step tab.
Results
11111111377255FF7V73193All data stays in your browser. No numbers are sent to any server.