Gray Code to Hex Converter — Reflected Binary to Hexadecimal

What is Gray code to hex conversion?

Gray code to hex conversion is the process of translating a value encoded in reflected binary code (Gray code) into hexadecimal. Gray code is a binary encoding where any two consecutive values differ by exactly one bit — a property that eliminates ambiguous readings when mechanical or optical sensors change position. Hexadecimal is a base-16 representation that packs four binary bits into a single character, making it far more compact than raw binary.

Because Gray code and hexadecimal are not directly related — you cannot map a Gray bit pattern to hex without going through binary — the conversion is always a two-step process. First the Gray code is decoded to natural binary using a chain of XOR operations. Then that binary value is grouped into 4-bit nibbles and each nibble is converted to its hex digit. This is why every accurate Gray-to-hex converter shows the intermediate binary step: it's not decorative, it's the actual algorithm.

This tool performs that conversion in both directions, shows every intermediate step, and handles values of any practical bit width using string-based bit manipulation rather than JavaScript number arithmetic — so nothing overflows or loses precision at 64 bits and beyond.

💡 Quick example. Gray 1110 → Binary 1011 → Hex B → Decimal 11. The binary step is where the XOR happens; the hex step is just a compact re-encoding of those 4 bits.

Gray code vs natural binary — the single-bit-change property

The reason Gray code exists is visible in the first 16 values. In natural binary, consecutive values often change multiple bits simultaneously; in Gray code, exactly one bit flips between any two adjacent values. The last two columns make this dramatic — the binary column jumps between 1 and 4 changed bits, while the Gray column is always exactly 1.

Look at the transition from 7 to 8 in natural binary: all four bits flip simultaneously (0111 → 1000). In Gray code, only one bit changes (0100 → 1100). Now imagine reading a mechanical encoder disc in the middle of that transition. In binary, a misaligned sensor could read any of 2⁴ = 16 different values. In Gray code, the worst case is reading one of the two adjacent values — never a wildly wrong one. That is the entire point of Gray code, and it is why the "Gray bits changed" column is always exactly 1.

The Gray code to hex algorithm (step by step)

There are two distinct stages. Both are deterministic and can be computed by hand, which is why Gray code still appears in engineering exams and hardware datasheets.

Stage 1: Gray code → binary

The most significant bit (MSB) of the binary value is the same as the MSB of the Gray code. Every subsequent binary bit is the XOR of the current Gray bit and the previous binary bit:

You work left to right. The first bit carries over directly. Each subsequent bit depends on the previous binary bit (not the previous Gray bit).

Stage 2: binary → hex

Group the binary value into 4-bit nibbles starting from the right (least significant bit). Pad the leftmost group with leading zeros if needed. Then replace each 4-bit nibble with its hexadecimal equivalent: 0000 = 0, 0001 = 1 … 1001 = 9, 1010 = A, 1011 = B, 1100 = C, 1101 = D, 1110 = E, 1111 = F.

Worked example — Gray 1110.

1. MSB: B₀ = G₀ = 1.
2. Next: B₁ = G₁ XOR B₀ = 1 XOR 1 = 0.
3. Next: B₂ = G₂ XOR B₁ = 1 XOR 0 = 1.
4. Last: B₃ = G₃ XOR B₂ = 0 XOR 1 = 1.
5. Binary = 1011. Group into nibbles: 1011. Convert: 1011 = B.

Result: Gray 1110 → Binary 1011 → Hex B → Decimal 11.

💡 Why this order matters. Gray→binary XORs left-to-right because each binary bit depends on the one to its left. If you XOR right-to-left you get a valid-looking but wrong result — this is the single most common mistake when converting by hand.

How to use the Gray code to hex converter

1. Choose a direction. Gray → Hex is the primary mode. Hex → Gray does the reverse. Gray → Binary/Decimal shows the intermediate binary and decimal without the hex layer — useful for verifying the XOR steps by hand.
2. Paste your value(s). Gray code must be only 0s and 1s. Spaces are stripped automatically. Enter one value per line to batch-convert.
3. Set output options. Choose uppercase or lowercase hex, an optional 0x prefix, and optional bit padding (4, 8, 16 or 32 bits). Padding affects both the display and the hex output — an 8-bit padded gray 1110 becomes hex 0B, not B.
4. Read the result. The main card shows the primary output. Below it, a bit-by-bit table shows the XOR derivation — Gray bit, previous binary bit, and the XOR that produced it — with every bit position labelled MSB-to-LSB.
5. Copy or export. Copy the hex, the binary, the decimal, or the full step-by-step breakdown from the copy menu.

Understanding the XOR derivation table

Most online Gray-code converters show only the final answer. That is enough if you just need a number, but it teaches you nothing about how the conversion works — and it gives you no way to verify the answer if you suspect an error. This tool shows every XOR step with the bit position clearly labelled:

Reading the "Result B" column top-to-bottom gives the binary result: 1011. Reading right-to-left gives 1101, which is the incorrect direction — the table makes that obvious because the "Prev B" column shows which bit you should XOR against.

⚠ XOR is not the same as addition. 1 XOR 1 = 0 (not 2). 0 XOR 0 = 0. 1 XOR 0 = 1. 0 XOR 1 = 1. Only the difference matters — this is modular addition without carry.

Gray code to hex reference table (4-bit)

The 4-bit Gray code sequence has 16 values, one for each hex digit. This table is the foundation for multi-digit conversions — a 16-bit Gray code converts by splitting into four 4-bit chunks, each mapped through this table after binary conversion. The final column shows how many bits change between consecutive values, demonstrating the single-bit-change property.

💡 Notice the pattern. The Gray code column is not the binary column with bits shuffled — it is a genuinely different encoding. Gray 0011 is decimal 2, not decimal 3. That is the whole point: consecutive Gray values differ by one bit even when the underlying binary values jump by several bits.

Full reference table — 4-bit and 8-bit, filterable

Type any value to filter, sort by any column, toggle columns on and off, switch density, page through results, and click any row to load its Gray code into the converter. Cell clicks copy the individual value. Keyboard: ↑ ↓ to move, Enter to load, Esc to clear.

Why convert Gray code to hexadecimal at all?

Gray code comes out of hardware in binary — 0s and 1s read from an encoder, a sensor, or a register. So why bother converting to hex?

• Compactness. A 16-bit Gray code value is 16 characters in binary but only 4 characters in hex. Datasheets, register dumps, and debug logs are dramatically more readable in hex.
• Alignment. Hexadecimal maps cleanly to byte boundaries. 8 bits = 2 hex digits, 16 bits = 4 hex digits. Binary does not compress this way.
• Register and memory documentation. Hardware registers are almost always documented in hex. If you read a Gray-coded position register and want to compare it against the datasheet, you need hex.
• Debugging. When you print a value in a debugger, hex is the default for many tools. Converting Gray code to hex lets you compare the raw value against what the documentation says it should be.
• Embedding in code. If you need to hard-code a Gray code value into firmware, hex is the natural literal format.

Where Gray code is actually used

Gray code is not an academic curiosity — it is embedded in the hardware you use every day:

• Rotary encoders and absolute position sensors. The classic application. A Gray-coded encoder disc ensures that only one bit changes between adjacent positions, so a mechanical misalignment cannot produce a wildly wrong reading. Position sensors in CNC machines, robotics arms, and camera gimbals rely on this.
• Analog-to-digital converters. In some ADC architectures the output is Gray-coded to prevent glitches during transition.
• Asynchronous FIFO pointers. Crossing a Gray-coded pointer between clock domains is the standard technique for avoiding metastability in asynchronous FIFOs — a pattern used in almost every modern SoC.
• Karnaugh maps. K-maps use Gray code ordering along their axes so that adjacent cells differ by one variable. This is the foundation of digital logic simplification.
• Error correction in digital communications. Gray coding reduces the effective bit-error impact in QAM and PSK modulation schemes. A single symbol error produces only one bit error in the decoded output.
• Tower of Hanoi and hypercube puzzles. The solution sequence of the Tower of Hanoi corresponds exactly to the Gray code sequence, and Gray code traces a Hamiltonian path on an n-dimensional hypercube graph.

Common mistakes when converting Gray code to hex

• Treating Gray code as if it were binary. A Gray code of 0011 is not decimal 3 — it is decimal 2. If you paste Gray code into a binary-to-hex converter, you get the wrong answer because the Gray-to-binary stage is skipped.
• XORing in the wrong direction. Gray→binary XORs left-to-right: each binary bit depends on the one to its left. Right-to-left produces a plausible-looking but incorrect result.
• Padding the wrong end. When padding Gray code to a wider bit width, you pad the left (most significant) side with zeros. Padding the right side shifts every bit position.
• Forgetting to group nibbles from the right. Hex conversion requires grouping binary into 4-bit groups starting from the LSB. If the binary length is not a multiple of 4, the leftmost group will be short — pad it with leading zeros before converting.
• Confusing 0xDEAD with a Gray code. Hex values and Gray code look similar (both use 0s and 1s plus letters A–F in the hex case), but Gray code contains only 0s and 1s. If your input has letters, it is hex, not Gray code.
• Assuming 1 XOR 1 = 1. XOR is not OR and not addition. 1 XOR 1 = 0. This is the single most common arithmetic mistake in Gray code conversion.

Privacy and data storage

Everything runs in your browser. The conversion, the XOR derivation table, the batch processing, and the reference table filter all happen locally in JavaScript. Nothing you paste is uploaded to a server. There is no account, no login, and no network request after the page has loaded — the tool works offline once the page is cached. Your input is not stored anywhere; refreshing the page clears it.

Limitations

• The converter handles reflected binary Gray code (the standard form named after Frank Gray). It does not support non-standard Gray code variants such as balanced Gray code or n-ary Gray code.
• Hexadecimal output is limited only by the size of the input. There is no 32-bit or 64-bit cap — any practical bit width converts exactly.
• Bit padding options cap at 32 bits. Inputs wider than that are converted without padding but at their natural width.
• The derivation table is hidden for inputs longer than 64 bits to keep the page responsive. The conversion still happens — only the step-by-step table is suppressed.
• Batch conversion is line-based. Nested or multi-line single values must be joined before pasting.
• The reference table covers 4-bit and 8-bit values. Larger tables would be less useful as a reference and more useful as a live conversion — which is what the tool itself does.

Frequently asked questions

Related tools on AIToolsPros