Free Number Converter – Binary, Decimal, Hex, Octal & Base 2–62

A number converter expresses one mathematical value in a different positional numeral system. Decimal 255, binary 11111111, octal 377 and hexadecimal FF are four different written forms of the same integer. The symbols and place values change; the quantity does not. A reliable conversion always begins with the source radix and ends with a clearly labeled target radix.

MyToolSpace Number Converter is designed for learners, programmers, electronics students and technical readers who switch between decimal arithmetic and machine-oriented bases. The live tool exposes common radix buttons, a custom radix input, an all-base overview and an explanation of the conversion steps. It also groups related bitwise, encoding, signed-number and floating-point inspection workflows together.

Use it when a problem asks for binary to decimal, hexadecimal to binary, decimal to octal or a less common base. For ordinary integer conversion, the result should round-trip: converting from base A to base B and back to base A must recover the same value after ignoring nonessential leading zeros and alphabet case where applicable.

Binary uses two symbols, 0 and 1. Moving one position left multiplies the place value by two. Binary 101101 is 32 + 8 + 4 + 1 = decimal 45. Because digital hardware is commonly described in bits, binary is useful for bit flags, masks, memory dumps, permissions and low-level debugging.

Decimal uses digits 0 to 9 and powers of ten. Hexadecimal uses digits 0–9 followed by A–F for ten through fifteen. Each hexadecimal digit corresponds to a four-bit binary group: 1111 becomes F, 1010 becomes A and 0010 becomes 2. Thus binary 11111010 equals FA in hex and 250 in decimal.

Octal uses 0–7 and maps each digit to three binary bits. For instance binary 111101101 groups into 111 101 101, or octal 755. This is the notation behind familiar Unix permission settings. Grouping bits is faster than repeated decimal arithmetic when converting between bases that are powers of two.

For an integer written in radix b, start from the least significant digit and add digit × b raised to the position number. In hexadecimal 2AF, F means 15 and A means 10, so 2AF₁₆ = 2×16² + 10×16 + 15 = 687₁₀. A character is not valid if its numeric value is equal to or greater than its base.

For decimal-to-base conversion, divide the positive integer by the target base, record each remainder and keep dividing the quotient until it becomes zero. Read remainders in reverse order. For 100 decimal to hex, the first division gives quotient 6 and remainder 4; the next gives quotient 0 and remainder 6, so the result is 64₁₆.

Fractions require a different method: multiply the fractional part by the target base, record the integer part, and continue with the new fraction. Decimal 0.625 × 2 = 1.25, then 0.25 × 2 = 0.5, then 0.5 × 2 = 1.0, so 0.625₁₀ = 0.101₂. Fractions such as decimal 0.1 often have repeating binary expansions, making displayed length an important setting.

Beyond binary, decimal and hexadecimal, higher-base notations are used for compact identifiers, short codes and specialized protocols. A positional base-N numeral needs a specific mapping between symbol characters and digit values. For example, base36 commonly represents zero to nine followed by A–Z, whereas Base58 and Base62 conventions can differ between libraries and ecosystems.

The MyToolSpace page provides quick buttons for B32, B36, B58 and B62 plus custom bases from 2 to 62. Treat the selected tool alphabet as authoritative for a conversion. Do not assume a Base58 integer converter is equivalent to Bitcoin’s complete Base58Check address format: checksums, version bytes and leading-zero semantics are additional protocol rules.

Base32 used as a positional radix is also different from RFC 4648 Base32 binary-to-text encoding. The same warning applies to Base64, which is usually a byte-encoding format rather than an ordinary number-system conversion. A valid technical explanation needs to specify both the alphabet and whether the process operates on integers or bytes.

Ordinary JavaScript Number arithmetic cannot distinguish every integer above 2⁵³−1. The page describes using BigInt for large-integer conversions so a long digit string can be translated without silently changing the integer’s value. This is useful for hashes interpreted numerically, identifiers, counters and mathematical exercises, though a hash’s normal display representation may not require conversion at all.

For negative inputs, consider whether you need a mathematical signed numeral such as −FF or a fixed-width binary pattern such as 11111111. They are not interchangeable. Negative values in ordinary base notation carry a minus sign, while a two’s-complement display interprets a fixed number of bits with an agreed width.

For fractional values, exact rational internal arithmetic is compatible with a finite requested display length. In a repeating target representation, a printed string cannot express every digit; clarify whether the UI rounds or truncates. The live page also documents decimal scientific notation such as 1.25e8; confirm the selected input mode before treating letters e or E as digits in another radix.

A bit can contain 0 or 1. Eight bits make a byte, so an unsigned byte can represent 256 values from zero to 255. The Hamming weight of a binary word is the number of set bits. The pattern 10101010 has four set bits, making its Hamming weight four and its set-bit parity even.

Bit-level analysis helps explain permission flags, register fields and low-level protocol packets. A bit mask selects particular positions. For example 00001111 isolates the low nibble of an 8-bit quantity, whereas 11110000 selects the high nibble. In many debugging tasks, fixed-width leading zeros matter for readability even though they do not change the unsigned integer.

Parity describes whether the count of 1 bits is odd or even; it is not the same as whether the represented number is odd or even. The least significant bit alone tells whether an unsigned integer is odd. Hamming weight and parity often appear in error detection, combinatorics and bit-manipulation exercises.

Bitwise AND sets a result bit only when both operands have one in the same position. OR sets it when either bit is one, while XOR sets it when exactly one bit is one. For 12 (1100₂) and 10 (1010₂), AND is 1000₂ (8), OR is 1110₂ (14), and XOR is 0110₂ (6). These are standard building blocks of flags and checksums.

NOT flips bits, so its result must be interpreted with an explicit word width to avoid confusion about infinite leading sign bits. NAND, NOR and XNOR invert the corresponding two-input operation within the chosen width. Logical and arithmetic right shifts may differ when the sign bit is set; check whether the mode uses a zero-fill or sign-preserving rule.

For ordinary binary addition, carry bits just as in decimal but at base two. The expression 1111₂ + 1₂ becomes 10000₂. A fixed 4-bit register cannot store all five resulting bits; its wrapped 4-bit outcome is 0000 with carry out. The page includes binary arithmetic and a bitwise calculator to make these distinctions visible.

Two’s complement represents signed integers within a fixed bit width. In eight bits, 00000101 denotes +5. Invert the bits to 11111010 and add one to get 11111011, the 8-bit representation of −5. When that same pattern is interpreted as unsigned, it is 251. Both readings are valid, but the interpretation must accompany the bits.

For n-bit two’s-complement signed integers, the range is −2^(n−1) through 2^(n−1)−1. For 8 bits this is −128 through 127; unsigned 8-bit values instead cover 0 through 255. In a fixed-width setting, overflow can wrap or be detected depending on the operation and language; a base converter alone is not a compiler’s integer-overflow model.

The live number converter documents selectable widths of 8, 16, 32 and 64 bits. These settings matter when reading registers, network values and binary file formats. An 8-bit signed result should not be confused with a 64-bit signed result simply because both represent the same mathematical input before masking.

Floating-point numbers store approximate real values using a sign, an exponent and a fraction field. IEEE-754 binary32 (Float32) has 1 sign bit, 8 exponent bits and 23 stored fraction bits. Binary64 (Float64) has 1 sign bit, 11 exponent bits and 52 stored fraction bits. Normal numbers also use an implicit leading significand bit.

Many simple-looking decimal fractions have no finite binary expansion. That is why a typical binary floating-point calculation such as 0.1 + 0.2 may not compare equal to exactly 0.3. This is not a mistake in converting whole numbers: it is a property of the chosen finite floating-point representation. The live tool offers separate IEEE-754 inspection for these stored bit patterns.

When reading the layout, look for all-zero exponents, all-one exponents, subnormal values, infinities and NaNs. A displayed decimal may be rounded for readability; the stored bits are the definitive representation for that format. This inspector is separate from the arbitrary-precision integer conversion mode.

Computers store text as numerical codes, but the mapping between characters and bytes follows an encoding standard. ASCII maps values 0–127 to a restricted character set, including A as decimal 65 or hex 41. Unicode assigns code points such as U+0041; UTF-8, UTF-16 and UTF-32 specify how these code points are stored as sequences of bytes or code units.

UTF-8 uses one to four bytes for a Unicode scalar value and preserves ASCII byte patterns for the first 128 code points. UTF-16 uses one or two 16-bit code units for most values, with surrogate pairs for supplementary characters. UTF-32 uses a 32-bit code unit per scalar value. Endianness and byte-order marks can affect how raw byte dumps are interpreted.

Base64 represents bytes using a printable alphabet and optional padding; it is reversible encoding, not encryption. The number converter includes text-to-binary, text-to-hex and Base64 workflows. If output looks different from an integer’s base-64 representation, the likely cause is that one method encodes bytes and the other changes the radix of an integer.

The number converter page describes browser-based computation and BigInt arithmetic. This supports exact conversion of integers within the browser’s practical resource limits. For very large inputs, device memory, processing time, browser implementation limits and user-interface rendering can still impose constraints, so 'arbitrary precision' does not mean infinite hardware capacity.

Distinguish three kinds of precision. Mathematical integers can be converted exactly; rational fractions may have repeating representations that require a fractional output limit; IEEE-754 floats are designed for finite precision and expose stored rounded values. An output that is exact in one mode should not be generalized to all display and export formats.

For privacy, the page identifies its converter as browser-based, but users should still avoid pasting secrets into screenshots, copied text, logs, shared export files or third-party integrations. Before relying on results for money, safety-critical engineering or production systems, cross-check a sample against another trusted implementation and verify digit alphabet, signedness and byte order.