Number Base Converter — Binary, Hex, Decimal & Bytes

The same characters can mean two different things. The string 4142 is the integer 16706 if you read it as one hexadecimal number, and it is the two bytes 41 and 42 — the text AB — if you read it as a list of bytes. Most converters silently pick one. This tool makes you say which: Number mode converts one integer between binary, octal, decimal, hexadecimal and any base from 2 to 36, and Bytes / Text mode converts a sequence of bytes to and from hex, binary, decimal, octal and text.

Number mode treats 0x, 0b and 0o as prefixes, strips spaces, underscores, commas and new lines, and is deliberately simple about everything else: in Auto base only a prefix sets the base, so 101010 is the decimal number 101010 and not the binary number 42. To read it as binary, choose base 2. If you type \x41\x42 in Number mode the tool does not guess — it points out that \x escapes belong to bytes and offers to switch modes. Every integer is a BigInt, so a 100-digit decimal converts to hexadecimal exactly, and 9007199254740993 stays 9007199254740993 instead of rounding to …992 the way a floating-point converter would.

0xDEADBEEF is four bytes. Read as an unsigned 32-bit number it is 3735928559. Read as a signed 32-bit number — where the top bit means negative — the very same bits are −559038737. Nothing was converted; the same pattern has two readings, and the Interpret as strip shows both together with the bytes DE AD BE EF so you can pick the one a challenge expects.

That is why the tool distinguishes three operations instead of one. A value is a mathematical integer you typed, such as −42 or 3735928559, and at a fixed width it is range-checked: 3735928559 is refused as a 32-bit signed value and the message gives the valid range, −2147483648…2147483647. A bit pattern is the bits you supplied, such as 0xDEADBEEF at 32 bits; it must fit the width but is never rejected for being too big for signed, because you gave bits, not a signed value. A wrap is the third operation and happens only when you press the button: it takes the value modulo 2^width, so −1 wrapped to 8 bits is 11111111 and 300 wrapped to 8 bits is 00101100. The base cards always show the mathematical value — −42 stays −42 in the decimal card — while a separate pattern card shows the two's-complement form 11010110 (0xD6) with its unsigned reading 214 clearly labelled.

A multi-byte number has to be laid out in memory one byte at a time, and there are two conventions. Big-endian writes the most significant byte first, so 0x12345678 is 12 34 56 78. Little-endian writes the least significant byte first, so the same number is 78 56 34 12. The value is identical; only the byte sequence differs, which is why packet captures, file headers and CPU registers so often look 'backwards'. The Interpret as strip lists both byte strings together with the decimal you get if each is read big-endian, so you can compare the readings directly.

Fixed byte lengths follow the same rule. 255 in four bytes is 00 00 00 ff in big-endian — zero padding on the left — and ff 00 00 00 in little-endian, with the zero padding at the end. If a value needs more bytes than you asked for, the tool refuses and says how many it needs; it never truncates. In Bytes mode the same bytes are decoded as UTF-8 by default, with ASCII and Latin-1 available, and invalid sequences are counted at byte level — "1 invalid sequence (1 byte)" — while the original bytes are always kept.

Crypto challenges often hand you a huge decimal such as 7380380986433366397 and nothing else. It is a message treated as one big-endian integer: write the integer as bytes and read the bytes as text. Here 7380380986433366397 is 666c61677b68697d in hex, which is the text flag{hi}. Python players know this as long_to_bytes and bytes_to_long; this page does both directions in the browser, accepts the integer in decimal, hex or binary, and works with either byte order.

Byte length is a setting, not a guess. Minimal drops all leading zero bytes — and zero itself is the single byte 00 — while Fixed N pads to exactly N bytes (up to 65,536). Be aware that leading zero bytes cannot be recovered from an integer: 00 00 41 and 41 are the same integer, so if the original message started with zero bytes you must supply the length. Negative integers need Signed and a fixed length because two's-complement bytes need a width. When the resulting bytes are at least 90% printable ASCII or whitespace the tool shows a Possible text line with the exact ratio, such as 31/32 printable bytes, 96.9%; below that it shows hex only rather than a failed decode.

A value is a number; a representation is how many bits and bytes you spend writing it. The value 255 is FF in one byte and 00 00 00 FF in four, and as a signed 8-bit value it does not exist at all — the signed 8-bit range stops at 127. Most conversion mistakes in CTF work are really representation mistakes: the digits are right but the width, the sign or the byte order was assumed. Choosing the width up front, and having the tool state which operation it used — for example Read as a 32-bit pattern — removes the guesswork.

The More bases tab covers what Number and Bytes mode deliberately do not. Its fraction converter reads a number with a radix point in any base from 2 to 36, such as 101.101 in binary, and writes it in any other base. The value is held exactly as a fraction of two big integers, so there is no floating-point step. What is shown is the expansion cut off after the number of fraction digits you choose (8 to 128), never rounded, and a repeating expansion is marked: 0.1 in decimal is 0.0(0011) in binary, the bracketed digits repeating forever, which is also why 0.1 + 0.2 is awkward in most programming languages.

The other-number-systems card writes one decimal integer in five systems that CTF puzzles and programming contests occasionally use. Negative bases (−2 to −36) represent every integer without a minus sign — 6 is 11010 in base −2. Balanced ternary uses the digits T (−1), 0 and 1, so 8 is 10T. Factorial base (factoradic) uses the place values …, 5!, 4!, 3!, 2!, 1!, 0! with digits written most significant first and separated by colons, so 463 is 3:4:1:0:1:0 because 3×120 + 4×24 + 1×6 + 0×2 + 1×1 + 0×1 = 463, Zeckendorf writes a number as non-adjacent Fibonacci numbers (100 is 1000010100), and bijective base-26 is the spreadsheet column scheme where 27 is AA and 703 is AAA. Factorial, Zeckendorf and bijective are defined only for non-negative or positive integers, and the tool says so instead of guessing.

The bit-field card takes a fixed-width pattern and a layout written as name:width pairs, listed from the top bit or from bit 0, and shows each field's bit range, decimal, hex and binary value. Presets cover the first 32-bit word of an IPv4 header (0x45000054 is version 4, header length 5, total length 84), the TCP flags (0x12 is ACK and SYN), Unix file mode, the RGB565 pixel and the DOS date and time used in ZIP files. The IEEE 754 presets only split sign, exponent and mantissa; this tool does not convert a float to its decimal value.

Start with the reading, not the digits. An odd number of hex digits is ambiguous, so the tool asks whether to pad with a leading 0 or to treat the input as a number instead. Binary that is not a multiple of eight bits asks whether to left-pad the first byte. A decimal that should have been binary came from Auto base reading it as decimal — pick base 2. A positive number that came out negative was read as signed; switch to unsigned or widen the bit width. Text that looks reversed is the other byte order. Replacement characters mean the bytes are not valid UTF-8 — try ASCII or Latin-1, or look at the hex. A flag that is missing its first characters lost leading zero bytes in the integer, so set a fixed byte length.