What does "Signed" / "Unsigned" mean in the tool?

**Unsigned** = every bit represents value. 8-bit unsigned holds 0 to 255. **Signed** = the highest bit is the sign ([[two's complement||standard representation in almost every CPU]]). 8-bit signed holds -128 to +127. The tool shows **both interpretations** at once, the switch only decides whether arithmetic ops (`A + B`, `A - B`) and arithmetic shift (`>>`) treat values as signed.

What is popcount and why?

**[[Popcount||population count, number of bits set to 1]]** is the count of 1s in the binary representation. `popcount(0b1011)` = 3. Useful in **compression**, **algorithms** (Hamming distance between hashes), **databases** (bitmap indexes), **machine learning** (feature cardinality). Modern CPUs have a **dedicated POPCNT instruction** (x86 SSE4.2, ARM NEON). In JS a loop or the Kernighan trick suffices: `while (n) { count++; n &= n-1; }` (each iteration zeroes the lowest 1).

What does "A & -A" do?

**Lowest set bit**: extracts the **lowest set bit** of a number. `0b1101100 & -(0b1101100)` = `0b100` = 4. Why it works: `-A` in [[two's complement||bitwise NOT + 1]] produces a number where all bits below the lowest 1 are identical and bits above are flipped, AND keeps only the lowest 1. **Practical use:** [[Fenwick tree||Binary Indexed Tree, data structure for prefix sums]], iterating over set bits.

Why do you need BigInt for 64-bit?

Because JavaScript **converts every bitwise op to 32-bit signed integer**. `(1 >`) work on BigInts with normal two's complement semantics. This tool uses BigInt internally for every width, guarantees correct 64-bit results.

How does rotation differ from a shift?

**Shift** drops bits past the edge and fills from the other side (0 or sign bit). **Rotation** wraps, bits leaving one side reappear on the other. Example in 8-bit: `0b10110000 << 1` = `0b01100000` (highest bit lost). `ROL 0b10110000 by 1` = `0b01100001` (highest 1 wrapped to position 0). **Used in crypto** (SHA-256 uses rotations heavily), **compression**, **hash algorithms**. Most CPU architectures have native ROL/ROR instructions.

How do I interpret arithmetic overflow?

In 8-bit unsigned: `200 + 100 = 300`, but 300 does not fit in 8 bits (max 255). **It wraps around**: `300 mod 256 = 44`. The tool flags this with a **yellow "Overflow" warning**. In 8-bit signed `100 + 50 = 150`, but max signed 8-bit is 127, the result wraps to a negative: `-106`. Most languages (Rust, Go, C in debug mode) **panic on overflow**, so it pays to know when it happens.

What are bit flags and when should I use them?

**A pattern: one number holds many booleans.** Define constants `FLAG_A = 1, FLAG_B = 2, FLAG_C = 4, FLAG_D = 8` (each a power of 2). **Set**: `flags |= FLAG_A | FLAG_C` (00000101). **Check**: `if (flags & FLAG_A)`. **Clear**: `flags &= ~FLAG_A`. **Pros**: 1 int = 32 booleans (memory savings, fast checks). **Cons**: readability. Use for **flag collections in protocols, configuration, file permissions, API options**. Avoid for 2-3 booleans, named fields read better.

How do I check if a number is a power of 2?

The classic trick: **`n > 0 && (n & (n - 1)) === 0`**. How it works: a power of 2 has **exactly one bit set**. `n - 1` zeros the lowest bit and sets all bits below. For a power of 2 their AND is 0. Example: `8 (0b1000) & 7 (0b0111) = 0`. Not a power: `6 (0b110) & 5 (0b101) = 4`. **Used in**: optimizations (power of 2 = shift instead of division), algorithms (segment tree, hashmap size), GPU programming (textures must be powers of 2).

Bitwise Operations Playground - free

Width

SignedTop bit as sign (two's complement)

ABIN

Bit grid (click to flip)

HEX

0x000000B4

OCT

0o264

DEC

180

DEC (signed)

180

BIN

0b00000000000000000000000010110100

BBIN

Bit grid (click to flip)

HEX

0x00000035

OCT

0o65

DEC

DEC (signed)

BIN

0b00000000000000000000000000110101

Shift n

Positions for shift / rotate

Bit index N

Bit for set / clear / toggle / test

Highlight differing bits

Logical operators

A AND B

A & B

HEX 0x00000034

OCT 0o64

DEC(u) 52

DEC(s) 52

BIN 0b00000000000000000000000000110100

A OR B

A | B

HEX 0x000000B5

OCT 0o265

DEC(u) 181

DEC(s) 181

BIN 0b00000000000000000000000010110101

A XOR B

A ^ B

HEX 0x00000081

OCT 0o201

DEC(u) 129

DEC(s) 129

BIN 0b00000000000000000000000010000001

NOT A

~A

HEX 0xFFFFFF4B

OCT 0o37777777513

DEC(u) 4294967115

DEC(s) -181

BIN 0b11111111111111111111111101001011

NOT B

~B

HEX 0xFFFFFFCA

OCT 0o37777777712

DEC(u) 4294967242

DEC(s) -54

BIN 0b11111111111111111111111111001010

Shifts and rotations

n = 2

A << 2

Left shift (×2 per position)

HEX 0x000002D0

OCT 0o1320

DEC(u) 720

DEC(s) 720

BIN 0b00000000000000000000001011010000

A >> 2

Arithmetic right shift (preserves sign)

HEX 0x0000002D

OCT 0o55

DEC(u) 45

DEC(s) 45

BIN 0b00000000000000000000000000101101

A >>> 2

Logical right shift (fills with 0)

HEX 0x0000002D

OCT 0o55

DEC(u) 45

DEC(s) 45

BIN 0b00000000000000000000000000101101

ROL A 2

Rotate left (bits wrap around)

HEX 0x000002D0

OCT 0o1320

DEC(u) 720

DEC(s) 720

BIN 0b00000000000000000000001011010000

ROR A 2

Rotate right (bits wrap around)

HEX 0x0000002D

OCT 0o55

DEC(u) 45

DEC(s) 45

BIN 0b00000000000000000000000000101101

Arithmetic

A + B

Addition (wraps on overflow)

HEX 0x000000E9

OCT 0o351

DEC(u) 233

DEC(s) 233

BIN 0b00000000000000000000000011101001

A - B

Subtraction (wraps on underflow)

HEX 0x0000007F

OCT 0o177

DEC(u) 127

DEC(s) 127

BIN 0b00000000000000000000000001111111

Bit tricks

bit N = 3

Set bit 3

A | (1 << 3)

HEX 0x000000BC

OCT 0o274

DEC(u) 188

DEC(s) 188

BIN 0b00000000000000000000000010111100

Clear bit 3

A & ~(1 << 3)

HEX 0x000000B4

OCT 0o264

DEC(u) 180

DEC(s) 180

BIN 0b00000000000000000000000010110100

Toggle bit 3

A ^ (1 << 3)

HEX 0x000000BC

OCT 0o274

DEC(u) 188

DEC(s) 188

BIN 0b00000000000000000000000010111100

Test bit 3

(A >> 3) & 1

Lowest set bit

A & -A

0b00000000000000000000000000000100

4 dec • 0x00000004

Popcount (set bits count)

Number of bits set to 1 in A

What does "&", "|", "^" mean in code and how do I set bit 5?

Bitwise operators are the foundation of many low-level tricks: permission masks (Unix `chmod`), bit flags, numeric optimizations (`x & 1` instead of `x % 2`), parsing network protocols (TCP flags, RGBA colors), memory management.

Type two numbers into A and B (as dec, hex 0x, bin 0b, oct 0o, auto-detected), pick a width (8-bit, 16-bit, 32-bit, 64-bit) and watch every operation live: AND, OR, XOR, NOT, shifts, rotations, popcount, lowest set bit.

Every result shown in a bit grid (click a bit to flip), in binary, dec (signed + unsigned), hex and oct. Computed with BigInt so 64-bit values work correctly even above `Number.MAX_SAFE_INTEGER`.

How to use it

Pick a width: 8 / 16 / 32 / 64 bits. Decides how many bits the operand has and how overflow is detected.

Enable Signed if you want values interpreted as two's complement (e.g. -1 in 8-bit = 0b11111111).

Enter A and B. Accepts every format: `255`, `0xFF`, `0b11111111`, `0o377`. Format auto-detected from the prefix.

Click a bit in the grid to flip it (toggle). Operations recompute immediately, all 12+ results update live.

For shifts and rotations set n with the slider. For single-bit ops (set/clear/toggle/test) set bit N.

"Highlight differing bits" shows in orange which bits the operation changed, perfect for seeing what `XOR` or `<<` actually does.

Copy any result in any format (BIN, HEX, OCT, DEC) with one click.

When this is useful

Real situations where you need to know bitwise operations:

Unix file permissions: `chmod 755` is a bitmask. `rwxr-xr-x` = `0b111101101` = 0o755 = 493 dec. Each bit is one flag (read/write/execute × owner/group/other).
TCP/IP flags: the TCP header has 9 flag bits (SYN, ACK, FIN, RST, PSH, URG...). A parser decodes them with masks: `flags & 0x01` is FIN, `flags & 0x02` is SYN, etc.
RGBA colors: 32-bit packs 4 channels of 8 bits each. `red = (color >> 24) & 0xFF`, `green = (color >> 16) & 0xFF`, and so on.
Configuration flags: C/Rust libraries pass dozens of options as a single int. `OPT_ASYNC | OPT_VERBOSE | OPT_RETRY`. Check: `if (opts & OPT_ASYNC)`.
Hash functions and crypto: implementations of MD5, SHA, AES use rotations (`ROL`, `ROR`), XORs and shifts. Usually 32-bit.
Bitmap indexes in databases: Postgres, Oracle, MySQL use bitwise ops for filtering.
Hardware GPIO: Arduino, ESP32, Raspberry Pi control pins with `PORTB |= (1 << 5)`. Each bit = pin state.
Network address masks: `192.168.1.0/24` is mask `0xFFFFFF00`. To check if an IP is in the network: `(ip & mask) == network`.
Algorithms: bitset as a compact set, Brian Kernighan for popcount, Sieve of Eratosthenes on bits, Fenwick tree.

To convert between number bases, see our number base converter. For byte size conversions, see file size converter.

Questions and answers

`>>` is arithmetic right shift: preserves the sign bit. `-8 >> 1` = `-4` (for negative numbers it "replicates" the 1 on the left). `>>>` is logical right shift: fills with zeros. `-8 >>> 1` = `2147483644` (treats bits as unsigned). Most languages only have `>>` (and it respects the signed/unsigned type of the variable). JavaScript has both because every number is converted to 32-bit signed for bitwise ops.

What does "&", "|", "^" mean in code and how do I set bit 5?

How to use it

Pick a width: 8 / 16 / 32 / 64 bits. Decides how many bits the operand has and how overflow is detected.

Enable Signed if you want values interpreted as two's complement (e.g. -1 in 8-bit = 0b11111111).

Enter A and B. Accepts every format: `255`, `0xFF`, `0b11111111`, `0o377`. Format auto-detected from the prefix.

Click a bit in the grid to flip it (toggle). Operations recompute immediately, all 12+ results update live.

For shifts and rotations set n with the slider. For single-bit ops (set/clear/toggle/test) set bit N.

"Highlight differing bits" shows in orange which bits the operation changed, perfect for seeing what `XOR` or `<<` actually does.

Copy any result in any format (BIN, HEX, OCT, DEC) with one click.

When this is useful

Real situations where you need to know bitwise operations:

Unix file permissions: `chmod 755` is a bitmask. `rwxr-xr-x` = `0b111101101` = 0o755 = 493 dec. Each bit is one flag (read/write/execute × owner/group/other).
TCP/IP flags: the TCP header has 9 flag bits (SYN, ACK, FIN, RST, PSH, URG...). A parser decodes them with masks: `flags & 0x01` is FIN, `flags & 0x02` is SYN, etc.
RGBA colors: 32-bit packs 4 channels of 8 bits each. `red = (color >> 24) & 0xFF`, `green = (color >> 16) & 0xFF`, and so on.
Configuration flags: C/Rust libraries pass dozens of options as a single int. `OPT_ASYNC | OPT_VERBOSE | OPT_RETRY`. Check: `if (opts & OPT_ASYNC)`.
Hash functions and crypto: implementations of MD5, SHA, AES use rotations (`ROL`, `ROR`), XORs and shifts. Usually 32-bit.
Bitmap indexes in databases: Postgres, Oracle, MySQL use bitwise ops for filtering.
Hardware GPIO: Arduino, ESP32, Raspberry Pi control pins with `PORTB |= (1 << 5)`. Each bit = pin state.
Network address masks: `192.168.1.0/24` is mask `0xFFFFFF00`. To check if an IP is in the network: `(ip & mask) == network`.
Algorithms: bitset as a compact set, Brian Kernighan for popcount, Sieve of Eratosthenes on bits, Fenwick tree.

To convert between number bases, see our number base converter. For byte size conversions, see file size converter.

Questions and answers

Bitwise Operations Playground

Logical operators

Shifts and rotations

Arithmetic

Bit tricks

What does "&", "|", "^" mean in code and how do I set bit 5?

How to use it

When this is useful

Questions and answers

Related tools

Number Base Converter

Regex tester

Word and Character Counter

Bitwise Operations Playground

Logical operators

Shifts and rotations

Arithmetic

Bit tricks

What does "&", "|", "^" mean in code and how do I set bit 5?

How to use it

When this is useful

Questions and answers

Related tools

Number Base Converter

Regex tester

Word and Character Counter