Compute logical XOR and bitwise XOR for up to 4 inputs — see truth tables, parity checks, bit-by-bit visualization, binary/hex output, and swap tricks.
The XOR (exclusive OR) operation is one of the most versatile and powerful operations in computing and discrete mathematics. Unlike regular OR which returns true when at least one input is true, XOR returns true only when the inputs differ — exactly one is true and the other is false. This "difference detector" property makes XOR invaluable across cryptography, error detection, data structures, and algorithm design.
At the bitwise level, XOR compares each corresponding pair of bits in two integers. A result bit is 1 only when the two input bits differ. This leads to remarkable properties: XOR-ing any number with itself produces zero (self-cancellation), XOR-ing with zero returns the original number (identity), and applying XOR twice with the same value restores the original (involution). These properties enable the famous XOR swap algorithm that exchanges two variables without a temporary, and they form the mathematical backbone of one-time pad encryption — the only theoretically unbreakable cipher.
Multi-input XOR acts as a parity function: the result is 1 when an odd number of inputs are 1. This is the basis of parity bits in error detection, RAID storage (XOR across disks for redundancy), and CRC checksums. This calculator supports up to four inputs in both logical and bitwise modes, with configurable bit widths from 4 to 32 bits, colour-coded bit-by-bit visualisation, and comprehensive property tables.
XOR is deceptively simple — one bit at a time — but tracking all 8, 16, or 32 bit positions by hand invites errors, and chaining three or four inputs compounds the risk. This calculator shows the binary representation of every operand, aligns the bits vertically, and highlights which positions differ. It supports 2–4 inputs in both logical and bitwise modes, so you can explore parity, self-cancellation (A ⊕ A = 0), and multi-input XOR in one place. Cryptography and networking students use it to verify XOR-cipher steps and RAID parity calculations.
A XOR B: output is 1 when inputs differ (A=0,B=1 or A=1,B=0). Bitwise XOR applies this per bit. Multi-input XOR = parity function (1 if odd number of 1-bits).
Result: 255 (0xFF)
170 = 10101010, 85 = 01010101. Every bit position differs, so XOR yields 11111111 = 255.
Both OR and XOR return 1 when at least one input is 1, but XOR returns 0 when both inputs are 1. This single-row difference in the truth table gives XOR its distinctive properties: it detects difference rather than presence. In a truth table, OR yields (0,1,1,1) while XOR yields (0,1,1,0) for inputs (0,0), (0,1), (1,0), (1,1).
XOR is its own inverse: A ⊕ B ⊕ B = A, because XOR-ing with B toggles bits and doing it again toggles them back. This makes XOR the foundation of simple encryption (one-time pads, stream ciphers) and the classic temp-free swap trick (a^=b; b^=a; a^=b). For multiple inputs, XOR computes the parity function — the result is 1 when an odd number of inputs are 1 — which is the basis for RAID parity, CRC error detection, and Hamming codes.
In a one-time pad, XOR-ing plaintext with a truly random key of equal length produces ciphertext that is information-theoretically unbreakable. Block ciphers like AES use XOR at every round to mix key material into the data. In algorithms, XOR is used to find the single unique element in an array (XOR everything together; duplicates cancel), to generate pseudo-random sequences (LFSR), and to implement Gauss–Jordan elimination over GF(2).
OR returns true when at least one input is true (including when both are true). XOR returns true only when the inputs differ — exactly one is true. In a truth table, OR gives 1,1,1,0 while XOR gives 0,1,1,0.
XOR is perfectly balanced (outputs 0 and 1 equally for random inputs) and is its own inverse. XOR-ing plaintext with a random key of equal length creates a one-time pad — the only provably unbreakable cipher. Stream ciphers and block ciphers heavily use XOR.
Multi-input XOR computes the parity of the inputs. The result is 1 if an odd number of inputs are 1, and 0 if an even number are 1. This is the basis for RAID parity and error-detection codes.
Yes. The XOR swap algorithm uses three XOR operations: a ^= b; b ^= a; a ^= b. After these steps, a and b exchange values without needing a temporary variable. However, in modern practice, using a temp variable is clearer and equally fast.
Parity bits add a single XOR check bit to data so the total number of 1-bits is always even (or odd). If a single bit flips during transmission, the parity check detects it. Hamming codes extend this idea to locate and correct single-bit errors.
Every bit in A matches the corresponding bit in A, so every XOR comparison yields 0. This self-cancellation property is exploited in algorithms to find the "missing" or "unique" number in a collection by XOR-ing all values together.