What is the difference between logical and arithmetic right shift?

Both move bits to the right, but they fill the vacated high bits differently. Logical right shift (>>>) always pads with zeros, so it treats the value as unsigned. Arithmetic right shift (>>) copies the sign bit into the top, so a negative number stays negative. In 8-bit, -8 is the pattern 11111000: logical >> 1 gives 01111100 = 124, while arithmetic >> 1 gives 11111100 = -4. Pick logical for raw unsigned data, arithmetic for signed integers.

Why does left shift by 1 multiply by 2?

Shifting every bit one place to the left turns the bit worth 1 into worth 2, the bit worth 2 into worth 4, and so on, exactly doubling the value. So 5 << 1 = 10 and 5 << 2 = 20. Each extra position doubles again, which is why n bits of left shift multiplies by 2 to the power n. This holds until a bit reaches the sign position or falls off the top of the chosen width, where overflow changes the result.

How does the sign bit behave when I shift?

In a fixed width the top bit is the sign: 1 means negative under two's complement. Left shift can push a 1 into that position, flipping a positive number negative (in 8-bit, 64 > 1 stays negative at -4. Logical right shift ignores the sign entirely and feeds in zeros, which is why it can turn a negative pattern into a large positive number.

What happens on bit-width overflow?

Each width has a fixed number of bit slots. When a left shift pushes bits past the most significant position, those high bits are simply dropped. In 8-bit, 255 << 1 keeps only the low eight bits = 11111110 = -2, not 510. Choosing 16 or 32 bits gives more room before the same shift overflows. The tool masks the result to your chosen width so what you see matches how a real 8/16/32-bit register would behave.

Why does arithmetic right shift act like divide by 2?

Dropping the lowest bit halves the value, and floor-rounds toward negative infinity. So 256 >> 2 = 64 and 20 >> 1 = 10. For negatives it still floors: -7 >> 1 = -4, not -3, because floor(-3.5) is -4. That floor behaviour is why >> is not identical to integer division that truncates toward zero. The tool computes the exact floor result inside your chosen width.

What does the unsigned right shift >>> do that >> does not?

The triple-arrow >>> is the unsigned (logical) right shift. It reads the value purely as a bit pattern, shifts right, and fills the top with zeros no matter what the original sign was. That is its whole job: there is no >>> distinction for positive numbers, but for negatives it diverges sharply. In 32-bit, -1 is 0xFFFFFFFF, and -1 >>> 1 = 0x7FFFFFFF = 2147483647, while -1 >> 1 stays -1. Use >>> when a value is conceptually unsigned bytes, color channels or flags.

Read a hardware register's status bit

A peripheral status register packs ready, error and busy flags at known bit positions. Paste the raw 8-bit value, logical right shift it by the flag's position in 8-bit width, and read whether the low bit is 1 so you confirm the flag without hand-counting the binary.

Verify a packed timestamp field

A 32-bit packed datetime keeps the year in the high bits and the month and day below it. Shift the word right by the year's offset in 32-bit width, then check the decimal and binary line up. The 4-bit grouped before-and-after view shows exactly where each field starts.

Bit Shift Calculator — Left, Logical and Arithmetic Shift

Left shift, logical and arithmetic right shift — see the bits move, pick 8/16/32-bit, read decimal, hex and binary — browser-only

Runs locally
Category Developer & DevOps
Best for Formatting, validating, shrinking, or inspecting code-adjacent text.

ValueDecimal, 0x hex or 0b binary — sign allowedShift amount (bits)Shift amount (bits)

Shift type

Bit width

Each left shift by 1 multiplies by 2 (within the width). 5 << 1 = 10.

Result

Decimal10

Hex0xa

Binary0b00000000000000000000000000001010

Bit alignment (32-bit)

Before0000 0000 0000 0000 0000 0000 0000 0101

After0000 0000 0000 0000 0000 0000 0000 1010

All shifts run on your value inside the chosen width using BigInt masking — exact, and nothing leaves your browser.

What this tool does

A focused bit shift calculator for the three shift operators that trip people up: left shift (value << n), logical right shift (value >>> n) and arithmetic right shift (value >> n). Type a value in decimal, 0x hex or 0b binary, choose the shift type and how many bits to move, and the tool shows the result in decimal, hexadecimal and binary at once. Pick a width of 8, 16 or 32 bits and it handles overflow and the sign bit the way real hardware does, masking the pattern inside that width. The before-and-after bits are laid out in 4-bit groups so you can watch zeros stream in on one side and bits fall off the other. Left shift by one is multiply by two; arithmetic right shift by one is floor-divide by two; logical right shift zero-fills and drops the sign. Sister tool to the bitwise AND/OR/XOR calculator, this one is all about movement. Everything runs client-side with one-click copy and a shareable URL that reopens your exact shift.

Tool details

Input: Text + Numbers; The page exposes text boxes, numeric controls, file pickers, or structured inputs depending on the tool.
Output: Live result + Copy; The result area focuses on usable output, with copy, download, or preview actions when supported.
Privacy: Browser-side processing; The main tool logic does not call an external API, so inputs normally stay in the current tab.
Save / share: Shareable URL state; Key settings are encoded in the URL so another person can reopen the same setup.
Performance budget: Initial JS <= 9 KB; No WASM budget is declared, keeping the tool quick to open on mobile.
Best fit: Developer & DevOps · Developer; Category and role tags drive related tools, internal links, and quick fit checks.

How to use

1. Input

Paste or drop your content into the tool panel.
2. Process

Click the button. All processing is local in your browser.
3. Copy / Download

Copy the result or download to disk in one click.

How Bit Shift Calculator fits into your work

Use it in the small gaps between coding, reviewing, debugging, and shipping.

Developer jobs

Formatting, validating, shrinking, or inspecting code-adjacent text.
Preparing snippets for documentation, tickets, commits, or handoff.
Checking a small payload quickly without switching tools.

Developer checks

Run irreversible transforms like minify or obfuscate on a copy.
Keep secrets out of pasted snippets unless the tool explicitly stays local.
Use your normal tests or linter before shipping transformed code.

Good next steps

These links move the current task into a more complete workflow.

Real-world use cases

Read a hardware register's status bit
A peripheral status register packs ready, error and busy flags at known bit positions. Paste the raw 8-bit value, logical right shift it by the flag's position in 8-bit width, and read whether the low bit is 1 so you confirm the flag without hand-counting the binary.
Verify a packed timestamp field
A 32-bit packed datetime keeps the year in the high bits and the month and day below it. Shift the word right by the year's offset in 32-bit width, then check the decimal and binary line up. The 4-bit grouped before-and-after view shows exactly where each field starts.

Common pitfalls

Shifting in the wrong width: a value that fits in 16 bits gives a different result if you read it in 8-bit, because the high bits get masked off.
Treating >>> on a positive number as special. For non-negative values >>> and >> agree; the difference only shows up once the top bit is set.
Counting bit positions from 1 instead of 0. The first flag is 1 << 0, not 1 << 1, so an off-by-one here doubles every mask.

Privacy

Your value, the shift type, the amount and the chosen width are all evaluated by BigInt JavaScript inside this browser tab, so the decimal, hex and binary output is computed locally and never uploaded. Note that the share link writes these numbers into the URL query string; for a sensitive value, copy the result instead of sharing the link.

FAQ

Tool combos

Folks in your role tend to reach for these alongside this tool.

Developer

Browse all tools for this role

Bit Shift Calculator — Left, Logical and Arithmetic Shift

Result

What this tool does

Tool details

How to use

1. Input

2. Process

3. Copy / Download

How Bit Shift Calculator fits into your work

Developer jobs

Developer checks

Good next steps

Real-world use cases

Read a hardware register's status bit

Verify a packed timestamp field

Common pitfalls

Privacy

FAQ

Bitwise Calculator

Number Base Converter

Two's Complement Converter

Scientific Calculator

AI Eval Planner

Apache Cheatsheet

API Key Generator

API Rate Limit Cheatsheet

App Store Keywords Checklist

ASCII Table Generator

ASCII Table Reference

awk + sed Cheatsheet