Guide

THE TOOLBOX / SYSTEMS & NUMERIC UTILITIES

Convert bases, bits &
IEEE 754 floats.

Translate 8/16/32/64-bit integers across Hex, Binary, Octal, and Decimal with signed Two’s Complement math, interactive bit toggles, and IEEE 754 float decomposition.

RADIX, TWO'S COMPLEMENT & IEEE 754
Interactive Bit Toggles (MSB → LSB, Click to Flip)
●   Native 64-bit BigInt & DataView
SYNCHRONIZED REGISTER & BIT LAYOUT

Computed 32-bit register representations.

Decimal (Unsigned)
255
Decimal (Signed Two's Complement)
255
Hexadecimal
0x000000FF (00 00 00 FF)
Octal
0o377
Binary (Nibbles)
0000 0000 0000 0000 0000 0000 1111 1111

THE DETAILS

64-bit BigInt radix conversion, Two’s Complement signed arithmetic, and IEEE 754-2019 floating-point layout.

1. Arbitrary-Precision 64-Bit BigInt Engine

Systems programmers debugging kernel pointers, Snowflake IDs, or Rust/Go u64/i64 registers need exact bit-level fidelity above 2^53 - 1. By operating directly on ECMAScript BigInt bitmasks ((1n << 64n) - 1n), every nibble and bit remains exact up to 0xFFFFFFFFFFFFFFFF.

2. Signed Two’s Complement Registers

Select 8-bit, 16-bit, 32-bit, or 64-bit register width to inspect both the unsigned interpretation (0 to 2^N - 1) and the signed Two’s Complement interpretation (-2^(N-1) to 2^(N-1) - 1) simultaneously.

3. Bitwise ALU & Interactive Bit Flipping

Click any individual bit in the interactive MSB→LSB bit grid to toggle flags in real time, or switch to the Bitwise ALU tab to evaluate AND, OR, XOR, NAND, NOR, and bit-shift expressions across hex and decimal operands.

4. IEEE 754 Single & Double Precision Inspector

Using hardware-native ArrayBuffer and DataView byte manipulation, the IEEE 754 Float tab decomposes any decimal number into its exact binary32 (1 sign bit, 8-bit exponent with bias 127, 23-bit mantissa) and binary64 (1 sign bit, 11-bit exponent with bias 1023, 52-bit mantissa) bit patterns. Need Unix permission bitmasks or IPv4/IPv6 subnet masks? Try the Chmod Calculator or CIDR Subnet Calculator.

Integer Register Widths & IEEE 754 Precision Comparison Matrix

Register / TypeUnsigned RangeSigned Two’s Complement RangeHex Width / Layout
8-bit (int8 / uint8)0 to 255-128 to 1270x00 – 0xFF (1 byte)
16-bit (int16 / uint16)0 to 65,535-32,768 to 32,7670x0000 – 0xFFFF (2 bytes)
32-bit (int32 / uint32)0 to 4,294,967,295-2,147,483,648 to 2,147,483,6470x00000000 – 0xFFFFFFFF
64-bit (int64 / uint64)0 to 18,446,744,073,709,551,615-9.22 × 10^18 to 9.22 × 10^1816 hex digits (8 bytes)
IEEE 754 binary32 / binary64Sign (1b) + Exp (8b / 11b)Mantissa (23b / 52b + hidden 1)Bias 127 (f32) / 1023 (f64)

Common Bitwise & Numeric Pitfalls

JavaScript 32-Bit Bitwise Truncation

In JavaScript, applying | 0 or << to a standard Number truncates it to a signed 32-bit integer (`ToInt32`). Always use BigInt literals (1n << 40n) when manipulating 64-bit masks.

Sign Extension on Narrow Loads

Casting a signed 8-bit -1 (0xFF) to a signed 32-bit integer sign-extends the leading 1 bit into 0xFFFFFFFF, whereas zero-extending an unsigned uint8 yields 0x000000FF (255).

Subnormal (Denormalized) Floats

When the biased exponent field is all zeros (00000000) and the mantissa is non-zero, IEEE 754 drops the implicit leading 1. bit to represent gradual underflow near zero.

Signed Zero (+0 vs. -0)

IEEE 754 defines distinct bit patterns for +0.0 (0x00000000) and -0.0 (0x80000000). While +0 === -0 evaluates to true, Object.is(+0, -0) and 1 / -0 === -Infinity distinguish them.

Frequently Asked Questions

Why do standard JavaScript calculators lose accuracy above 9,007,199,254,740,991?

Standard JavaScript Numbers are IEEE 754 double-precision (64-bit) floats with only 53 bits of significand precision (Number.MAX_SAFE_INTEGER = 2^53 - 1). Any 64-bit integer above that threshold rounds low-order bits silently. Our converter uses native arbitrary-precision BigInt math so 64-bit memory addresses, database snowflake IDs, and uint64 bitmasks remain 100% exact.

How does Two’s Complement represent negative integers in binary and hex?

In an N-bit Two’s Complement system, the most significant bit (MSB, bit N-1) has a negative weight of -2^(N-1). To negate an integer, invert all bits (one’s complement) and add 1. Consequently, -1 is always represented as all ones: 0xFF in 8-bit, 0xFFFF in 16-bit, 0xFFFFFFFF in 32-bit, and 0xFFFFFFFFFFFFFFFF in 64-bit.

Why does 0.1 + 0.2 equal 0.30000000000000004 in IEEE 754 floating-point math?

In base 10, 1/10 (0.1) is a terminating fraction, but in base 2 (binary), 1/10 is an infinitely repeating fraction (0.0001100110011...). When rounded to fit a 23-bit (float32) or 52-bit (float64) mantissa, a tiny representation error remains, which you can inspect directly in the IEEE 754 Float tab.

What is the difference between arithmetic right shift (>>) and logical right shift (>>>)?

An arithmetic right shift preserves the sign bit (MSB) by filling vacated high-order bits with copies of the sign bit, whereas a logical unsigned right shift fills vacated high-order bits with zeros.

Are my register values or memory addresses sent over the network?

No. All base conversions, Two’s Complement masking, bitwise ALU operations, and DataView IEEE 754 float inspections run 100% locally in your browser.