Number Base Converter

A number base — also called a radix — defines how many unique digits a positional numeral system uses before rolling over to the next place value. The familiar decimal system uses base 10 (digits 0–9); binary uses base 2 (digits 0–1); hexadecimal uses base 16 (digits 0–9 plus letters A–F). Every positive integer can be expressed in any of these systems, and the underlying quantity never changes — only the written representation does.

Number base conversion is one of the most fundamental skills in computer science and digital electronics. Processors store and manipulate all data in binary form, yet programmers routinely read memory addresses in hexadecimal, file permissions in octal, and business logic in decimal. Being able to fluently move between these representations lets you decode hardware data sheets, write low-level bit-manipulation code, interpret network protocols, and understand how data is laid out in memory.

Our number base converter calculator handles the conversion automatically. You enter a number in any supported base — binary, octal, decimal, hexadecimal, base-32, base-36, or any custom base from 2 to 36 — and the tool instantly displays every other representation simultaneously. You also get bit-length information, byte count, ones and zeros counts, and whether the value is a power of two — all of which are useful diagnostics when working at the hardware or systems-programming level.

This guide explains the mathematics behind positional notation, walks through manual conversion procedures, and shows you how the calculator applies JavaScript's built-in parseInt and Number.prototype.toString to produce fast, accurate results for any integer you enter.

Every number in a positional system can be understood as a sum of digits multiplied by powers of the base. In decimal, the number 255 means (2 × 10²) + (5 × 10¹) + (5 × 10⁰) = 200 + 50 + 5 = 255. The same value in binary is 11111111, which expands to (1×2⁷)+(1×2⁶)+(1×2⁵)+(1×2⁴)+(1×2³)+(1×2²)+(1×2¹)+(1×2⁰) = 128+64+32+16+8+4+2+1 = 255. Both representations encode the same quantity — they just use different bases.

To convert from any base to decimal, you multiply each digit by the appropriate power of the base and sum the results. This is exactly what JavaScript's parseInt(string, radix) does internally. To convert from decimal to another base, you repeatedly divide by the target base, collecting remainders from right to left. JavaScript's Number.prototype.toString(radix) implements this division-remainder algorithm and returns the result as a string — for bases above 10 it uses lowercase letters a–z for digit values 10–35, which the calculator then uppercases for readability.

The tool also groups binary output into nibbles (4-bit groups) separated by spaces — for example, 11111111 becomes "1111 1111" — and groups hexadecimal output into byte pairs — FF becomes "FF". These visual groupings mirror how engineers actually read binary and hex dumps, making it easier to spot byte boundaries and bit patterns at a glance.

For the bit-analysis panel, the calculator counts the total number of binary digits (bit length), computes the minimum number of bytes required to store the value using Math.ceil(bitLength / 8), tallies set bits (1s) and unset bits (0s), and checks for power-of-two status using the bitwise identity (n & (n-1)) === 0. A power of two has exactly one set bit in its binary representation, which is a commonly exploited property in hashing, memory allocation, and data-structure sizing.

Binary (base 2) is the native language of digital hardware. Every transistor is either off (0) or on (1), so all processor instructions, memory addresses, and file contents ultimately exist as streams of binary digits. Understanding binary is essential for bit manipulation, bitwise operators in programming, networking (subnet masks), and cryptography.

Octal (base 8) uses digits 0–7. It was common on early minicomputers and mainframes because each octal digit maps cleanly to exactly three binary digits — so the binary string 111 111 111 becomes 7 7 7 in octal. Today octal survives primarily in Unix/Linux file permission notation: chmod 755 uses three octal digits to encode read/write/execute bits for owner, group, and others.

Decimal (base 10) is what humans use every day. It has ten digits (0–9) and every place value is a power of 10. While computers do not work natively in decimal, all human-readable output — prices, counts, measurements — is expressed in decimal. The decimal value serves as the universal pivot point in this calculator: every input is first parsed into a decimal integer, then expressed in all target bases.

Hexadecimal (base 16) is the workhorse of programming and digital systems. Its sixteen digits (0–9 and A–F) mean that each hex digit represents exactly four binary bits (one nibble), so two hex digits encode a full byte. Memory addresses, color codes (#FF5733), MAC addresses, SHA hashes, and machine-code listings are all written in hex because it is far more compact than binary and still maps one-to-one onto bytes.

Base-32 uses digits 0–9 and letters A–V (or in some standards A–Z and 2–7). It is used in certain encoding schemes for file names, DNS labels, and TOTP (time-based one-time password) secret keys because it avoids ambiguous characters like 0/O and 1/I/l. Base-36 uses all ten digits plus all 26 letters of the alphabet, producing the most compact human-readable integer representation without case sensitivity — useful for URL shorteners and compact ID generation.

Beyond simple base conversion, this calculator provides a bit analysis panel that surfaces several important properties of a number's binary representation. These properties appear constantly in low-level programming, algorithm design, and computer architecture, and knowing them by inspection can save significant debugging time.

Bit length is the number of binary digits required to represent the value, which equals ⌊log₂(n)⌋ + 1 for any positive integer n. For example, 255 requires 8 bits (11111111), while 256 requires 9 bits (100000000). Bit length determines the minimum word size a CPU register must have to hold a value, and it feeds directly into the byte length calculation: Math.ceil(bitLength / 8) gives the number of full bytes needed.

Ones count (also called Hamming weight or popcount) is the number of set bits in the binary representation. This value matters in error-correcting codes, hashing algorithms, population counting for sets, and SIMD (single-instruction multiple-data) operations. A ones count of 1 means the number is a power of two. High ones counts indicate values with many flags set simultaneously, which is useful when reading bitmask registers.

Power of two detection uses the identity (n & (n - 1)) === 0: subtracting 1 from a power of two flips its single set bit and all lower bits, so AND-ing with the original always yields zero. This check is O(1) and is used everywhere from hash table sizing (powers of two allow cheap modulo via bitwise AND) to memory-aligned allocation. The calculator flags this property explicitly so you can identify it at a glance.

Even or odd is determined by the least-significant bit: if bit 0 is 0 the number is even; if it is 1 the number is odd. This is equivalent to n % 2 === 0 but the bitwise version (n & 1) is marginally faster and appears in performance-critical inner loops. Understanding this property is a stepping stone to more advanced bit manipulation tricks used throughout systems and competitive programming.

Number base conversion is not just a classroom exercise — it arises in real engineering and programming work every day. Here are the most common scenarios where a reliable base converter calculator saves time.

Web and graphic design: CSS colors are specified as six-digit hex codes like #1A2B3C. To understand what decimal red, green, and blue components those hex pairs represent, you convert each pair (1A, 2B, 3C) from hexadecimal to decimal to get the RGB values (26, 43, 60). Going the other direction — adjusting an RGB color and encoding it back to hex — is equally common.

Network administration: IPv4 addresses are four decimal octets (e.g., 192.168.1.1), but subnet masks and bitwise network calculations require binary representations. Converting 255.255.255.0 to binary immediately reveals the /24 prefix length. IPv6 addresses use hexadecimal groups, so hex-to-decimal and hex-to-binary conversions are a daily occurrence for network engineers.

Assembly and embedded programming: Processor register values, port addresses, and interrupt vectors are almost always given in hexadecimal in datasheets. Translating hex to binary lets you see exactly which bits are set in a control register, enabling you to safely flip individual flags without disturbing others using bitmask operations.

Permissions and security: Unix file permissions use octal notation. The permission chmod 644 means owner has read+write (6 = 110 in binary), group has read-only (4 = 100), and others have read-only (4 = 100). Converting octal to binary makes the permission bits immediately interpretable.

Data encoding: Base-64 and base-32 encoding schemes represent binary data as ASCII text for safe transmission over protocols that handle only printable characters. Understanding how larger bases pack more bits per character — base-32 uses 5 bits per character, base-64 uses 6 — helps you reason about encoding overhead and choose the right scheme for your use case.