User Rating 0.0 ★★★★★

Total Usage 0 times

Category Code Utilities

Enter Binary Value Only 0 and 1 allowed. Max 64 bits per value. One value per line for batch mode.

Bit Padding

Bit Grouping

Enter a binary or Gray code value above and press Convert.

Is this tool helpful?

Your feedback helps us improve.

★ ★ ★ ★ ★

About

Gray code (reflected binary code) changes only one bit between successive values. This property eliminates transition glitches in rotary encoders, ADCs, and Karnaugh maps where multiple simultaneous bit flips cause spurious intermediate states. A standard binary counter transitioning from 0111 to 1000 flips all four bits. If hardware latches read mid-transition, the sampled value could be any of 16 states. Gray code guarantees exactly one bit changes per step, removing that race condition entirely.

This converter implements the canonical XOR algorithm: the Gray code bit g_i equals b_i ⊕ b_i−1 for each position after the MSB. It handles arbitrary bit widths up to 64 bits. Note: this tool works with unsigned integers only. Gray code has no inherent sign representation, so negative values require a separate encoding convention such as offset binary before conversion.

Formulas

Binary to Gray code conversion operates bitwise. The most significant bit (MSB) of the Gray code equals the MSB of the binary input. Every subsequent Gray bit is derived by XOR of the current binary bit with its left neighbor.

g₀ = b₀

g_i = b_i−1 ⊕ b_i for i = 1, 2, …, n−1

The reverse (Gray to Binary) reconstructs each binary bit by XOR of the Gray bit with the previously decoded binary bit:

b₀ = g₀

b_i = b_i−1 ⊕ g_i for i = 1, 2, …, n−1

Where b_i is the i-th binary bit (index 0 = MSB), g_i is the i-th Gray code bit, ⊕ denotes exclusive OR (XOR), and n is the total bit count. The Hamming distance between any two consecutive Gray code values is always exactly 1.

Reference Data

Decimal	Binary	Gray Code	Hamming Distance
0	0000	0000	0
1	0001	0001	1
2	0010	0011	1
3	0011	0010	1
4	0100	0110	1
5	0101	0111	1
6	0110	0101	1
7	0111	0100	1
8	1000	1100	1
9	1001	1101	1
10	1010	1111	1
11	1011	1110	1
12	1100	1010	1
13	1101	1011	1
14	1110	1001	1
15	1111	1000	1
16	10000	11000	1
17	10001	11001	1
18	10010	11011	1
19	10011	11010	1
20	10100	11110	1
21	10101	11111	1
22	10110	11101	1
23	10111	11100	1
24	11000	10100	1
25	11001	10101	1
26	11010	10111	1
27	11011	10110	1
28	11100	10010	1
29	11101	10011	1
30	11110	10001	1
31	11111	10000	1

Frequently Asked Questions

Gray code is constructed by reflecting the sequence at each bit-width expansion. For n bits, you take the (n−1)-bit Gray sequence, duplicate it in reverse, prepend 0 to the first half and 1 to the second. The mirror point has identical suffixes, so only the new prefix bit differs. This reflection property propagates recursively from the 1-bit base case (0, 1), guaranteeing Hamming distance of exactly 1 at every boundary.

In a standard binary counter, transitioning from 0111 to 1000 requires all four bits to flip simultaneously. Physical switches or sensor tracks never toggle at exactly the same instant. During the transition window, the encoder may read intermediate garbage values like 0000 or 1111. Gray code's single-bit-change property means the reading is either the old valid value or the new valid value. No intermediate spurious states exist.

Yes. Leading zeros are preserved and participate in the XOR chain. However, since the MSB is 0 and XOR with 0 produces the same bit, leading zeros in binary map to leading zeros in Gray code. The converted value is numerically identical whether you input 0011 or 11. Padding matters only for display alignment and when interfacing with fixed-width hardware registers.

Karnaugh maps arrange variable combinations so that adjacent cells differ by exactly one variable. This is the Gray code ordering applied to both row and column headers. The adjacency ensures that any rectangle of 1-cells on the map corresponds to a product term where the differing variables can be eliminated. Without Gray code ordering, visually adjacent cells might differ in multiple variables, breaking the graphical minimization method.

The formula g_i = b_i−1 ⊕ b_i is purely bitwise and has no dependency on total width. It works for any positive integer bit length. This tool supports up to 64 bits. Beyond that, the conversion logic remains valid, but JavaScript's native bitwise operators work on 32-bit integers, so this implementation uses string-level XOR to avoid truncation.

For values that fit in a 32-bit integer, the entire conversion is G = B ⊕ (B >> 1), where >> is a right shift. This tool implements string-based XOR to support up to 64 bits, but for hardware or embedded systems, the shift-and-XOR single instruction is the standard approach.