Number Base Converter

What is a number base?

A base — also called a radix — is how many distinct digits a numeral system uses, and therefore how much each position is worth.

In decimal, positions are powers of ten. 253 means:

2 × 10²  +  5 × 10¹  +  3 × 10⁰
  200    +    50     +    3     = 253

Change the base and only the multipliers change. The same number in hexadecimal is FD:

F × 16¹  +  D × 16⁰
15 × 16  + 13 × 1
  240    +   13     = 253

The quantity never moved. Only its written form did. That is the whole idea — a base is notation, not arithmetic.

Valid digits per base

A base with radix n uses exactly n digits, starting at zero. Once the numerals run out, letters continue the sequence.

Base 36 is the ceiling for this notation, because it exhausts the ten numerals and all twenty-six Latin letters. Anything beyond it needs a different alphabet — Base64 and Base58 are encodings with their own character sets rather than positional bases in this sense.

Notice the prefixes. 0x, 0o and 0b are not part of the value; they tell a compiler which base to read. This matters in a specific legacy case: in C, Java and older JavaScript, a bare leading zero means octal, so 010 is 8, not 10. That has caused real bugs in code parsing zero-padded input.

How to convert a number

1. Select the base you are typing in This is the source base. The tool cannot infer it — 101 is a valid number in every base, meaning 5 in binary, 65 in octal, 101 in decimal and 257 in hex.
2. Enter the value Spaces, underscores, commas and a matching prefix are stripped, so 0xFF, FF and 1111_1111 all work. A leading minus sign is accepted.
3. Read every base at once All six representations update together. Digit grouping, prefixes and letter case are display options and do not affect the copied value's digits.
4. Check the width panel Bit length, bytes needed and the smallest fixed-width integer that holds the value are shown, which is usually the actual question when you are debugging a field or a register.

Examples worth recognising

Why octal survives for file permissions

Three bits express exactly one octal digit, and Unix permissions come in groups of three bits — read, write, execute. So each octal digit maps to one permission set with nothing left over:

0o755  =  111 101 101
          rwx r-x r-x
          │   │   └── other:  5 = 101 = r-x
          │   └────── group:  5 = 101 = r-x
          └────────── owner:  7 = 111 = rwx

Hexadecimal has the same property for bytes, since one hex digit is exactly four bits and a byte is two digits. Neither base is more "computer-friendly" in the abstract; each aligns cleanly with a particular bit-group size.

Large numbers, and why BigInt matters here

JavaScript numbers are IEEE 754 doubles, exact for integers only up to 2⁵³ − 1. Past that, conversions silently return the wrong answer:

9007199254740993          // typed literally
(9007199254740993).toString(16)
// "20000000000000"        — wrong, the value became ...992

BigInt("9007199254740993").toString(16)
// "20000000000001"        — correct

This page parses with BigInt throughout, so Snowflake IDs, 64-bit hashes, large database keys and Twitter-style identifiers convert exactly. There is no practical upper limit beyond available memory.

Negative numbers and two's complement

A minus sign works, and every base shows a signed result. But hardware and low-level code do not store a sign — they use two's complement at a fixed width, which is why a negative value read from a register looks like a huge positive one.

For -1 at 32 bits:

Signed decimal:   -1
32-bit hex:        0xFFFFFFFF
Read as unsigned:  4294967295

When the input is negative, the tool also shows the 32-bit two's complement form. That is the explanation for the classic bug where a temperature sensor reports 65535 instead of −1: the value was read as unsigned at the wrong width.

Use cases

• Reading bit flags. A permissions integer of 22 is 10110 in binary, telling you which flags are set at a glance. The "bits set to 1" count gives the number of active flags.
• Setting file modes. Convert between the octal chmod argument and the decimal value an API expects.
• Checking field widths. Before storing a value, confirm whether it fits an unsigned 16-bit or signed 32-bit column.
• Debugging colour values. A hex colour is three or four byte-sized numbers; converting a channel to decimal connects #FF8000 to rgb(255, 128, 0). The Color Converter does the full conversion.
• Shortening identifiers. Base 36 gives a compact alphanumeric form of a large integer, useful for URL-safe short IDs.
• Reading memory addresses. Addresses in crash dumps and disassembly are hexadecimal; converting to decimal makes offsets easier to subtract.

Privacy

Parsing and formatting run in your browser using BigInt. Nothing you type is uploaded, which is worth knowing when the value is an internal identifier or a production key.