Question 1

What is a number base, and why are binary, octal, and hex important?

Accepted Answer

A number base (or "radix") is the count of unique digits in a positional numeral system. Decimal (base 10) uses 0–9. Binary (base 2) uses 0 and 1 — the language of digital hardware. Hexadecimal (base 16) uses 0–9 plus a–f and is the compact human-readable form computers actually prefer for memory addresses, color codes, hash digests, and machine code. Octal (base 8) is a legacy compromise used today mostly in UNIX file permissions (777 = `rwxrwxrwx`).

Question 2

Why does this converter use BigInt instead of regular JavaScript numbers?

Accepted Answer

JavaScript's native `number` is a 64-bit IEEE 754 double and can only represent integers exactly up to 2⁵³ − 1 (9,007,199,254,740,991). Anything beyond — UUIDs, SHA-256 digests, 64-bit memory addresses — silently loses precision when parsed as a number. We use the native `BigInt` type underneath so values of any size convert exactly, with no rounding errors.

Question 3

Is my number sent to any server?

Accepted Answer

No. Every conversion — parsing, base math, two's complement, formatting — happens in your browser via BigInt arithmetic. Memory addresses from a crash dump, internal product IDs, license keys, cryptographic constants — none of it ever leaves your device.

Question 4

What is two's complement and when should I use it?

Accepted Answer

Two's complement is how nearly every modern CPU represents signed integers. To get −1 in 8-bit two's complement, take the binary of 1 (00000001), flip every bit (11111110), and add 1 (11111111 = 0xFF). Switch the Bit Width dropdown from "Auto" to 8, 16, 32, or 64 and we display the signed representation alongside its unsigned hex and binary forms — essential when debugging C, Rust, Go, or any low-level code.

Question 5

Why does my value sometimes show an ASCII character?

Accepted Answer

When the value falls in the printable ASCII range (32 through 126), we surface the corresponding character. So 65 displays as `A`, 32 as a space, 126 as `~`. Useful when decoding hex byte sequences from memory dumps, network packets, or debug logs.

Question 6

How do I enter a binary or hex value with a prefix?

Accepted Answer

Our parser recognises the common prefixes: `0b` and `0B` for binary (`0b1010` = 10), `0o` for octal (`0o755` = 493), `0x` and `#` for hex (`0xFF` and `#FF` both = 255). Switch to the matching base tab first, paste the prefixed value, and we strip the prefix for you. Underscores and spaces are also stripped — `1010_1010` and `1010 1010` both parse correctly.

Question 7

What does "Base 36" mean and when is it useful?

Accepted Answer

Base 36 uses every alphanumeric digit (0–9, a–z) to encode a number, producing the most compact string representation possible in plain ASCII. JavaScript's `Number.prototype.toString(36)` is a classic way to generate short random tokens — `Math.random().toString(36).slice(2)` produces a base-36 string. URL shorteners, short-ID generators, and some game-save formats rely on it. Drag the slider in the tool to 36 to see your value rendered that way.

Question 8

How does this differ from JavaScript's parseInt(value, base) and Number.toString(base)?

Accepted Answer

Two differences. (1) We use BigInt under the hood, so we work correctly with values beyond 2⁵³ − 1 — `parseInt` silently loses precision past that point. (2) We add two's complement, bit grouping, ASCII mapping, and radix-prefix detection, none of which the native methods provide. For everyday conversions in script files, the native methods are fine; for hand-debugging large hex digests or crash addresses, this tool is faster.

Question 9

Can I convert negative numbers?

Accepted Answer

Yes. Prefix with `-` for a signed value in any base. The result will show the negative form in each base; toggle a bit width to see the two's complement representation. Most low-level debugging starts in decimal — type `-42`, set bit width to 8, and you'll see the 8-bit two's complement (`11010110` / `D6`) that the CPU actually stores.

Value	Binary (8-bit)	Hex (8-bit)
5	0000 0101	0x05
−1	1111 1111	0xFF
−5	1111 1011	0xFB
−128 (min)	1000 0000	0x80
127 (max)	0111 1111	0x7F

Free Number Base Converter: Binary, Octal, Decimal, Hex

Arbitrary Precision (BigInt)

Bases 2 Through 36

Two's Complement Mode

100% Client-Side

The BigInt-Precision Number Base Converter for Low-Level Engineering

The Five Bases Every Engineer Uses

Two's Complement, Explained Once and For All

A Practical Debugging Workflow

Related Engineering & Encoding Utilities

Base	Name	Digits	Real-World Use
2	Binary	0–1	CPU registers, bitmasks, flags, permission bits
8	Octal	0–7	UNIX file permissions (e.g. `chmod 755`)
10	Decimal	0–9	Human reading, financial values, counters
16	Hexadecimal	0–9, a–f	Memory addresses, color codes, hash digests, machine code
36	Base 36	0–9, a–z	Short tokens, URL shorteners, compact IDs