Number Converter

Binary is the base-2 number system, using only the digits 0 and 1. Each position represents a power of two. Computers use binary because their transistors have two stable states (off and on), which map naturally to 0 and 1.

Hexadecimal is the base-16 number system, using the digits 0–9 and the letters A–F (where A=10, B=11, …, F=15). It is popular with programmers because one hex digit represents exactly four binary bits, so a byte is just two hex digits.

Octal is the base-8 number system, using digits 0–7. Each octal digit maps to exactly three binary bits. It is used in Unix file permissions (for example chmod 755) and some legacy systems.

Decimal is the base-10 number system we use every day, with digits 0–9. Each position represents a power of ten. It is called base-10 because it has ten distinct digits.

255 in binary is 11111111 — eight ones. This is the largest value that fits in a single 8-bit byte, which is why 255 appears so often in computing (for example in RGB colour values).

FF in hexadecimal equals 255 in decimal. F is 15, so FF = 15×16 + 15 = 255. It is the maximum value of one byte.

To convert to decimal, multiply each digit by its base raised to the digit’s position and add the results. To convert from decimal to another base, repeatedly divide by the target base and read the remainders from bottom to top. This tool shows every step.

Multiply each binary digit by the corresponding power of two and add them. For example 1011 = 1×8 + 0×4 + 1×2 + 1×1 = 11. Use the step-by-step view to see the full expansion.

Repeatedly divide the decimal number by 2, writing down each remainder, until the quotient is 0. Read the remainders from bottom to top. For example 13 → 1101.

Repeatedly divide by 16 and record the remainders (using A–F for 10–15), then read them bottom-to-top. For example 255 → FF, and 4095 → FFF.

Base64 is a binary-to-text encoding that represents binary data using 64 printable ASCII characters (A–Z, a–z, 0–9, + and /). It is used to safely transmit binary data — like images or attachments — through text-only channels such as email or JSON. It is an encoding, not a positional number system.

These are positional number systems (and encodings) using larger digit alphabets. Base32 uses 32 symbols, Base58 (used by Bitcoin) omits easily-confused characters like 0/O and l/I, and Base62 uses 0–9, A–Z and a–z. They produce shorter strings than binary or hex for the same value.

ASCII (American Standard Code for Information Interchange) is a 7-bit character encoding that maps 128 characters — letters, digits and symbols — to the numbers 0–127. For example the letter A is 65 and the digit 0 is 48.

Unicode is a universal character standard that assigns a unique code point to every character in every writing system, far beyond ASCII’s 128. Code points are written like U+0041 (the letter A). UTF-8, UTF-16 and UTF-32 are ways of encoding those code points as bytes.

They are all encodings of Unicode. UTF-8 uses 1–4 bytes per character and is backward-compatible with ASCII, making it the web standard. UTF-16 uses 2 or 4 bytes. UTF-32 uses a fixed 4 bytes per character. UTF-8 is the most space-efficient for Latin text.

Two’s complement is the standard way computers represent signed integers. The most significant bit indicates the sign, and negative numbers are formed by inverting all bits and adding one. It lets the same addition circuitry work for both positive and negative numbers.

Invert every bit of the number (one’s complement) and then add 1. For example, in 8 bits, +5 is 00000101, so −5 is 11111010 + 1 = 11111011.

IEEE-754 is the standard for representing floating-point numbers in computers. A number is split into a sign bit, an exponent and a mantissa (fraction). Float32 uses 1 + 8 + 23 bits; Float64 uses 1 + 11 + 52 bits. This tool shows each field for any value.

Hex is compact and maps cleanly to binary: each hex digit equals four bits, so a 32-bit value is just 8 hex digits. It is far easier to read and write than long binary strings, which is why memory addresses, colour codes and machine values are shown in hex.

Computers store all numbers as binary bits. Integers use fixed-width binary (often with two’s complement for signs), and real numbers use IEEE-754 floating point. Text is stored as numbers too, via character encodings like ASCII and UTF-8.

A bit is a single binary digit (0 or 1). A byte is a group of 8 bits, which can represent 256 values (0–255). Bytes are the basic unit of computer memory and storage.

The Hamming weight (or population count) is the number of 1 bits in a number’s binary representation. For example 170 (10101010) has a Hamming weight of 4. It is used in error-correcting codes and performance-critical algorithms.

Parity tells you whether the number of 1 bits is even or odd. Even parity means an even count of 1s; odd parity means an odd count. Parity bits are a simple way to detect single-bit errors in transmitted data.

Yes. Integer conversions use BigInt arbitrary-precision arithmetic, so there is no overflow — you can convert numbers with hundreds of digits exactly. Fractions are handled with exact rational maths.

Yes. You can convert negative numbers (for example −255), fractions (255.75), and base-10 scientific notation (1.25e8). For two’s complement, signed representations are shown for 8, 16, 32 and 64-bit widths.

Roman numerals are a system from ancient Rome using letters: I=1, V=5, X=10, L=50, C=100, D=500 and M=1000. Smaller values before larger ones are subtracted (IV=4, IX=9). This tool converts between Roman numerals and decimal for 1–3999.

Group the digits and name each group with its scale word. This tool supports both the international system (thousand, million, billion) and the Indian system (thousand, lakh, crore), and even reads out decimal fractions.

The Indian numbering system groups the rightmost three digits together, then every two digits after that, and uses lakh (100,000) and crore (10,000,000). For example 1,000,000 is written 10,00,000 and read as “ten lakh”.

Scientific notation writes a number as a value between 1 and 10 multiplied by a power of ten, for example 1.25 × 10⁸ (written 1.25e8). It is convenient for very large or very small numbers.

Engineering notation is like scientific notation but the exponent is always a multiple of three (so it aligns with metric prefixes like kilo, mega, giga). For example 12,500 becomes 12.5e3.

Each character is converted to its byte value (via UTF-8) and then written as 8 binary digits. For example “A” is 65 = 01000001. This tool converts whole strings both ways.

Each character is converted to its byte value and written as two hexadecimal digits. For example “HELLO” becomes 48 45 4C 4C 4F. The tool reverses this too.

Bitwise operations work on individual bits: AND, OR, XOR, NOT, and the combinations NAND, NOR and XNOR, plus left and right shifts. They are fundamental to low-level programming, flags, masks and cryptography.

A left shift moves bits toward the most significant end (multiplying by powers of two); a right shift moves them the other way (dividing). This tool performs shifts within a chosen bit width so results stay masked correctly.

Because 0.1 and 0.2 cannot be represented exactly in IEEE-754 binary floating point — they are stored as the nearest representable values, and the tiny errors add up. Use the IEEE-754 view to see exactly how a value is stored.

It lets you choose any source and target base from 2 to 62 — for example base 7 to base 13, or base 3 to base 62 — not just the common ones. Useful for puzzles, cryptography and computer-science coursework.

Yes. All integer conversions use exact BigInt arithmetic and fractions use exact rational maths, so results are mathematically precise with no rounding error or overflow, at any size.

Yes. It is completely free with no sign-up, runs entirely in your browser so nothing is uploaded, and works offline once loaded. History and favourites are stored only on your device.

One hexadecimal digit represents exactly four bits (a nibble), because 16 = 2⁴. Two hex digits make one 8-bit byte.

Unsigned maximums are 255 (8-bit), 65,535 (16-bit), 4,294,967,295 (32-bit) and 18,446,744,073,709,551,615 (64-bit). Signed maximums are roughly half those, since one bit is used for the sign.