Hex to Decimal Converter

About Hex to Decimal Converter

Hex Digit Values

The hexadecimal system extends the familiar decimal digits (0-9) with six additional symbols (A-F) to represent values 10 through 15 in a single character. This gives each position 16 possible values instead of the 10 used in everyday counting. The table below shows all 16 hex digits alongside their decimal and 4-bit binary equivalents.

Hex	Decimal	Binary	Hex	Decimal	Binary
0	0	0000	8	8	1000
1	1	0001	9	9	1001
2	2	0010	A	10	1010
3	3	0011	B	11	1011
4	4	0100	C	12	1100
5	5	0101	D	13	1101
6	6	0110	E	14	1110
7	7	0111	F	15	1111

The key relationship here is that each hex digit maps to exactly 4 binary bits (a nibble). Two hex digits represent a full byte (8 bits), covering the range 00 to FF (0 to 255 decimal). This one-to-four mapping is the main reason hex became the standard shorthand for binary data in computing.

How Hex to Decimal Conversion Works

Each hex digit represents a power of 16 based on its position from right to left. The rightmost digit is multiplied by 16^0 (which is 1), the next by 16^1 (16), then 16^2 (256), and so on. Multiply each digit by its positional value and sum the results.

Worked example - converting 1A3 hex to decimal: Start from the right. The digit 3 is in position 0, so 3 x 16^0 = 3 x 1 = 3. The digit A (value 10) is in position 1, so 10 x 16^1 = 10 x 16 = 160. The digit 1 is in position 2, so 1 x 16^2 = 1 x 256 = 256. Adding them up: 256 + 160 + 3 = 419. So hex 1A3 = 419 decimal.

Hex Value	Calculation	Decimal Result
FF	(15 x 16) + (15 x 1)	255
1A3	(1 x 256) + (10 x 16) + (3 x 1)	419
BEEF	(11 x 4096) + (14 x 256) + (14 x 16) + (15 x 1)	48,879
DEAD	(13 x 4096) + (14 x 256) + (10 x 16) + (13 x 1)	57,005

How Decimal to Hex Conversion Works

The reverse process uses repeated division. Divide the decimal number by 16, write down the remainder, and repeat with the quotient until it reaches zero. Each remainder becomes a hex digit, and reading them from bottom to top gives the final hex string. Remainders of 10 through 15 are written as A through F.

Worked example - converting 1000 decimal to hex: 1000 / 16 = 62 remainder 8. 62 / 16 = 3 remainder 14 (E). 3 / 16 = 0 remainder 3. Reading remainders bottom to top: 3E8. So 1000 decimal = 3E8 hex. You can verify: (3 x 256) + (14 x 16) + (8 x 1) = 768 + 224 + 8 = 1000.

Step	Division	Quotient	Remainder	Hex Digit
1	1000 / 16	62	8	8
2	62 / 16	3	14	E
3	3 / 16	0	3	3

Reading remainders bottom to top: 1000 decimal = 3E8 hex.

Why Hex Became the Standard in Computing

The hexadecimal notation used today (digits 0-9 plus letters A-F) was standardised by IBM in 1963 and became the de facto convention by 1966 through the Fortran IV manual for the IBM System/360 (Wikipedia). Before that, some systems used alternative notations - the Bendix G-15 computer used 0-9 and u-z back in 1956.

Hex won out for a practical reason: modern computers organise data in bytes (8 bits), and one byte maps perfectly to two hex digits. A 32-bit memory address fits in 8 hex digits (like 0x7FFE1234), while the same address in binary would be 32 characters long. Octal (base 8) was popular on older systems with 12-bit or 36-bit word sizes, but since most modern architectures use word sizes that are multiples of 4 bits, hex is a natural fit.

Hex also has a simple relationship with binary: to convert, just group the binary digits into sets of four from the right and translate each group independently. Converting 1101 1010 in binary gives DA in hex - no arithmetic needed, just a lookup. This is why debuggers, hex editors, and memory dump tools all default to hexadecimal.

Where Hex Is Used

Context	Example	Why Hex
CSS colour codes	#FF5733	Two hex digits per colour channel (0-255 maps to 00-FF)
Memory addresses	0x7FFE1234	Compact representation of 32 or 64-bit binary addresses
MAC addresses	A1:B2:C3:D4:E5:F6	6 bytes as 12 hex characters
Unicode code points	U+1F600 (grinning face emoji)	Standard notation for character encoding
Error codes	0x80070005 (Access Denied)	Windows HRESULT codes are hex by convention
File magic bytes	89 50 4E 47 (PNG header)	Binary file signatures displayed as hex
IPv6 addresses	2001:0db8::1	128 bits as 8 groups of 4 hex digits

In web development, hex is everywhere. CSS colour codes like #FF5733 encode red, green, and blue channels as three pairs of hex digits - FF for 255 red, 57 for 87 green, and 33 for 51 blue. The Colour Converter can translate between HEX, RGB, HSL, and other formats if you need to work with colours directly.

Network protocols rely heavily on hex too. MAC addresses use 6 bytes written as 12 hex characters (separated by colons or hyphens). IPv6 addresses represent 128 bits as eight groups of four hex digits. Even the file sitting on your disk identifies itself with hex magic bytes at the start - a PNG image always begins with 89 50 4E 47 0D 0A 1A 0A, and a PDF starts with 25 50 44 46 (the ASCII hex for "%PDF").

Common Hex Values Worth Knowing

Hex	Decimal	Significance
0x00	0	Null byte - string terminator in C
0xFF	255	Maximum value of a single byte (8 bits)
0xFFFF	65,535	Maximum value of a 16-bit unsigned integer
0x7FFFFFFF	2,147,483,647	Maximum 32-bit signed integer (INT_MAX)
0xFFFFFFFF	4,294,967,295	Maximum 32-bit unsigned integer (UINT_MAX)
0x1FFFFFFFFFFFFF	9,007,199,254,740,991	JavaScript Number.MAX_SAFE_INTEGER (2^53 - 1)
0x20	32	ASCII space character
0x41	65	ASCII uppercase 'A'
0x61	97	ASCII lowercase 'a'
0x30	48	ASCII digit '0'

The byte boundaries are the ones you will hit most often. 0xFF (255) is the largest value a single byte can hold, which is why RGB colour channels max out at 255. 0x7FFFFFFF (about 2.1 billion) is the classic INT_MAX in 32-bit signed systems - go one higher and you wrap into negative numbers in languages like C or Java. In JavaScript, the safe integer limit is 0x1FFFFFFFFFFFFF (roughly 9 quadrillion), beyond which standard Number loses precision. This tool uses BigInt internally, so it handles values well past that limit.

Hex and ASCII Characters

The ASCII standard (defined by ANSI X3.4-1986) assigns each character a number from 0 to 127, and those numbers are commonly written in hex. Printable characters span from 0x20 (space) to 0x7E (tilde). The uppercase letters A-Z sit at 0x41 through 0x5A, lowercase a-z at 0x61 through 0x7A, and digits 0-9 at 0x30 through 0x39. One handy pattern: the difference between uppercase and lowercase is always 0x20 (32 decimal), so toggling bit 5 flips the case of any letter.

Character Range	Hex Range	Decimal Range	Count
Control characters	0x00 - 0x1F	0 - 31	32
Space and punctuation	0x20 - 0x2F	32 - 47	16
Digits 0-9	0x30 - 0x39	48 - 57	10
Uppercase A-Z	0x41 - 0x5A	65 - 90	26
Lowercase a-z	0x61 - 0x7A	97 - 122	26
DEL	0x7F	127	1

For a full interactive reference, the ASCII Table tool shows every character with its decimal, hex, binary, and octal values.

Hex in Colour Codes

Hex Code	R	G	B	Colour
#FF0000	255	0	0	Red
#00FF00	0	255	0	Green
#0000FF	0	0	255	Blue
#FFFFFF	255	255	255	White
#000000	0	0	0	Black
#808080	128	128	128	Medium grey

Each pair of hex digits in a CSS colour code represents one colour channel (red, green, blue), with 00 being none and FF being full intensity. CSS also supports shorthand hex - #F00 expands to #FF0000, and 8-digit hex codes like #FF573380 add an alpha (transparency) channel as the last two digits. The Colour Converter translates between HEX, RGB, HSL, and more formats.

Common Mistakes When Working with Hex

Forgetting that hex is case-insensitive trips people up occasionally. 0xFF, 0xff, and 0xFf all mean the same thing - 255 decimal. Most style guides prefer uppercase (FF) for data and colour codes, but language conventions vary. Python uses lowercase (0xff), while CSS historically uses uppercase (#FF5733).

Another common mistake is confusing the 0x prefix with the value itself. The "0x" is just a notation convention used in programming languages like C, Java, JavaScript, and Python to indicate that the following characters are hexadecimal. The actual value is only the part after the prefix - 0xFF and FF represent the same number.

Precision is a real pitfall when converting large hex values in JavaScript. The standard Number type only safely handles integers up to 2^53 - 1 (hex 0x1FFFFFFFFFFFFF). Anything larger, like a 64-bit memory address, will silently lose precision if you use parseInt(). The correct approach for large values is BigInt, which is what this tool uses internally.

Negative numbers also cause confusion. Hex itself has no sign, but signed integer representations use two's complement. In a 32-bit signed system, 0xFFFFFFFF is not 4,294,967,295 - it is -1. Whether a hex value is treated as signed or unsigned depends on the programming context and the data type being used.

For binary-specific work with bit visualisation, the Binary to Decimal Converter focuses on that use case. For converting between any base from 2 to 36, the Number Base Converter handles all bases simultaneously. All conversions run in your browser with no data sent to any server.

Sources

• MDN - BigInt (arbitrary-precision integers in JavaScript)
• MDN - Number.MAX_SAFE_INTEGER
• Unicode Consortium - Code Charts
• IETF RFC 4291 - IPv6 Addressing Architecture
• MDN - CSS hex color notation
• IETF RFC 20 - ASCII format for network interchange