Bitwise calculator with shifts

How to use

1. Type A as a decimal number, or with a 0x (hex), 0b (binary) or 0o (octal) prefix. Negative numbers use a leading minus. Underscores are ignored.
2. Choose the Operator: AND, OR, XOR, NOT (one input), left shift, arithmetic right shift (>>) or logical right shift (>>>). For all but NOT and the shifts, type B as well; for a shift, B is the number of places.
3. Choose the Number type. 8, 16, 32 and 64-bit integer models a fixed-width type: inputs are wrapped to that width (and the tool says so), and the result is shown both signed and unsigned. JavaScript Number applies ECMAScript's rules: convert to a signed 32-bit integer, operate, and for shifts use the count modulo 32. JavaScript BigInt has no width: values are exact and negative numbers behave as an infinite string of sign bits.
4. Read the bit grid. For AND, OR and XOR the grid shows A, B and the result in aligned columns (and, for widths up to 16 bits, a column-by-column table); for NOT the bits that flipped are marked. For a shift it shows the bits that left, the bits that entered, and whether they are zeros or copies of the sign bit. The truth table and the >> versus >>> comparison appear below it.
5. The line labelled with the JavaScript expression shows exactly what that expression gives in a console. In a fixed-width mode it shows the wrapped values.

The four basic operations on single bits:

NOT flips every bit: 0 becomes 1 and 1 becomes 0. The table is generated by code, and the tests compare each row with JavaScript's own operators.

Worked examples

Every result below is recomputed by an automated test from the tool's engine. The bit patterns were also worked out by hand first, and the results are compared with JavaScript's own operators, BigInt, and BigInt.asIntN / asUintN on thousands of random values.

AND, OR and XOR on 0xCA and 0xAC

0xCA = 11001010 and 0xAC = 10101100 (as 8-bit signed numbers, -54 and -84). Column by column:

  11001010   (0xCA)
  10101100   (0xAC)
  --------
  10001000   AND  = 0x88 = 136 unsigned
  11101110   OR   = 0xEE = 238 unsigned
  01100110   XOR  = 0x66 = 102

Arithmetic versus logical right shift

-8 in 8 bits is 11111000. Arithmetic shift right by 1 copies the sign bit into the new left bit: 11111100 = -4, which is -8 divided by 2. Logical shift right puts a 0 there: 01111100 = 124.

JavaScript works on 32 bits, so the same expression gives a much bigger number. -8 is 32 bits of 1 followed by 000; shifting in a 0 at the left gives 0111...1100 = 2³¹ - 4.

NOT in JavaScript

~x equals -x - 1 in two's complement, so ~5 is -6. All 32 bits flip.

What goes wrong

These are the surprises people actually report. Each result is the tool's exact output and is covered by a test.

1 << 32 is 1 in JavaScript

The count is reduced modulo 32, so shifting by 32 is shifting by 0. The tool notes this when you type a count of 32 or more in JavaScript mode.

0xFFFFFFFF | 0 is -1

0xFFFFFFFF is 4294967295 as a Number, but every JavaScript bitwise operator first converts its operands to a signed 32-bit integer. All 32 bits being 1 is -1 in that reading.

0x80000000 & 0xFFFFFFFF is negative

Only bit 31 survives, and in a signed 32-bit integer bit 31 is the sign. To get 2147483648 back, use >>> 0 on the result.

Left shift past bit 31 wraps

0xFFFFFFFF is -1 after conversion, and -1 << 1 is -2. A bit that moves past bit 31 is lost, not carried into a bigger number, so left shifts cannot be used to multiply past 2³¹ in a Number. Another consequence: (2**32 + 5) | 0 is 5, and 2**53 | 0 is 0, because the high bits are dropped on conversion.

>>> on a BigInt throws

Browsers' JavaScript engines refuse it; the tool reports the same message. Use >>, or cut to a width first with BigInt.asUintN. Mixing a BigInt with a Number is also an error: 1n << 2 throws a TypeError ("Cannot mix BigInt and other types, use explicit conversions", observed in Node 20.19.2 and consistent with MDN's statement that BigInt and Number cannot be mixed in arithmetic).

A fraction is not an integer

Bitwise operators work on integers. In JavaScript 1.5 | 0 silently becomes 1; the tool rejects the fraction rather than truncate without telling you.

1 << 8 in 8 bits

In a fixed-width mode the tool shows the mathematical result, 0, and warns that in C a shift by a count not smaller than the width is undefined behaviour (cppreference), so a compiler may give any result.

Arithmetic right shift rounds down, not toward zero

-9 >> 1 is -5, because shifting is floor division by 2 (-4.5 rounds down to -5). Integer division in C and Java, and Math.trunc(-9 / 2), give -4. In C the result of right-shifting a negative value is implementation-defined (cppreference), although most implementations use an arithmetic shift.

Limits & gotchas

• Fixed widths are 8, 16, 32 and 64 bits. Other widths (12, 24, 128) are not offered; use BigInt mode and mask by hand.
• Inputs are wrapped, not rejected, in fixed widths. A value that does not fit the width is reduced modulo 2^width and a note says so, as a C cast would do for unsigned types.
• JavaScript Number mode is 32-bit. A Number beyond 32 bits is truncated by ToInt32, exactly as in a browser console. For larger values use the 64-bit mode or BigInt.
• Shift counts. At most 1000. A BigInt shift is exact, and the bit grid widens to show the whole result, so a shift by 1000 draws a grid of about a thousand cells; scroll sideways to read it.
• Language differences. The fixed-width modes describe hardware-style two's complement results. C, C++ and Java specify some of these cases differently (undefined behaviour for oversized shifts, implementation-defined right shifts of negatives in C). The tool tells you where this matters but cannot know your compiler.
• Integers only. No floating-point operands. For the bits of a float, use the IEEE 754 page.
• Browser. Tested in a current Chrome only.

FAQ

Sources

• Ecma International / TC39: ECMAScript Language Specification: Number type, bitwise shift operators and BigInt operations Used for: Number is IEEE 754 binary64; Number shifts convert with ToInt32 or ToUint32 and take the count modulo 32; BigInt left and right shift act on an infinite two's complement string; BigInt::unsignedRightShift throws a TypeError; strings are sequences of 16-bit code units.
• MDN Web Docs: Right shift (>>) Used for: Number >> returns a 32-bit integer and copies the sign bit; BigInt >> has no truncation.
• MDN Web Docs: Unsigned right shift (>>>) Used for: >>> fills with zeros and always gives a non-negative result; it throws a TypeError for BigInt ("BigInts have no unsigned right shift, use >> instead").
• MDN Web Docs: BigInt Used for: BigInt holds integers of arbitrary size; mixing BigInt and Number in arithmetic throws a TypeError.
• MDN Web Docs: BigInt.asIntN() Used for: BigInt values are always encoded as two's complement; asIntN wraps a value to a signed width.
• cppreference.com: C arithmetic operators Used for: In C a shift count that is negative or not smaller than the promoted width of the left operand is undefined behaviour; signed right shift of a negative value is implementation-defined; unsigned arithmetic wraps modulo 2^n; signed overflow is undefined.
• Wikipedia: Two's complement Used for: The most significant bit is the sign; one zero and one extra negative number (a 4-bit range of -8 to +7); invert-and-add-one; sign extension repeats the most significant bit; the most negative number has no positive counterpart.

Every document above was opened and read on 2026-10-02. Documentation changes; if a page here disagrees with the current docs, trust the docs and tell us.

The statement that a shift count is taken modulo 32 for Numbers is from the ECMAScript algorithms (Number::leftShift and signedRightShift use ToInt32 on the left operand and the low five bits of the count); the error message for BigInt >>> is from MDN.

Related tools

• Two's complement calculator

  Encode and decode signed integers in 8, 16, 32 and 64 bits, with overflow, sign extension and addition flags.

• Hex converter

  Hex, decimal and binary with byte views, big- and little-endian order and byte-list input.

• Number base converter

  Convert between any bases from 2 to 36, with fractions, repeating expansions and the division and weight steps.

• IEEE 754 converter

  See the sign, exponent and fraction bits of float32 and float64 values, and the exact value stored.