How does XOR work for simple encryption?

XOR's key property: (A ⊕ B) ⊕ B = A. If you have plaintext P and a key K, then ciphertext C = P ⊕ K, and you decrypt with P = C ⊕ K — the exact same operation. This is a one-time pad when K is truly random and as long as the message. XOR ciphers appear everywhere from simple string obfuscation to the XOR step in AES encryption. The weakness: if you reuse the same key for multiple messages, (C₁ ⊕ C₂) reveals (P₁ ⊕ P₂), which leaks information about both plaintexts.

When should I use bitwise operations in high-level code?

Use bitwise operations when you need to pack multiple boolean flags into a compact format (database columns, API parameters, network protocol headers), when performing calculations where powers-of-2 scaling saves CPU cycles (in tight loops and graphics code), when interfacing with hardware or binary file formats that define bit-level structures, and when implementing algorithms from the domain of cryptography, compression, or error correction where bit-level manipulation is inherent to the algorithm.

What goes wrong with sign extension during right shift?

Arithmetic right shift (>>) replicates the sign bit (the leftmost bit) into vacated positions to preserve the sign. A negative 8-bit number like -16 (11110000) right-shifted by 1 becomes 11111000 (-8) — the 1 fill preserves the negative. But if you expected zero-fill (logical shift), you get 01111000 (120), a wildly different unsigned value. Languages handle this differently: Java uses >> for arithmetic and >>> for logical; C leaves it implementation-defined for signed types; JavaScript's >> is arithmetic on 32-bit signed integers.

How do I count the number of set bits (popcount) in a number?

Population count (popcount or Hamming weight) counts the number of 1-bits in a binary representation. Modern CPUs have a dedicated POPCNT instruction (SSE4.2 on x86), but the classic software approach is Brian Kernighan's algorithm: `while (n) { n &= n - 1; count++; }` — each iteration clears the lowest set bit. Our calculator shows the popcount for every result. Popcount is used in error-correcting codes, cryptography (Hamming distance), and sparse array implementations.

Why do bitwise operations on JavaScript numbers sometimes give unexpected results?

JavaScript bitwise operators (except >>>) convert operands to 32-bit signed integers, perform the operation, then convert back to a 64-bit float. This means only the lower 32 bits survive. For numbers larger than 2³¹-1 or with fractional parts, the implicit conversion can cause surprising results. Always use Math.floor() for explicit integer conversion before relying on bitwise behaviour, and be aware that values outside the 32-bit range will be truncated modulo 2³².

Calculators2026-05-10

Bitwise Calculator: AND, OR, XOR, Shift Operations and Flag Manipulation Explained

Bitwise operations are the knife-edge of programming — they operate on individual bits within a byte or word, giving you direct control over the raw binary representation of data. Where arithmetic operates on numbers as abstract values, bitwise operations manipulate the 1s and 0s themselves. This is how file permissions are encoded in a single integer on Unix, how graphics programmers extract RGB channels from a pixel value, how network protocols pack multiple flags into a single header byte, and how fast hash functions and checksums are built. Our free bitwise calculator takes two operands (or one for NOT and shifts), performs the selected operation at the bit level, and displays the result in binary, hexadecimal, and decimal simultaneously — with each bit position labeled so you can verify exactly what happened where.

memory

Bitwise Calculator

Free · No registration

Try this tool for free →open_in_new

Step-by-Step Guide

Enter Your Operands

Type two numbers in decimal, hexadecimal (prefix with 0x), or binary (prefix with 0b). The calculator accepts 32-bit and 64-bit mode — in 32-bit mode, operands are treated as unsigned 32-bit integers (0 to 4,294,967,295). Each operand is displayed in binary format with bit positions numbered from 31 (most significant) down to 0 (least significant), so you can visualise exactly which bits are set before applying any operation.

Select the Bitwise Operation

Choose from seven operations: AND (&) sets a result bit to 1 only if both corresponding operand bits are 1; OR (|) sets it to 1 if either operand bit is 1; XOR (^) sets it to 1 if exactly one operand bit is 1; NOT (~) inverts every bit of a single operand; left shift (<<) moves all bits left by N positions (filling with zeros on the right); logical right shift (>>>) moves bits right with zero-fill; arithmetic right shift (>>) moves bits right with sign-bit fill. The calculator animates the operation — showing which input bits contribute to each output bit.

Read the Multi-Format Result and Bit Map

The result displays in binary (32 bits with spacing every 4 bits for readability), hexadecimal (8 hex digits for 32-bit), and decimal. A visual bit map highlights which positions are 1 in the result, and hovering over any bit shows which input bits produced it. The copy buttons let you grab the result in any format instantly — binary for documentation, hex for code, decimal for calculations.

Tips & Best Practices

check_circle

Bit masking is the most common bitwise pattern: use AND with a mask to extract specific bits. To get the lowest 8 bits of a 32-bit value: value & 0xFF (255). To test if bit 3 is set: (value & (1 << 3)) !== 0. To clear bit 5: value & ~(1 << 5). To set bit 7: value | (1 << 7). To toggle bit 2: value ^ (1 << 2). These four patterns — test, clear, set, toggle — cover 90% of bit manipulation in practice.

check_circle

Color channel extraction is a classic bitwise use case. An RGB pixel packed into a 32-bit integer (0xRRGGBB) can be unpacked with: red = (pixel >> 16) & 0xFF, green = (pixel >> 8) & 0xFF, blue = pixel & 0xFF. In one line, you've extracted three colour channels using right shift and AND masks. ARGB (alpha channel) uses the top 8 bits: alpha = (pixel >> 24) & 0xFF.

check_circle

Left shift by 1 position multiplies by 2; right shift by 1 position divides by 2 (integer division, rounding toward zero for arithmetic shift, toward negative infinity for logical). Left shift by N is equivalent to multiplying by 2ᴺ. Right shift by N is equivalent to dividing by 2ᴺ. CPUs execute shifts in a single clock cycle, making them dramatically faster than general multiplication/division for powers of 2.

check_circle

XOR swap is a classic trick to swap two variables without a temporary variable: a ^= b; b ^= a; a ^= b. After this sequence, a and b have exchanged values. It works because XOR is commutative, associative, and x ^ x = 0, x ^ 0 = x. In modern code, this is mainly a curiosity — compilers optimise standard swaps equally well — but it's a great demonstration of XOR's algebraic properties.

check_circle

Permission flags pack multiple on/off settings into a single integer. Unix file permissions use 12 bits: the bottom 9 are rwx for owner/group/others (each r=4, w=2, x=1). Higher bits encode setuid (4000), setgid (2000), and sticky (1000). Each permission is a single flag that can be tested or modified independently — this is the pattern behind virtually every flags parameter in every C API.

check_circle

CRC (Cyclic Redundancy Check) and checksum calculations use XOR and shift operations heavily. A basic CRC-8 implementation XORs each byte of data into a running register, then shifts and conditionally XORs with a polynomial. This produces an 8-bit "fingerprint" that detects accidental changes to data. Our calculator lets you step through such algorithms bit by bit to see how they work.

check_circle

The right shift operator comes in two flavours: logical (>>> in JavaScript/Java), which fills the vacated leftmost bits with zeros; and arithmetic (>> in most languages), which fills them with copies of the sign bit (preserving the sign for signed integers). Right-shifting -8 (11111000 in 8-bit signed) by 1 with arithmetic shift produces -4 (11111100); with logical shift it produces 124 (01111100), a completely different value.

Frequently Asked Questions

Bitwise AND (&) operates on individual bits of two numbers: 5 & 3 = 1 because 101 & 011 = 001. Logical AND (&&) operates on boolean truth values: 5 && 3 returns 3 (truthy value) in JavaScript, or true in strictly typed languages. Bitwise AND produces a number; logical AND produces a boolean. Confusing them in an `if` statement is a common bug — `if (x & 1)` tests if the lowest bit is set (odd number check), while `if (x && 1)` checks if x is truthy (and ignores the 1 entirely due to short-circuit evaluation returning x).

Bitwise operations are the smallest and fastest operations a computer can perform — literally one CPU cycle, one logic gate layer deep. Our calculator makes these operations visible, showing exactly which bits change and why. Whether you're packing flags, extracting colour channels, or debugging a cryptography implementation, see your bits in full detail.

Try this tool for free →open_in_new