About

A single bit flip in memory can corrupt a byte, change a character, or crash a system. This tool renders each character of your input as an 8-bit binary word and lets you toggle any bit position from b₇ (MSB, weight 128) down to b₀ (LSB, weight 1). The flipped codepoint is computed via XOR: c′ = c ⊕ 2^k, where k is the toggled bit index. Flipping bit 5 of an uppercase ASCII letter converts it to lowercase and vice versa - a property exploited in case-insensitive comparison optimizations. Flipping bit 6 of a digit character produces a control code, which can break parsers and protocols that assume clean input.

This tool operates strictly within the 7-bit ASCII range (0 - 127). Flipped values exceeding this range are displayed with their codepoint but may not render as printable glyphs. The tool approximates real hardware bit errors; actual memory corruption involves ECC detection, Hamming distance analysis, and parity checks not modeled here. Use it to study encoding vulnerabilities, understand XOR masking, or demonstrate why single-bit errors matter in serial protocols like UART where no parity bit is configured.

Formulas

Each ASCII character is represented by a 7-bit codepoint stored in an 8-bit byte. The decimal value of a byte is the weighted sum of its bits:

c = 7∑i=0 b_i ⋅ 2ⁱ

where b_i ∈ {0, 1} is the value of the i-th bit.

Flipping bit k is performed using a bitwise XOR with a mask containing a single set bit at position k:

c′ = c ⊕ 2^k

where c is the original codepoint, c′ is the flipped codepoint, ⊕ denotes bitwise XOR, and k is the zero-indexed bit position (0 = LSB, 7 = MSB).

The Hamming distance between original and flipped strings equals the total number of toggled bits:

d_H(S, S′) = n∑j=1 popcount(c_j ⊕ c_j′)

where popcount counts the number of set bits in the XOR result, and n is the string length. For ASCII case conversion, the relationship exploits the fact that uppercase letters (65 - 90) and lowercase letters (97 - 122) differ only in bit 5 (weight 32): c_lower = c_upper ⊕ 32.

Reference Data

Char	Dec	Hex	Binary	Category	Bit 5 Flip	Bit 6 Flip
A	65	0x41	01000001	Uppercase	a (97)	! (33)
a	97	0x61	01100001	Lowercase	A (65)	! (33)
0	48	0x30	00110000	Digit	P (80)	p (112)
9	57	0x39	00111001	Digit	Y (89)	y (121)
Z	90	0x5A	01011010	Uppercase	z (122)	: (58)
z	122	0x7A	01111010	Lowercase	Z (90)	: (58)
&space&	32	0x20	00100000	Whitespace	@ (64)	NUL (0)
!	33	0x21	00100001	Punctuation	A (65)	SOH (1)
@	64	0x40	01000000	Symbol	` (96)	NUL (0)
~	126	0x7E	01111110	Symbol	^ (94)	> (62)
/	47	0x2F	00101111	Symbol	O (79)	o (111)
\n	10	0x0A	00001010	Control	* (42)	J (74)
\r	13	0x0D	00001101	Control	- (45)	M (77)
\t	9	0x09	00001001	Control	) (41)	I (73)
DEL	127	0x7F	01111111	Control	? (63)	> (62)
NUL	0	0x00	00000000	Control	&space& (32)	@ (64)

Frequently Asked Questions

Uppercase letters A - Z occupy codepoints 65-90 and lowercase a - z occupy 97-122. The difference is exactly 32, which is 2⁵. In binary, these ranges differ only at bit position 5. XOR-ing any uppercase letter's codepoint with 32 sets bit 5 to 1, producing the lowercase equivalent. XOR-ing a lowercase letter with 32 clears bit 5, producing uppercase. This design was intentional in the ASCII standard to simplify case conversion in hardware.

Codepoints 0-31 are control characters (NUL, SOH, STX, ETX, etc.) and codepoint 127 is DEL. These are non-printable. The tool displays their standard abbreviation (e.g., NUL, BEL, ESC) instead of attempting to render an invisible or terminal-disrupting character. If a flipped value exceeds 127, it falls outside 7-bit ASCII entirely and is shown as its decimal codepoint with a warning indicator.

In UART serial communication without parity, a single bit flip in a transmitted byte goes undetected and corrupts the received character. For example, transmitting "H" (0x48) with bit 0 flipped yields "I" (0x49) - a valid character that causes silent data corruption. Protocols like CRC-16 and Hamming(7,4) ECC add redundancy to detect or correct such errors. This tool lets you visualize exactly which character results from any given single-bit or multi-bit error pattern.

Yes. Each bit cell is independently toggleable. Flipping bits k₁ and k₂ simultaneously is equivalent to XOR-ing the codepoint with (2^k₁ + 2^k₂). The resulting character updates in real time. The Hamming distance counter at the bottom tracks the total number of flipped bits across all characters.

Standard ASCII is a 7-bit encoding covering codepoints 0-127. The 8th bit (bit 7, weight 128) is always 0. Extended ASCII (ISO 8859-1, Windows-1252) and UTF-8 use bit 7 to signal multi-byte sequences or extended characters. Flipping bit 7 of a standard ASCII character produces a value in the 128-255 range, which this tool flags as outside the 7-bit ASCII standard.

XOR masking is fundamental in cryptography (one-time pads, stream ciphers), error detection (CRC, parity bits), data obfuscation (simple XOR encryption with a key), graphics programming (sprite rendering via XOR blitting), and networking (calculating broadcast addresses from IP and subnet mask). The operation is its own inverse: applying the same mask twice restores the original value, making it ideal for toggling and encryption.