Hex Bitwise Calculator — XOR, Shifts, All Bases

Code reference: bitwise and base conversion across languages

Every language spells a hex literal 0xFF, but octal splinters into 0377, 0o377, or no support at all, and bitwise XOR ranges from ^ to PostgreSQL's # to PowerShell's -bxor. Here is the literal syntax, operator set, and multi-base formatting for each language, so a value you worked out in the browser drops cleanly into the source you actually ship.

Number literal syntax by language

Underscores as digit separators (0xFF_FF_FF_FF) are accepted in Rust, Go, Java 7+, C# 7+, Swift, Kotlin, Python 3.6+, and Ruby. C and C++ require single quotes instead (0xFF'FF'FF'FF). PHP and JavaScript use the same single-underscore form in 7.4+ and ES2021.

Bitwise operations and multi-base output

Systems languages: C, C++, Rust, Go

The full operator set is identical across these four: &, |, ^, ~, <<, >>. Signedness matters for right shift. An unsigned right shift fills with zero, a signed right shift on a negative value fills with one. C, C++, and Go pick behavior based on the variable’s type. Rust requires an explicit unsigned or signed type at the binding site.

JVM and .NET: Java, Kotlin, C#, Swift

Java is the outlier with its dedicated >>> triple-arrow for logical right shift. Kotlin spells operators as keywords: and, or, xor, inv, shl, shr, ushr. C# and Swift route through the unsigned type to force zero-fill. C# 11 added >>> matching Java syntax.

JavaScript and TypeScript

const a = 0xFFFFFFFFn;
const b = 0x0F0Fn;
const c = a ^ b;
console.log(c.toString(16).toUpperCase()); // "FFFFF0F0"
console.log(c.toString(10));                // "4294967280"
console.log(c.toString(8));                 // "37777770360"
console.log(c.toString(2));                 // "11111111111111111111000011110000"

The n suffix marks BigInt literals. Mixing BigInt and Number in the same expression throws a TypeError. Convert one side first with BigInt(x) or Number(x).

Scripting: Python, Ruby, PHP, Perl

Python and Ruby integers grow without bound, so NOT on a positive value returns a negative because the result is interpreted as infinitely-wide two’s complement. To recover the 32-bit unsigned view: (~x) & 0xFFFFFFFF. The same mask applies to Perl’s ~ operator on platforms where the integer width is configurable at build time.

Shells: Bash, Zsh, PowerShell

Bash arithmetic context ($(( ))) covers &, |, ^, ~, <<, >>. PowerShell spells the same operators out as -band, -bor, -bxor, -bnot, -shl, -shr. Both default to 64-bit signed math, so a value above 0x7FFFFFFFFFFFFFFF overflows silently in Bash and wraps to a negative in PowerShell.

Databases: PostgreSQL, MySQL, SQLite

PostgreSQL is the outlier. Its XOR operator is #, and ^ is exponentiation. MySQL and SQLite follow C convention. None of the three has a built-in binary-string formatter, so binary output usually requires a recursive CTE that divides the value by two and concatenates the remainder.

Common hex constants and bit patterns

The poison patterns (0xDEADBEEF, 0xBAADF00D, 0xFEEDFACE) appear in uninitialized memory or unmapped regions on many platforms. They are chosen to be visibly wrong in a debugger and pronounceable when read aloud during a pairing session.

Width and signedness: NOT and shift across languages

The pattern: anything with a fixed-width type has a sensible NOT. Anything with arbitrary-precision integers (Python, Ruby, JavaScript BigInt) treats NOT as infinitely-wide two’s complement and requires an explicit mask to recover the byte or word view that the embedded world expects.

Related concepts

• Two’s complement: how negative integers are encoded as bit patterns and why ~x equals -(x+1) for any fixed-width signed type.
• Endianness: byte order for multi-byte values in memory. 0x1234 may be stored as 12 34 (big-endian) or 34 12 (little-endian).
• Hamming weight: the count of set bits in a value. Reachable in most languages as popcount, bitCount, or bit_count.
• Bit fields and packed structs: C and C++ syntax for naming individual bit ranges inside a single integer.
• De Bruijn sequences: a technique for finding the lowest set bit in constant time using a small lookup table.