Julia Bitwise Operators

Julia Bitwise Operators

Julia bitwise operators work on the individual binary digits of integer values. They are used for bit masks, flags, binary data, low-level protocols, permissions, and other operations where each bit has a specific meaning.

This tutorial covers bitwise NOT, AND, OR, XOR, left shift, arithmetic right shift, and logical right shift. It also explains the difference between bitwise operators and Julia’s short-circuit Boolean operators.

Julia Bitwise Operators List

The following table lists the bitwise operators available in Julia.

Expression	Name	Operation
~x	bitwise NOT	Flips every bit in x
x & y	bitwise AND	Sets a result bit when both corresponding bits are 1
x | y	bitwise OR	Sets a result bit when either corresponding bit is 1
x ⊻ y	bitwise XOR	Sets a result bit when the corresponding bits differ
x >>> y	logical right shift	Shifts bits right and fills the left side with zeros
x >> y	arithmetic right shift	Shifts bits right while preserving the sign for signed integers
x << y	left shift	Shifts bits left and fills the right side with zeros

Julia uses the Unicode character ⊻ for infix bitwise XOR. In the Julia REPL or many editors, it can be entered by typing \xor and pressing Tab. The function form xor(x, y) can be used when entering the Unicode character is inconvenient.

Reading Bitwise Results in Binary

Bitwise operations are easier to understand when the operands are written in binary. For example, decimal 10 is binary 1010, while decimal 25 is binary 11001.

x = 10
y = 25

println(bitstring(x))
println(bitstring(y))

The bitstring function displays the complete fixed-width binary representation of a primitive value. The number of displayed bits depends on the value’s type, such as Int64, UInt8, or UInt32.

Julia Bitwise NOT Operator

Bitwise NOT

julia> x = 10
10

julia> ~x
-11

The bitwise NOT operator ~ flips every bit: each 0 becomes 1, and each 1 becomes 0. For signed integers represented using two’s complement, the relationship ~x == -x - 1 holds. Therefore, ~10 evaluates to -11.

x = UInt8(10)
result = ~x

println(result)
println(bitstring(x))
println(bitstring(result))

245
00001010
11110101

Using UInt8 makes the eight-bit complement visible without interpreting the highest bit as a sign bit.

Julia Bitwise AND Operator

Bitwise AND

julia> x = 10
10

julia> y = 25
25

julia> x & y
8

The bitwise AND operator & produces a 1 only where both operands have a 1 in the same bit position.

01010   (10)
11001   (25)
-----
01000   (8)

Bitwise AND is commonly used with a mask to test whether selected bits are set.

READ_PERMISSION = 0b100
permissions = 0b110

has_read_permission = (permissions & READ_PERMISSION) != 0
println(has_read_permission)

true

Julia Bitwise OR Operator

Bitwise OR

julia> x = 10
10

julia> y = 25
25

julia> x | y
27

The bitwise OR operator | produces a 1 where either operand has a 1 in the corresponding position.

01010   (10)
11001   (25)
-----
11011   (27)

Bitwise OR is often used to combine independent flags into one integer.

READ = 0b100
WRITE = 0b010
EXECUTE = 0b001

permissions = READ | WRITE
println(bitstring(UInt8(permissions)))

00000110

Julia Bitwise XOR Operator

Bitwise XOR

julia> x = 10
10

julia> y = 25
25

julia> x ? y
19

In current Julia syntax, bitwise XOR is written as x ⊻ y or xor(x, y). The question mark is associated with Julia’s conditional operator and is not the bitwise XOR operator.

x = 10
y = 25

println(x ⊻ y)
println(xor(x, y))

19
19

XOR produces a 1 when the corresponding operand bits are different and a 0 when they are the same.

01010   (10)
11001   (25)
-----
10011   (19)

Applying the same XOR mask twice restores the original value because (x ⊻ mask) ⊻ mask equals x.

value = 42
mask = 0b1010

encoded = value ⊻ mask
decoded = encoded ⊻ mask

println(encoded)
println(decoded)

32
42

Logical Right Shift with Julia >>>

Logical Shift Right

julia> x = 25
25

julia> x >>> 2
6

The logical right-shift operator >>> moves bits to the right and inserts zeros from the left. Bits shifted beyond the right edge are discarded.

00011001   (25)
>>> 2
00000110   (6)

The difference between logical and arithmetic right shifts is most visible with negative signed integers. Logical right shift does not extend the sign bit.

x = Int8(-8)

println(x >>> 1)
println(bitstring(x >>> 1))

124
01111100

Arithmetic Right Shift with Julia >>

Arithmetic Shift Right

julia> x = 25
25

julia> x >> 2
6

The arithmetic right-shift operator >> moves bits to the right. For a negative signed integer, it fills the new positions on the left with 1 bits so that the sign is preserved.

x = Int8(-8)

println(x >> 1)
println(bitstring(x >> 1))

-4
11111100

For positive values, >> and >>> normally produce the same numeric result because the sign bit is already zero.

Left Shift with Julia <<

Logical/Arithmetic Shift Left

julia> x = 25
25

julia> x << 1
50

The left-shift operator << moves bits to the left, inserts zeros on the right, and discards bits that move outside the value’s fixed width.

00011001   (25)
<< 1
00110010   (50)

For values that remain within the integer type’s range, shifting left by n positions has the same numeric effect as multiplying by 2^n. Fixed-width integer shifts can discard high-order bits, so the result is not always equivalent to unrestricted mathematical multiplication.

x = 7
shift = 3

println(x << shift)
println(x * 2^shift)

56
56

Bitwise Operators and Boolean Operators in Julia

Bitwise operators should not be confused with Julia’s short-circuit Boolean operators. The operators & and | evaluate both operands and perform an operation on corresponding bits. The operators && and || are used for conditional logic and may skip evaluation of the right operand.

Operator	Purpose	Short-circuits
&	Bitwise AND	No
|	Bitwise OR	No
⊻	Bitwise XOR	No
&&	Conditional AND	Yes
||	Conditional OR	Yes

function check_value()
    println("Right operand evaluated")
    return true
end

false && check_value()
true || check_value()

In both expressions above, check_value() is skipped because the left operand already determines the result.

Bit Masks and Flags with Julia Bitwise Operators

A bit mask lets one integer represent several independent on-or-off settings. OR can enable a flag, AND can test or retain selected flags, XOR can toggle a flag, and AND with a complemented mask can clear a flag.

READ = UInt8(0b100)
WRITE = UInt8(0b010)
EXECUTE = UInt8(0b001)

permissions = READ | WRITE
println(bitstring(permissions))

permissions |= EXECUTE
println(bitstring(permissions))

has_write = (permissions & WRITE) != 0
println(has_write)

permissions &= ~WRITE
println(bitstring(permissions))

00000110
00000111
true
00000101

The typed constants in this example keep all operations within eight bits. This makes complements and masks easier to reason about.

Element-Wise Bitwise Operations on Julia Arrays

Julia’s dot syntax applies bitwise operations element by element. Operators such as .&, .|, and .⊻ can be used with arrays and compatible broadcastable values.

values = UInt8[0b0011, 0b0101, 0b1110]
mask = UInt8(0b0110)

println(values .& mask)
println(values .| mask)
println(values .⊻ mask)

UInt8[0x02, 0x04, 0x06]
UInt8[0x07, 0x07, 0x0e]
UInt8[0x05, 0x03, 0x08]

Julia may display unsigned integer array values in hexadecimal. The values are still integers and can be inspected in binary with bitstring.

Bitwise Updating Assignment Operators in Julia

Julia provides updating forms for its bitwise operators. Each form performs the operation and assigns the result back to the variable.

Updating expression	Equivalent expression
x &= y	x = x & y
x |= y	x = x | y
x ⊻= y	x = x ⊻ y
x <<= y	x = x << y
x >>= y	x = x >> y
x >>>= y	x = x >>> y

flags = UInt8(0b0010)

flags |= UInt8(0b1000)
println(bitstring(flags))

flags ⊻= UInt8(0b0010)
println(bitstring(flags))

00001010
00001000

Common Julia Bitwise Operator Mistakes

• Using ? for XOR. Julia’s bitwise XOR operator is ⊻, and its function form is xor.
• Using & or | when conditional short-circuit behavior is required. Use && or || for Boolean control flow.
• Assuming >> and >>> behave identically for negative signed integers.
• Ignoring the integer type’s bit width when applying complements or shifts.
• Assuming a left shift can never overflow or discard high-order bits.
• Reading an unsigned hexadecimal display as a different kind of value rather than another representation of an integer.

Julia Bitwise Operators FAQ

What is the bitwise XOR operator in Julia?

Julia uses ⊻ for bitwise XOR. The expression x ⊻ y can also be written as xor(x, y). In supported editors, type \xor followed by Tab to enter the symbol.

What is the difference between | and || in Julia?

The | operator performs bitwise OR and evaluates both operands. The || operator performs short-circuit conditional OR and evaluates its right operand only when the left operand is false.

What is the difference between >> and >>> in Julia?

The >> operator performs an arithmetic right shift and preserves the sign of a negative signed integer. The >>> operator performs a logical right shift and inserts zeros on the left.

How do I test whether a bit is set in Julia?

Apply a bit mask with AND and compare the result with zero. For example, (value & mask) != 0 is true when at least one bit selected by the mask is set.

How do I display an integer as binary in Julia?

Use bitstring(value) to display the complete fixed-width bit pattern. The string(value, base=2) form can be used when a shorter base-2 textual representation is preferred.

Editorial QA Checklist for Julia Bitwise Operators

• Confirm that the XOR operator is shown as ⊻ or xor, not as a question mark.
• Verify that & and | are clearly distinguished from && and ||.
• Check negative signed-integer examples for the different behavior of >> and >>>.
• Confirm that complement and shift examples specify a fixed-width type when the bit width affects the result.
• Run all added Julia examples and verify that their outputs and binary representations match the stated integer types.

Conclusion

In this Julia Tutorial, we learned how Julia’s bitwise NOT, AND, OR, XOR, left-shift, arithmetic right-shift, and logical right-shift operators work. We also covered binary representations, bit masks, updating assignments, element-wise array operations, and the distinction between bitwise and short-circuit Boolean operators.