What is a parity bit?

A parity bit is an extra bit added to a group of data bits so the total number of 1 bits is either always even (even parity) or always odd (odd parity). It is the simplest form of error detection used in serial links and memory.

What does even parity versus odd parity mean?

Even parity sets the extra bit so the count of 1 bits including the parity bit is even. Odd parity sets it so that count is odd. The two schemes detect the same single-bit errors but disagree on the parity bit value.

Can parity detect every error?

No. A single parity bit catches any odd number of flipped bits but misses an even number of flips, because two errors cancel out in the count. For stronger detection you need CRCs or Hamming codes.

How is the parity computed here?

The tool counts the set bits using arbitrary-precision arithmetic, then takes that count modulo 2. An even result means even parity, an odd result means odd parity, regardless of how large the number is.

Where is parity still used today?

Parity remains common in UART serial communication, older ECC memory, RAID systems, and many embedded protocols where a cheap single-bit check is enough to flag corruption and request a retransmission.

What is the Bit Parity Calculator?

Compute the parity of any integer and the parity bit you would append for even-parity or odd-parity error detection. Enter a value in decimal, hex, or binary and see whether it has an even or odd number of set bits. Runs in your browser. It runs free in your browser on Gera Tools, with nothing uploaded.

Bit Parity Calculator

Name: Bit Parity Calculator
Creator: Gera Tools
License: https://creativecommons.org/licenses/by/4.0/

Parity is the oldest and cheapest error-detection trick in computing: count the 1 bits and remember whether that count is even or odd. This tool tells you the parity of any integer and, for both the even-parity and odd-parity conventions, exactly which bit you would append to a frame.

How it works

The tool counts the set bits in your value and takes that count modulo 2:

ones        = number of 1 bits in the value
data parity = ones mod 2        // 0 = even, 1 = odd
even bit    = data parity       // appended, keeps the total even
odd bit     = 1 − data parity   // appended, keeps the total odd

For even parity the appended bit makes the overall number of 1 bits even; for odd parity it makes the overall count odd. A receiver recomputes parity over the data plus the parity bit and flags an error if it does not match the agreed scheme. A single flipped bit always changes the count, so it is always caught.

Example and notes

The byte 182 is 10110110, which contains five 1 bits — an odd number, so its data parity is odd. To transmit it under even parity you would append a 1 (making six 1 bits, even); under odd parity you would append a 0 (leaving five, odd). Parity cannot locate or correct the error, only detect it, and it misses errors that flip an even number of bits — that is why robust systems layer CRCs or Hamming codes on top.

Where parity checking is used

Parity remains relevant in several real-world settings, each using it slightly differently:

UART serial communication Most microcontrollers and serial terminals allow you to configure the parity bit as None, Even, Odd, or the less common Mark (always 1) or Space (always 0). Even parity is the most common choice when parity is enabled. A UART parity error triggers a status flag in the hardware register, signalling that the received byte should be discarded and a retransmission requested.

ECC RAM modules Error-Correcting Code memory extends the parity concept significantly. A 64-bit data bus paired with 8 additional check bits uses a Hamming-based scheme that can not only detect but also correct single-bit errors, and detect (though not correct) double-bit errors. The additional bits are computed by applying several parity checks over different subsets of the data bits.

RAID 3 and RAID 5 Block-level storage RAID calculates a parity stripe across the data drives. In RAID 3, the parity is on a dedicated drive; in RAID 5, the parity is distributed across all drives. In either case, if one drive fails, the missing data can be reconstructed by XORing the surviving drives — the same logic as the parity bit, extended to large blocks.

Network protocols and magnetic tape Older protocols and backup tape formats use Longitudinal Redundancy Checks (LRC), which are essentially parity bytes computed over rows and columns of a data frame, catching more errors than a single parity bit.

Error detection limits

A single parity bit catches any odd number of bit flips in a group: 1, 3, 5, and so on. It misses any even number of flips — two errors cancel out perfectly, leaving the parity unchanged. For most communication channels where burst errors are rare, this is acceptable. Where bursts or corruption affecting multiple bits are a real risk (radio links, flash storage), CRC codes or Reed-Solomon error correction are used instead.