Decimal ↔ Hex Converter

Numerical systems provide structured ways to express numbers using sets of symbols and positional weighting rules. In daily human society, we use the decimal system, whereas low-level computing architectures frequently utilize the hexadecimal system.

Understanding hexadecimal place values requires evaluating powers of 16 ($16^n$). The rightmost hexadecimal digit always represents $16^0 = 1$. Moving one position to the left multiplies the positional weight value by 16.

Converting a base-10 decimal number to base-16 hexadecimal is performed using the successive division by 16 method.

To convert a base-16 hexadecimal number back to base-10 decimal, apply the positional expansion method.

The table below shows all 16 hexadecimal symbols alongside their base-10 decimal equivalents and 4-bit binary nibble representations:

In computer science and digital electronics, hexadecimal is invaluable because one hexadecimal digit represents exactly four binary bits (one nibble) ($2^4 = 16$).

Raw binary strings are long and cumbersome for human engineers to read or transcribe without making mistakes. Hexadecimal provides a direct, perfectly aligned 4-to-1 compression of binary data:

Common contexts where hexadecimal representation is essential include:

• Byte Values & Machine Code: Expressing 8-bit bytes concisely as two hex characters (e.g. 0x00 to 0xFF).
• Memory & Debugging Output: Inspecting RAM pointers, stack traces, and core dumps (e.g. 0x7FFF5FBFF000).
• Low-Level Bit Fields & Flags: Configuring hardware registers using explicit bit masks (e.g. 0x80 for MSB flag).
• Network Packet Traces: Examining raw Ethernet headers, IP payloads, and MAC addresses in Wireshark.
• Binary Data Files & Hex Editors: Viewing compiled binaries, executable file headers (e.g. 0x4D5A for PE headers), and disk sectors.

Digital computer memory is structured around fundamental units of binary information. Hexadecimal maps cleanly to these structural units:

An unsigned 8-bit byte spans decimal values 0 to 255, which corresponds to hexadecimal 00 to FF.

In source code and developer documentation, hexadecimal numbers are almost always prefixed with 0x or 0X (e.g., 0xFF, 0x1A, 0x100).

The 0x prefix stems from the C programming language and is now standard across C++, Java, JavaScript, Python, Rust, Go, and C#.

Hexadecimal representation is case-insensitive for the digits A–F. Uppercase and lowercase letters represent identical numerical quantities:

Developers choose between uppercase or lowercase formatting depending on project conventions or language standards (e.g. CSS colors often use uppercase #FF0000 or lowercase #ff0000, while C formatting uses %X vs %x). ToolMono provides a live Letter Case toggle button to instantly switch output between UPPERCASE and lowercase.

In mathematical terms, F and 0F both represent the exact same decimal value: 15₁₀. However, in software engineering, leading zeros define fixed-width field representation.

Fixed-width zero padding ensures consistent visual width when displaying memory dumps, CPU register contents, fixed protocol fields, and checksums.

Below is a reference lookup table for common decimal integers and their corresponding hexadecimal values across standard 8-bit byte widths:

To verify a hexadecimal conversion result manually without a calculator, perform polynomial expansion:

The table below illustrates how the three primary computer number systems relate to each other:

Need to convert base-2 binary strings directly? Check our companion Binary ↔ Decimal Converter.

A hexadecimal bit pattern can represent different values depending on whether it is treated as an unsigned integer or as a signed fixed-width Two's Complement integer.

Hexadecimal literals are used extensively in programming for bit masking, flag evaluation, byte array initialization, and memory inspection.

const dec = 255;
const hex = dec.toString(16).toUpperCase(); // 'FF'
const hexWithPrefix = '0x' + hex; // '0xFF'

const hex = '0xFF';
const dec = parseInt(hex, 16); // 255
const bigDec = BigInt('0xFF'); // 255n

dec_val = 255
hex_val = hex(dec_val) # '0xff'
hex_upper = hex(dec_val)[2:].upper() # 'FF'

hex_str = '0xFF'
dec_val = int(hex_str, 16) # 255

int dec = 255;
String hex = Integer.toHexString(dec).toUpperCase(); // "FF"

String hex = "FF";
int dec = Integer.parseInt(hex, 16); // 255

package main
import "fmt"

func main() {
    dec := 255
    hex := fmt.Sprintf("%X", dec) // "FF"
}

package main
import ("fmt"; "strconv")

func main() {
    dec, _ := strconv.ParseInt("FF", 16, 64) // 255
}

#include <stdio.h>

int main() {
    int dec = 255;
    printf("%X\n", dec); // FF
    return 0;
}

#include <stdio.h>

int main() {
    int dec;
    sscanf("FF", "%x", &dec); // 255
    return 0;
}

let dec = 255;
let hex = format!("{:X}", dec); // "FF"

let hex = "FF";
let dec = i64::from_str_radix(hex, 16).unwrap(); // 255

int dec = 255;
string hex = dec.ToString("X"); // "FF"

string hex = "FF";
int dec = Convert.ToInt32(hex, 16); // 255

$dec = 255;
$hex = strtoupper(dechex($dec)); // 'FF'

$hex = 'FF';
$dec = hexdec($hex); // 255

let dec = 255
let hex = String(dec, radix: 16, uppercase: true) // "FF"

let hex = "FF"
let dec = Int(hex, radix: 16) // 255

val dec = 255
val hex = dec.toString(16).uppercase() // "FF"

val hex = "FF"
val dec = hex.toInt(16) // 255

-- PostgreSQL
SELECT to_hex(255); -- 'ff'
-- MySQL
SELECT HEX(255); -- 'FF'

-- PostgreSQL
SELECT ('x' || lpad('FF', 8, '0'))::bit(32)::int; -- 255
-- MySQL
SELECT CONV('FF', 16, 10); -- 255