Bitwise Calculator

Bitwise operations are the direct manipulation of individual bits in a binary number — the lowest-level operations a processor performs, executing in a single clock cycle and forming the foundation of everything from network address masking to cryptographic key generation. Understanding and calculating bitwise results is fundamental to embedded systems programming, kernel development, protocol implementation, and any domain where the bit-level representation of data matters. The bitwise calculator performs all standard bitwise operations with simultaneous multi-base output.

The Six Bitwise Operations

AND (&): result bit is 1 only if both input bits are 1. Primary use: masking — isolating specific bits while zeroing others. 0xFF & 0x0F = 0x0F (keeps lower 4 bits, clears upper 4). Checking if a bit is set: if (value & (1 << n)) tests whether bit n is 1.

OR (|): result bit is 1 if either input bit is 1. Primary use: setting bits — turning on specific bits without affecting others. value | (1 << n) sets bit n to 1 regardless of its current state.

XOR (^): result bit is 1 if the input bits differ. Primary use: toggling bits; detecting differences; simple encryption (applying the same key twice restores the original). value ^ (1 << n) toggles bit n.

NOT (~): inverts all bits (unary operation). In two's complement: ~x = -(x+1). ~0 = -1 in signed integers; ~0 = 0xFFFFFFFF in 32-bit unsigned.

Left shift (<<): shifts bits left by n positions, filling with zeros. Equivalent to multiplying by 2ⁿ. 5 << 3 = 40 (5 × 8). Overflow discards bits shifted past the register width.

Right shift (>>): shifts bits right by n positions. For unsigned: fills with zeros (logical shift). For signed: fills with the sign bit (arithmetic shift), preserving negative numbers. 40 >> 3 = 5 (40 ÷ 8). Use this online calculator for any bitwise operation. The binary arithmetic calculator handles arithmetic in binary.

Practical Bit Manipulation Patterns

Common bitwise idioms used in production code:

• Check if bit n is set: (value >> n) & 1 — returns 0 or 1
• Set bit n: value | (1 << n)
• Clear bit n: value & ~(1 << n)
• Toggle bit n: value ^ (1 << n)
• Check if power of 2: (n > 0) && !(n & (n-1)) — a power of 2 has exactly one 1-bit
• Round up to next power of 2: repeatedly left-shift until exceeding n, or use __builtin_clz() in GCC
• Swap two integers without temp variable: a^=b; b^=a; a^=b (XOR swap trick)
• Multiply by 2ⁿ: x << n (compiler generates this automatically for constant divisors/multipliers)

Networking: Subnet Mask Operations

IP address subnetting is pure bitwise AND operation. Network address = IP address AND Subnet mask. For IP 192.168.1.50 (11000000.10101000.00000001.00110010) AND subnet mask 255.255.255.0 (11111111.11111111.11111111.00000000): network address = 192.168.1.0. The host portion = IP AND (NOT subnet mask) = IP AND 0.0.0.255: 0.0.0.50. This calculator makes subnet mask calculations transparent at the bit level. The binary arithmetic calculator and developer calculators cover the complete low-level programming toolkit.

Bitwise Operations in Cryptography and Hashing

Modern cryptographic algorithms are entirely composed of bitwise operations: AES uses XOR, bit rotations, and table lookups; SHA-256 uses AND, OR, XOR, NOT, and right rotations (ROTR) as its primary mixing functions; ChaCha20 uses only XOR, addition, and rotation. The exclusive use of bitwise operations (plus modular addition) in these algorithms ensures: constant-time execution (no secret-dependent branches), hardware implementation efficiency (bitwise gates are the fastest hardware circuits), and reversibility properties (XOR is its own inverse). Understanding bitwise operations is a prerequisite for reading cryptographic algorithm specifications.