🔀 Hex to Binary Converter
Professional Hexadecimal ⇄ Binary Converter | Base-16 to Base-2 Calculator
🔢 Hex to Binary Conversion Reference (0-F)
| Hex | Binary (4-bit) | Decimal | Hex | Binary (4-bit) | Decimal |
|---|---|---|---|---|---|
| 0 | 0000 | 0 | 8 | 1000 | 8 |
| 1 | 0001 | 1 | 9 | 1001 | 9 |
| 2 | 0010 | 2 | A | 1010 | 10 |
| 3 | 0011 | 3 | B | 1011 | 11 |
| 4 | 0100 | 4 | C | 1100 | 12 |
| 5 | 0101 | 5 | D | 1101 | 13 |
| 6 | 0110 | 6 | E | 1110 | 14 |
| 7 | 0111 | 7 | F | 1111 | 15 |
📚 Complete Guide to Hex-Binary Conversion
Understanding Hexadecimal and Binary Systems
Binary (base-2) is the fundamental number system of digital computing. Uses only two digits: 0 and 1 (bits). Each position represents a power of 2: \( 2^0=1, 2^1=2, 2^2=4, 2^3=8, 2^4=16, 2^5=32, 2^6=64, 2^7=128, 2^8=256 \). Example: 1010₂ = \( 1×8 + 0×4 + 1×2 + 0×1 = 10₁₀ \). Every digital operation—processor instructions, memory storage, data transmission—ultimately reduces to binary. Electronic circuits naturally implement two states: on/off, high voltage/low voltage, magnetized/demagnetized. Why binary is challenging for humans: Long sequences difficult to read/write. Example: 8-bit byte 11010110 vs decimal 214. Error-prone: 1011 vs 1101 easily confused. 32-bit value requires 32 binary digits vs 10 decimal digits. Memory address 0x7FFFFFFF = 01111111111111111111111111111111 (32 ones, impractical). Hexadecimal (base-16) solves binary's readability problem. Uses 16 symbols: digits 0-9 (values 0-9) and letters A-F (values 10-15: A=10, B=11, C=12, D=13, E=14, F=15). Each position represents power of 16: \( 16^0=1, 16^1=16, 16^2=256, 16^3=4096 \). Example: 1A3₁₆ = \( 1×256 + 10×16 + 3×1 = 419₁₀ \). Perfect relationship between hex and binary: Each hex digit = exactly 4 binary bits (nibble). Mathematical basis: \( 16 = 2^4 \). Range: 4 bits represent 0-15 values = one hex digit 0-F. Conversion trivial: direct substitution without arithmetic. Example: F₁₆ = 1111₂ (memorize 16 patterns, instant conversion). Two hex digits = 8 bits = 1 byte (00-FF = 0-255). Hex provides 4× compression of binary (FF vs 11111111) while maintaining direct correspondence. Why computing uses hex extensively: Memory addresses compact yet binary-aligned. RGB colors (#FF5733 = red 255, green 87, blue 51). Assembly language opcodes. Memory dumps, debugging tools. MAC addresses (00:1A:2B:3C:4D:5E). IPv6 addresses. Checksums, hashes (MD5, SHA). File format signatures. CPU register contents. Byte-level data manipulation.
Hex to Binary Conversion Method
Conversion algorithm: Replace each hex digit with its 4-bit binary equivalent. Direct substitution using memorized patterns—no arithmetic required. 16 fundamental patterns to memorize: 0₁₆=0000₂, 1₁₆=0001₂, 2₁₆=0010₂, 3₁₆=0011₂, 4₁₆=0100₂, 5₁₆=0101₂, 6₁₆=0110₂, 7₁₆=0111₂, 8₁₆=1000₂, 9₁₆=1001₂, A₁₆=1010₂, B₁₆=1011₂, C₁₆=1100₂, D₁₆=1101₂, E₁₆=1110₂, F₁₆=1111₂. Memory aids: 0-7: Same binary as decimal (7₁₀=111₂=7₁₆). 8: 1000₂ (one thousand in binary = eight). 9: 1001₂ (8+1). A-F: Letters represent 10-15, binary patterns 1010-1111. Step-by-step procedure: (1) Write hex number, separate digits. (2) Replace each digit with 4-bit binary. (3) Concatenate all groups. (4) Remove leading zeros (optional). Detailed Example 1: Convert FF₁₆ to binary. Separate: F | F. Convert: F₁₆ = 1111₂ (15 decimal, all 4 bits set). F₁₆ = 1111₂. Concatenate: 1111 1111. Result: 11111111₂ (8 bits, max byte value). Verification: 11111111₂ = 128+64+32+16+8+4+2+1 = 255₁₀ = FF₁₆ ✓. Detailed Example 2: Convert 1A3₁₆ to binary. Separate: 1 | A | 3. Convert: 1₁₆ = 0001₂; A₁₆ = 1010₂ (10 decimal = 8+2 = 1010); 3₁₆ = 0011₂. Concatenate: 0001 1010 0011. Result: 000110100011₂ = 110100011₂ (drop leading zeros). Verification: \( 1×256 + 10×16 + 3 = 419₁₀ \); Binary: \( 256+128+16+2+1 = 403... \) Wait, recalculate: 110100011₂ = \( 1×2^8 + 1×2^7 + 0×2^6 + 1×2^5 + 0×2^4 + 0×2^3 + 0×2^2 + 1×2^1 + 1×2^0 = 256+128+32+2+1 = 419₁₀ \) ✓. Detailed Example 3: Convert A5₁₆ to binary. A₁₆ = 1010₂ (10 decimal). 5₁₆ = 0101₂ (5 decimal). Result: 10100101₂ (8 bits). Decimal check: 128+32+4+1 = 165₁₀ = A5₁₆ ✓. Detailed Example 4: Convert 3E8₁₆ to binary. 3₁₆=0011₂, E₁₆=1110₂, 8₁₆=1000₂. Result: 001111101000₂ = 1111101000₂. Decimal: 512+256+128+64+32+8 = 1000₁₀ = 3E8₁₆ ✓. Detailed Example 5: Convert CAFE₁₆ to binary. C=1100₂, A=1010₂, F=1111₂, E=1110₂. Result: 1100101011111110₂ (16 bits). Why this works: Hex base 16 = 2⁴, so each digit position in hex = 4 bit positions in binary. Hex digit encodes 4 binary bits perfectly—no information lost, no calculation needed. Direct mapping makes conversion trivial compared to hex↔decimal (which requires arithmetic).
Binary to Hex Conversion Method
Reverse process: Group binary into 4-bit chunks (from right), convert each to hex digit. Step-by-step procedure: (1) Write binary number. (2) Group bits into sets of 4, starting from rightmost (LSB). (3) Pad leftmost group with leading zeros if needed (make it 4 bits). (4) Convert each 4-bit group to single hex digit. (5) Concatenate hex digits. Detailed Example 1: Convert 11111111₂ to hex. Group from right: 1111 | 1111 (already aligned). Convert: 1111₂ = F₁₆; 1111₂ = F₁₆. Result: FF₁₆. Decimal check: 255₁₀ ✓. Detailed Example 2: Convert 110100011₂ to hex. Group from right: 1 | 1010 | 0011 (leftmost group needs padding). Pad: 0001 | 1010 | 0011 (add three leading zeros to make 4-bit group). Convert: 0001₂=1₁₆, 1010₂=A₁₆, 0011₂=3₁₆. Result: 1A3₁₆. Decimal: 256+160+3 = 419₁₀ ✓. Detailed Example 3: Convert 10101₂ to hex. Group: 1 | 0101 (leftmost needs padding). Pad: 0001 | 0101. Convert: 0001₂=1₁₆, 0101₂=5₁₆. Result: 15₁₆. Decimal: 16+5 = 21₁₀ ✓. Detailed Example 4: Convert 1111101000₂ to hex. Group: 11 | 1110 | 1000 (leftmost needs padding). Pad: 0011 | 1110 | 1000. Convert: 0011₂=3₁₆, 1110₂=E₁₆, 1000₂=8₁₆. Result: 3E8₁₆ (1000 decimal). Detailed Example 5: Convert 1₂ to hex. Single bit. Pad: 0001₂. Result: 1₁₆. Why group from right: Rightmost bit = LSB (least significant bit, value 2⁰=1). Grouping from right preserves positional values. Example: 10101₂ grouped wrong (from left): 1010|1 → A1₁₆? No! Must be 0001|0101 → 15₁₆. Common mistakes: Grouping from left (incorrect). Forgetting to pad leftmost group. Confusing binary 1010₂ with decimal 1010₁₀ (actually equals 10₁₀=A₁₆).
Practical Conversion Examples
Example 1: Memory address 0x7FFF to binary. Hex: 7FFF. Convert: 7₁₆=0111₂, F₁₆=1111₂, F₁₆=1111₂, F₁₆=1111₂. Result: 0111111111111111₂ (16 bits). Significance: Max positive 16-bit signed integer (32767₁₀). Example 2: RGB color #3A7BD5 to binary. Hex: 3A7BD5 (Red=3A, Green=7B, Blue=D5). 3₁₆=0011₂, A₁₆=1010₂ → Red: 00111010₂ (58₁₀). 7₁₆=0111₂, B₁₆=1011₂ → Green: 01111011₂ (123₁₀). D₁₆=1101₂, 5₁₆=0101₂ → Blue: 11010101₂ (213₁₀). Full binary: 001110100111101111010101₂ (24 bits). Example 3: MAC address 00:1A:2B to binary. 00₁₆=00000000₂, 1A₁₆=00011010₂, 2B₁₆=00101011₂. Result: 000000000001101000101011₂ (24 bits of 48-bit MAC). Example 4: Binary 10000000₂ to hex (1 bit set). Group: 1000 | 0000. Convert: 8₁₆, 0₁₆. Result: 80₁₆ (128₁₀, high bit of byte). Example 5: Hex DEADBEEF to binary (common debug value). D=1101₂, E=1110₂, A=1010₂, D=1101₂, B=1011₂, E=1110₂, E=1110₂, F=1111₂. Result: 11011110101011011011111011101111₂ (32 bits). Decimal: 3,735,928,559₁₀. Example 6: Binary subnet mask 11111111111111111111111100000000₂ to hex. Group: 1111|1111|1111|1111|1111|1111|0000|0000. Convert: F|F|F|F|F|F|0|0. Result: FFFFFF00₁₆ (255.255.255.0 subnet mask, /24 network).
Application-Specific Conversions
Assembly Language and Machine Code: CPU instructions encoded as binary, displayed as hex. x86 instruction: MOV AL, 42h = B0 42 (hex) = 10110000 01000010 (binary). B0₁₆ opcode = 10110000₂ (MOV immediate to AL register). 42₁₆ operand = 01000010₂ (immediate value 66₁₀). Programmers read hex, CPU executes binary. Bit Manipulation and Flags: Status register: 0x8F = 10001111₂. Each bit = flag: Bit 7 (leftmost): 1 = Negative. Bit 6: 0 = Clear. Bit 3: 1 = Interrupt enabled. Bits 0-3: 1111 = condition codes. Setting bit 5: 8F₁₆ | 20₁₆ = AF₁₆ (10001111 OR 00100000 = 10101111). Network Packet Analysis: TCP flags byte: 0x18 = 00011000₂. Bit 4: ACK=1. Bit 3: PSH=1. Other flags=0. Hex compact for documentation, binary for bit-level analysis. Permissions and Access Control: Unix file mode: 0x1ED = 755₈ = 111101101₂. Owner: 111₂=rwx. Group: 101₂=r-x. Others: 101₂=r-x. Binary shows exact permission bits. Color Depth and Graphics: 16-bit RGB565: 0xF800 = 1111100000000000₂. Red (5 bits): 11111₂=31₁₀=max red. Green (6 bits): 000000₂=0₁₀=no green. Blue (5 bits): 00000₂=0₁₀=no blue. Result: Pure red in 16-bit color. Cryptography and Hashing: MD5 hash output: 32 hex digits = 128 bits. Example: 5D41402ABC4B2A76B9719D911017C592 (hex) = 128 binary bits. Each hex digit = 4 bits of hash output. SHA-256: 64 hex digits = 256 bits.
Why Choose RevisionTown's Hex-Binary Converter?
RevisionTown's professional converter provides: (1) Bidirectional Conversion—Convert hex→binary and binary→hex seamlessly with instant results; (2) Step-by-Step Breakdown—Shows conversion process digit-by-digit with 4-bit grouping visualization; (3) Flexible Output Options—Choose uppercase/lowercase hex, optional 0x prefix for programming contexts; (4) Large Number Support—Handles values up to JavaScript safe integer limit (53 bits) for comprehensive applications; (5) Input Validation—Automatically detects invalid characters (non-hex, non-binary), provides clear error messages; (6) Automatic Padding—Binary-to-hex conversion automatically pads leftmost group to 4 bits; (7) Copy to Clipboard—One-click copy for immediate use in code, documentation, or other tools; (8) Comprehensive Reference Table—Quick lookup for all 16 hex-binary mappings (0-F to 0000-1111); (9) Mobile Optimized—Responsive design works perfectly on smartphones, tablets, and desktops; (10) Zero Cost—Completely free with no ads, registration, or limitations; (11) Professional Accuracy—Trusted by computer science students, programmers, embedded systems engineers, network engineers, reverse engineers, security researchers, and IT professionals worldwide for programming (converting hex constants to binary for bit manipulation 0xFF=11111111), debugging (analyzing memory dumps, register values in binary), digital electronics (converting hex to binary for circuit design, FPGA programming), network analysis (packet header fields between hex and binary), assembly language (understanding machine code opcodes in binary), computer architecture education (demonstrating hex-binary relationship in coursework), reverse engineering (analyzing executables, firmware at bit level), cryptography (examining hash outputs, encryption keys in binary), embedded systems (register configuration, GPIO pins using binary from hex), game development (graphics programming, color values in binary), cybersecurity (analyzing malware, shellcode in binary format), hardware design (Verilog/VHDL hex literals to binary), protocol implementation (binary field manipulation from hex specifications), and all applications requiring accurate hex-binary conversions with professional-grade tools for software development, computer engineering, digital forensics, and comprehensive computing education worldwide.
❓ Frequently Asked Questions
Replace each hex digit with its 4-bit binary equivalent. No calculation needed—direct substitution. Memorize 16 patterns: 0=0000, 1=0001, 2=0010, 3=0011, 4=0100, 5=0101, 6=0110, 7=0111, 8=1000, 9=1001, A=1010, B=1011, C=1100, D=1101, E=1110, F=1111. Example: FF₁₆ to binary. F=1111, F=1111. Result: 11111111₂ (8 bits). Example: 1A3₁₆ to binary. 1=0001, A=1010, 3=0011. Result: 000110100011₂ = 110100011₂ (drop leading zeros). Steps: (1) Separate hex into individual digits. (2) Replace each with 4-bit binary. (3) Concatenate all groups. (4) Optionally remove leading zeros. Why this works: Each hex digit (base-16) = exactly 4 binary bits (base-2) because 16 = 2⁴. Direct 1-to-1 mapping, no arithmetic. Quick patterns: 0-7 same as decimal binary. 8=1000 (high bit set). F=1111 (all bits set). A=1010, C=1100 (memorize letters).
One hexadecimal digit = exactly 4 binary bits (half a byte, called nibble). Mathematical reason: 16 = 2⁴, so base-16 digit represents 4 base-2 digits. Range: 4 bits represent 0-15 decimal = 0-F hex = 0000-1111 binary. Examples: 0₁₆ = 0000₂ (4 bits, all zero). F₁₆ = 1111₂ (4 bits, all one). A₁₆ = 1010₂ (4 bits). 5₁₆ = 0101₂ (4 bits with leading zero). Practical implications: (1) Byte representation: 8 bits (1 byte) = 2 hex digits. Example: FF₁₆ = 11111111₂ (8 bits). 00-FF hex = 0-255 decimal = 00000000-11111111 binary. (2) Word sizes: 16-bit word = 4 hex digits (FFFF₁₆ = 16 bits). 32-bit = 8 hex digits. 64-bit = 16 hex digits. (3) Memory addresses: 32-bit address 0x7FFFFFFF = 8 hex digits = 32 bits. Much shorter than writing 32 binary digits. Calculation: n hex digits = 4n binary bits. Hex A5₁₆ (2 digits) = 8 bits (10100101₂). Hex 3E8₁₆ (3 digits) = 12 bits (001111101000₂).
Group binary into 4-bit chunks from right, convert each group to hex digit. Steps: (1) Write binary number. (2) Starting from rightmost bit (LSB), group into sets of 4. (3) If leftmost group has fewer than 4 bits, pad with leading zeros. (4) Convert each 4-bit group to single hex digit. (5) Concatenate results. Example: 11111111₂ to hex. Group: 1111|1111 (already 4-bit aligned). Convert: 1111₂=F₁₆, 1111₂=F₁₆. Result: FF₁₆. Example: 110100011₂ to hex. Group from right: 1|1010|0011 (leftmost=1 bit). Pad leftmost: 0001|1010|0011 (add three 0s). Convert: 0001₂=1₁₆, 1010₂=A₁₆, 0011₂=3₁₆. Result: 1A3₁₆. Example: 10101₂ to hex. Group: 1|0101. Pad: 0001|0101. Convert: 1₁₆, 5₁₆. Result: 15₁₆. Why group from right: Preserves positional values (LSB=rightmost). Grouping from left would misalign bit positions. Verification: Convert result back: 15₁₆ → 00010101₂ = 10101₂ ✓.
FF₁₆ = 255₁₀ (decimal) = 11111111₂ (binary) = maximum 8-bit value (1 byte). Breakdown: F₁₆ = 15₁₀. Two F's: First F (left) = 15 × 16¹ = 15 × 16 = 240. Second F (right) = 15 × 16⁰ = 15 × 1 = 15. Total: 240 + 15 = 255₁₀. Binary representation: F₁₆ = 1111₂ (4 bits, all set to 1). FF₁₆ = 1111 1111₂ (8 bits, all set to 1). Significance: All 8 bits enabled = 2⁸-1 = 256-1 = 255. Common uses: (1) Color values: RGB white = #FFFFFF (red=FF, green=FF, blue=FF, all max). Pure red = #FF0000. (2) Byte values: Maximum unsigned byte (0-255 range). Bit mask: 0xFF = all bits in byte. (3) Memory: Uninitialized memory often shows FF pattern. (4) Networking: Broadcast MAC address: FF:FF:FF:FF:FF:FF. Related values: 00₁₆=0₁₀=00000000₂ (min byte). 7F₁₆=127₁₀=01111111₂ (max signed byte). 80₁₆=128₁₀=10000000₂ (high bit set). FF₁₆=255₁₀=11111111₂ (max unsigned byte).
Hexadecimal provides 4× more compact representation than binary while maintaining direct correspondence. Reasons for hex: (1) Readability: Binary: 11010110₂ (8 digits, hard to parse). Hex: D6₁₆ (2 digits, easy to read/remember). 32-bit value: Binary needs 32 digits; hex needs 8. (2) Error prevention: Binary strings look similar: 1011 vs 1101 easily confused. Hex digits more distinct: B vs D. (3) Direct binary mapping: Each hex digit = exactly 4 bits. Conversion trivial (memorize 16 patterns). Example: F₁₆ = 1111₂ instantly, no calculation. (4) Byte alignment: 1 byte = 8 bits = 2 hex digits (00-FF). Perfect for representing bytes compactly. Example: Memory dump shows 48 65 6C 6C 6F (hex) vs 01001000 01100101 01101100 01101100 01101111 (binary, unreadable). (5) Industry standards: Memory addresses: 0x7FFFFFFF (hex) not 01111111... RGB colors: #FF5733 (hex) standard. MAC addresses: 00:1A:2B (hex format). Why not octal?: Octal (base-8) = 3 bits per digit. Doesn't align with 8-bit bytes (8 not divisible by 3). Hex cleaner for modern computing. Summary: Hex perfect middle ground—compact like decimal, binary-aligned unlike decimal, readable unlike binary.
Learn 16 patterns using systematic approach and memory techniques. Pattern 1: Digits 0-7 (same as decimal): 0₁₆=0000₂, 1₁₆=0001₂, 2₁₆=0010₂, 3₁₆=0011₂, 4₁₆=0100₂, 5₁₆=0101₂, 6₁₆=0110₂, 7₁₆=0111₂. These match decimal-to-binary (0-7₁₀ = same binary). Pattern 2: High bit set (8-15): 8₁₆=1000₂ (leftmost bit=1, others=0). 9₁₆=1001₂ (8+1). A₁₆=1010₂ (10=8+2). B₁₆=1011₂ (11=8+2+1). C₁₆=1100₂ (12=8+4). D₁₆=1101₂ (13=8+4+1). E₁₆=1110₂ (14=8+4+2). F₁₆=1111₂ (15=all bits set). Memory techniques: (1) Binary counting: Count 0-15 in binary: 0000, 0001, 0010, 0011... This teaches patterns. (2) Powers of 2: Recognize 8=1000 (2³), 4=0100 (2²), 2=0010 (2¹), 1=0001 (2⁰). (3) Symmetry: 0 and F are extremes (0000, 1111). 5 and A both end 0 (0101, 1010). (4) Flashcards: Create 16 cards (hex on front, binary on back). Daily practice. (5) Chunking: Remember by position: Bits: [8][4][2][1]. Example: B=11 decimal = 8+2+1 = 1011₂ (positions 8,2,1 set). Practice exercises: Convert random hex (2A, C5, 7F) to binary. Check with calculator. Reverse: binary to hex (1101, 0110, 1111). Common patterns: All 1s = F. All 0s = 0. High bit only = 8. Alternating = 5 or A.
0x is prefix indicating hexadecimal number in programming languages (C, C++, Java, JavaScript, Python, etc.). Convention from C language, now universal standard. Why needed: Distinguishes hex from decimal. 10 = ten (decimal) vs 0x10 = sixteen (hex). FF ambiguous alone, but 0xFF clearly hex (255 decimal). Examples: 0xFF = 255₁₀ = 11111111₂. 0x1A3 = 419₁₀ = 110100011₂. 0x00 = 0₁₀ = 0₂. 0xDEADBEEF = 3,735,928,559₁₀ (common debug value). Code usage: C: int value = 0xFF; // 255. JavaScript: const color = 0x3A7BD5; // RGB color. Python: num = 0xFF # 255. Assembly: MOV AX, 0x1234. Related prefixes: 0b = binary (0b1010 = 10₁₀). 0o or 0 = octal (0o12 = 10₁₀; leading 0 deprecated). No prefix = decimal (255 = decimal 255). Output formatting: C: printf("0x%X", 255) outputs "0xFF". JavaScript: (255).toString(16) outputs "ff" (add "0x" manually). Python: hex(255) outputs "0xff". Case sensitivity: 0xFF = 0xff (same value, uppercase convention preferred). 0X1A3 valid but 0x1a3 more common. Binary conversion: 0xFF → binary: Remove 0x, convert FF: 1111 1111₂. Programmer sees 0xFF, CPU executes 11111111₂.
Same method as small numbers—replace each hex digit with 4 bits, regardless of size. Hex-to-binary conversion scales perfectly because it's digit-by-digit substitution, not arithmetic. Example: DEADBEEF₁₆ to binary (32-bit value). D=1101₂, E=1110₂, A=1010₂, D=1101₂, B=1011₂, E=1110₂, E=1110₂, F=1111₂. Result: 11011110 10101101 10111110 11101111₂ (32 bits, spaces for readability). Decimal: 3,735,928,559₁₀. Example: FFFFFFFFFFFFFFFF₁₆ (16 F's, 64-bit max). Each F=1111₂. Result: 64 consecutive 1-bits. Decimal: 18,446,744,073,709,551,615₁₀ (max 64-bit unsigned). Tips for large numbers: (1) Work left-to-right: Convert each hex digit to 4 bits sequentially. (2) Use spacing: Group binary output by 8 bits (bytes) for readability. Example: CAFE₁₆ = 11001010 11111110₂. (3) Verify digit count: n hex digits → 4n binary bits. 8 hex digits = 32 bits (DWORD). 16 hex = 64 bits (QWORD). (4) Leading zeros matter: 0001₁₆ = 0000000000000001₂ (16 bits with leading zeros preserved). (5) Use tools: For massive values (128-bit, 256-bit), calculators prevent manual errors. Real-world examples: IPv6 address: 2001:0db8:85a3:0000:0000:8a2e:0370:7334 (eight 16-bit hex groups = 128 bits total). SHA-256 hash: 64 hex digits = 256 binary bits. UUID: 32 hex digits (with hyphens) = 128 bits.
