What hexadecimal notation is
Hexadecimal is a base-16 positional number system. Where decimal (base 10) uses ten digits and binary (base 2) uses two, hexadecimal uses sixteen: 0 through 9, then A through F to stand in for the values 10 through 15. Each position in a hex number represents a power of 16, the same way each position in a decimal number represents a power of 10. The number 1A3 in hex, for instance, means (1 × 16²) + (10 × 16¹) + (3 × 16⁰), which works out to 419 in decimal.
Hex exists because it maps cleanly onto binary. A single hex digit represents exactly four bits, so two hex digits represent a full byte, four represent a 16-bit word, and eight represent a 32-bit value. A 64-bit pointer or hash, written in binary, would be an unreadable string of 64 zeros and ones; written in hex, it's a compact 16-character string. That compression, with an exact and reversible relationship to the underlying bits, is the entire reason hex is used throughout computing rather than, say, base 12 or base 20.
Converting hex to decimal
To convert a hex value to decimal by hand, multiply each digit by 16 raised to the power of its position (counting from 0 on the right), then add the results. For 0x2F: the F (15) is in position 0, contributing 15 × 16⁰ = 15; the 2 is in position 1, contributing 2 × 16¹ = 32. Adding them gives 47. This converter does the same arithmetic, but treats the input as an arbitrary-precision integer rather than a fixed-size register, so a 40-digit hex string converts just as correctly as 0xFF.
Converting decimal to hex
The reverse direction uses repeated division by 16. Divide the decimal number by 16, write down the remainder as a hex digit, then repeat with the quotient until it reaches zero. Reading the remainders from last to first gives the hex value. For 500: 500 ÷ 16 = 31 remainder 4; 31 ÷ 16 = 1 remainder 15 (F); 1 ÷ 16 = 0 remainder 1. Reading the remainders bottom-up gives 1F4, so 500 in decimal is 0x1F4.
Where hex shows up in software development
Memory addresses and pointers are almost always printed in hex in debuggers, crash dumps, and core dumps, because a fixed-width hex string maps directly onto the machine word without any conversion loss. Color values in CSS and design tools (#FF5733) are hex-encoded RGB bytes. File format signatures — the first few bytes of a file that identify its type, like 89 50 4E 47 for PNG — are conventionally described and matched in hex. Hash digests (MD5, SHA-256), UUIDs, and MAC addresses are all hex strings under the hood. Error codes in Windows API calls (0x80070005) and HTTP status extensions, IPv6 addresses, and Unicode code points (U+1F600) all use hex for the same reason: it's a direct, lossless view of the underlying binary data that's shorter than binary and easier to group into bytes than decimal.
Negative numbers and large values
Decimal integers can be negative in the ordinary sense — this tool accepts a leading minus sign and returns a signed hex value, such as -255 converting to -0xFF. That's sign-magnitude notation: a sign plus an absolute value, which is how most people read and write negative numbers by hand. It's different from how negative numbers are actually stored in a computer's memory, which uses two's complement — a fixed-width bit pattern where the top bit signals sign and there's no separate minus symbol. If you need that representation instead, theHex ↔ Signed Integer tool interprets a hex value as a two's complement number at a chosen bit width, and theTwo's Complement Calculator walks through the bit-level steps of how that representation is derived.
Because this converter uses arbitrary-precision arithmetic rather than a fixed integer type, it isn't limited to 32-bit or 64-bit ranges the way a calculator built on native machine integers would be. A 100-digit hex number converts to its exact decimal equivalent, and vice versa, without rounding or overflow.
Common mistakes when reading or writing hex
Hex letters are case-insensitive: 0xff, 0xFF, and 0xFf all represent the same value, 255. Some tools and languages prefer uppercase for readability, others lowercase; neither is more correct. Leading zeros don't change the value — 0x00FF and0xFF are identical — but they're often kept to indicate a fixed bit width, such as showing a byte as two digits or a 32-bit value as eight. The 0x prefix itself isn't part of the number; it's a notation convention (borrowed from C) to distinguish a hex literal from a decimal one, and this converter accepts input with or without it.
A related point of confusion is digit count versus value. 0x1 and 0x0001 both equal 1, but many formats expect a specific number of digits regardless of the value — a byte is always written as two hex digits (0x05, not 0x5), a 16-bit value as four, and so on. When pasting hex into a context that expects a fixed width, such as a color code or a memory address, it's the padding that matters, not just the numeric equivalence.