About

A right bit-shift displaces every bit in a binary word toward the least-significant position by n places. The n least-significant bits are discarded. What fills the vacated most-significant positions determines the shift type: a logical shift inserts 0s, while an arithmetic shift replicates the original sign bit. Confusing the two produces silently wrong results in signed arithmetic. Dividing a signed negative integer with a logical shift instead of an arithmetic one yields a large positive number rather than the expected negative quotient. This tool performs both shift variants across 8, 16, 32, and 64-bit widths with full two's complement representation, so you can verify firmware masks, protocol headers, or compiler output without risking a subtle off-by-one in production code.

Input accepts binary, decimal, or hexadecimal notation. The bit-level visualization color-codes retained, dropped, and filled positions so the mechanical effect of the shift is immediately visible. Note: results assume a fixed-width register. Overflow and sign extension behave exactly as they would in a hardware ALU of the selected width.

Formulas

The logical right shift by n positions on a w-bit unsigned value:

result = value2ⁿ = floor(value × 2⁻ⁿ)

The arithmetic right shift preserves the sign bit s. For a w-bit two's complement integer:

result = (value >> n) | (mask)

where the fill mask is:

mask =

{

0 if s = 0 (positive)((2ⁿ − 1) << (w − n)) if s = 1 (negative)

Where value is the input integer, n is the shift amount (0 ≤ n ≤ w), w is the register width in bits, and s is the most-significant bit (sign bit) of the original value. Arithmetic right-shift of a negative number rounds toward negative infinity, not toward zero.

Reference Data

Shift Amount	8-bit Logical (unsigned 200)	8-bit Arithmetic (signed −56)	Equivalent Division	Bits Dropped
0	11001000 → 200	11001000 → −56	÷ 1	0
1	01100100 → 100	11100100 → −28	÷ 2	1
2	00110010 → 50	11110010 → −14	÷ 4	2
3	00011001 → 25	11111001 → −7	÷ 8	3
4	00001100 → 12	11111100 → −4	÷ 16	4
5	00000110 → 6	11111110 → −2	÷ 32	5
6	00000011 → 3	11111111 → −1	÷ 64	6
7	00000001 → 1	11111111 → −1	÷ 128	7
8	00000000 → 0	11111111 → −1	÷ 256	8

Frequently Asked Questions

A logical right shift (often denoted >>> in languages like Java and JavaScript) always fills vacated most-significant bits with 0. It treats the operand as unsigned. An arithmetic right shift (>>) copies the original sign bit into the vacated positions. For positive numbers both produce identical results. For negative numbers in two's complement, arithmetic shift preserves the sign (result stays negative), while logical shift produces a large positive value. Example: 11110000 (signed −16 in 8-bit) shifted right by 1: arithmetic gives 11111000 (−8), logical gives 01111000 (120).

Arithmetic right shift by n is equivalent to floor division by 2ⁿ. For −7 >> 1, the mathematical result is −3.5, which floors to −4, not −3. This is a known asymmetry with integer division in C and most hardware ALUs. If your code expects truncation toward zero, you need to add a correction term: result = (x + ((x >> (w − 1)) & ((1 << n) − 1))) >> n.

For a logical right shift, shifting by w or more positions on a w-bit register always yields 0 because every original bit is discarded and replaced with 0. For an arithmetic right shift on a negative value, the result becomes all 1s (which is −1 in two's complement). In C, shifting by an amount ≥ the type width is technically undefined behavior. This tool clamps the shift to the selected bit width to give you the mathematically consistent result.

Two's complement encodes negative numbers by inverting all bits and adding 1. The MSB serves as the sign bit: 0 for non-negative, 1 for negative. When you select an 8-bit width and enter decimal 200, the tool treats it as unsigned 11001000. The same bit pattern read as signed 8-bit is −56. The shift operation acts on the raw bits identically; interpretation differs based on signed vs unsigned context. This is why the tool shows both interpretations.

Yes, for unsigned or known-positive values: x >> n is equivalent to floor(x ÷ 2ⁿ). Modern compilers already optimize integer division by powers of two into shifts, so the performance benefit in high-level languages is negligible. The risk emerges with signed negatives: −7 ÷ 2 truncates to −3 in most languages, but −7 >> 1 floors to −4. If your values can be negative, prefer explicit division for clarity.

JavaScript's native bitwise operators (>>, >>>) coerce operands to 32-bit integers, losing precision for larger values. This tool uses BigInt arithmetic internally, which handles arbitrary-precision integers. The 64-bit mode accurately models CPU registers (x86-64, ARM64) and data types like C's int64_t or Java's long without JavaScript's 32-bit truncation artifacts.