Bitwise Calculator - AND, OR, XOR, NOT, and Truth Table

A bitwise calculator applies boolean AND, OR, XOR, NAND, NOR, XNOR, or NOT to two integers column by column inside a fixed-width register and shows the result in decimal, binary, octal, and hexadecimal, the fastest way to verify what a low-level flag, mask, or toggle is doing.

• • Debug flag bits in microcontroller registers: Mask a status register with AND, isolate one bit with AND against a power of two, or clear a flag with AND against the bitwise NOT of a mask.
• • Encode permissions in a single integer: Use OR to set a bit, AND with NOT to clear a bit, and XOR to toggle a bit when storing read, write, and execute flags in one byte.
• • Convert color channels in image and UI code: Mask the red, green, blue, and alpha channels out of a packed 32-bit color with AND against 0xFF, 0xFF00, 0xFF0000, and 0xFF000000.

Most programming languages expose the same six operators: & (AND), | (OR), ^ (XOR), ~ (NOT), and the two compound shifts that are usually discussed alongside them. The bitwise calculator is the scratchpad you reach for when an expression like (flags & READ) == READ is hard to read in your head or in code review.

When a mask itself is built from a single power of two, the bit shift calculator builds the same constant in a fixed-width register without doing the multiplication in your head.

The calculator writes A and B as n-bit binary strings, lines up the bits, and applies the chosen boolean rule column by column. NOT only needs the first operand and flips every bit in the chosen bit width.

• a: first operand, treated as an unsigned n-bit integer
• b: second operand, ignored when the operation is NOT
• op: boolean rule: AND, OR, XOR, NAND, NOR, XNOR, or NOT
• n: bit width, from 4 to 32, that fixes the register size

The result panel reports the same number in decimal, binary, octal, and hexadecimal so you can paste the value into the language or debugger you are using, and the popcount row gives the number of 1-bits in the result for the flag-mask checks that need it most.

According to Wikipedia, a bitwise operation acts on one or two bit patterns of equal length by applying a boolean operator column by column, with the same truth table used for the per-bit AND, OR, and XOR operators that are built into C, C++, Java, JavaScript, and Python.

According to MDN Web Docs, JavaScript's bitwise operators first coerce their operands to 32-bit signed integers using two's complement, which is why a bitwise NOT in JavaScript is the same as negating the value and subtracting one.

When the same two operands also need an add, subtract, multiply, or divide alongside the bitwise rule, the binary operations calculator runs both arithmetic and bitwise operations from the same form.

Four ideas that come up every time you work with bitwise operators.

The four concept cards above are the foundation for everything else. The same vocabulary is used by every language specification, so you can read the operator docs for C, Java, Python, JavaScript, and Rust without translating the names again.

If you only need to see a single number in another base, the binary converter does that without forcing you to pick an operation first.

Pick the operation, set the two operands, choose a bit width, and read the result in the format you need.

1. 1 Pick an operation: Choose AND, OR, XOR, NAND, NOR, XNOR, or NOT from the dropdown. NOT ignores operand B.
2. 2 Enter the first operand: Type the unsigned integer for A. The binary row below the inputs shows the bit pattern you typed, padded to the bit width.
3. 3 Enter the second operand: Type the unsigned integer for B. Two's complement, signed, or negative values are out of scope for this tool.
4. 4 Choose a bit width: Pick 4, 8, 16, or 32 bits. The width fixes how NOT behaves and how both operands are truncated if they are too wide.
5. 5 Read the result panel: The result row shows decimal, binary, octal, hex, and popcount at the same time, so you can copy the value directly into the language you are writing.
6. 6 Reset and try the next case: Hit Reset to restore the default 170 AND 240 example and try a new rule without retyping the operands.

To check whether the third bit of a status register is set, AND the register against 0b00001000 (8 in decimal) and look at the popcount. The same register can be OR'ed with 0b00001000 to set the bit, and XOR'ed with 0b00001000 to toggle it.

If your workflow needs the column-by-column carry rule as well as the bitwise rules, the binary addition calculator shows the addition step by step in binary.

Six practical reasons to verify a bitwise expression with a calculator instead of trusting the compiler or your mental model.

• • Catch off-by-one bit errors before runtime: Mask width, sign extension, and shift counts are the three most common sources of one-bit bugs. Reading the result in binary next to the operands makes the wrong bit obvious.
• • See all four number bases at once: Decimal, binary, octal, and hex are all visible in the same row, which removes the back-and-forth between a debugger and a hex converter.
• • Match the register width of your target: 4, 8, 16, and 32 bit widths let the calculator behave like the actual hardware register, including the way NOT truncates in 8 bits.
• • Learn the operator truth tables by doing: The default example is 0xAA AND 0xF0, which is the textbook case for AND masking and a good warm-up for NAND, NOR, and XNOR.
• • Validate hand-written masks: Engineers who write permission masks or packed struct layouts can paste a candidate mask into B and use AND or XOR against a known value to confirm the shape.
• • Compare bitwise rules side by side: Switching between AND, OR, and XOR with the same operands shows the same column-by-column pattern in three different output rows.

Used in a code review, the calculator is a quick way to show a reviewer that a clever bit-trick is doing exactly what the commit message claims, without having to drop into a debugger to print the intermediate values.

Four things that change what a bitwise operation returns, and two limits of this calculator worth knowing before you paste a result into production code.

• • This tool is for plain integer bitwise operations. Floating-point bit tricks, IEEE 754 sign and mantissa extraction, and bitwise operations on big integers larger than 32 bits are not supported.
• • The calculator returns the result in the chosen bit width, so a NOT inside an 8-bit register can never return a value outside 0..255. If you need the language's actual signed 32-bit behaviour, paste the operands into a real language REPL rather than trust the bit width of this tool.

Both limitations are about scope, not correctness: the bitwise rules are stable across every modern language, so once you have a verified result you can paste it into the target code with confidence.

According to Python documentation, the bitwise operations ~, &, |, and ^ assume an infinite-width two's complement representation, which is why -1 has an unlimited run of 1-bits under ~ and why the result is sign-extended before being returned.

For a real-world example of how the same AND and shift rules extract color channels from a packed 32-bit integer, the hex to RGB calculator walks through a 0xRRGGBB value end to end.