base-n

The app holds exactly one thing: a pattern of bits, as wide as you say. Every panel on the page is a different way of looking at that same pattern — as a binary string, as a decimal number, as a float, as bytes in memory.

Change it anywhere and everything else follows. Type a hex digit, click a bit, run a calculation: the value moves in one place and every panel redraws from it. Because nothing is converted twice, no two panels can ever disagree with each other.

Two settings decide how that pattern is read: data width, which says how many bits there are, and representation, which says what they mean. Everything else on the page follows from those two.

Anything from 4 to 256 bits. Use a preset button, or type an exact number in the box — 12, 24 and 48 are all legal. In the two float modes the width is fixed by the format, so the box is disabled.

Changing the width keeps the value where it can:

• Widening preserves the value. In Signed mode the sign bit is extended, so -1 in 8 bits (1111 1111) becomes -1 in 16 bits (1111 1111 1111 1111), not 255.
• Narrowing drops the high bits. If the value no longer fits you get an overflow indicator telling you what was kept.

Four ways to read the same bits. Note what the decimal field means in each — in the float modes it is the value, while binary, octal and hex are the stored bit pattern.

Switching between modes does one of two things, and the difference matters:

• Between Unsigned, Signed and a float mode, the bit pattern is kept — a reinterpret cast. The unsigned 32-bit value 42 becomes 5.9e-44 in Float32, because that is genuinely what those bits mean as a float. This is the useful direction for reading a raw register dump.
• Between Float32 and Float64, the value is kept and re-encoded. A single-precision 0.1 becomes the double nearest to it.

These change how values are written, never what is stored. Grouping separators are ignored when you type, so you can paste a grouped value straight back in.

A red outline with a message under the field means the text isn't valid for that base — a 2 in the binary field, say. Nothing is stored until it parses.

Press Enter to normalise a field: it is rewritten with your current padding, grouping and case settings. Copy puts exactly what you see on the clipboard, separators and all.

A red bar under the fields says what was kept instead, and the field you typed in is outlined. It clears as soon as you enter a value that fits. Four things set it off:

The value is still stored in every case — wrapped, truncated or saturated to infinity, exactly as hardware would. The indicator tells you that what came out is not what you put in.

Bits run from the most significant on the left to bit 0 on the right, in rows of 16 (8 on a narrow screen). The numbers in the margins are the bit indices at each end of the row, and the small gaps fall on byte boundaries. Click any bit to flip it — every other panel updates as you do.

In the float modes each bit is tinted by the field it belongs to, and the coloured underline shows how far each field reaches even where the bits are zero.

A float is three fields packed into one word: a sign bit, a biased exponent and a mantissa. For -22.5 in Float32 (0xC1B40000) they come out like this:

The panel reads each one back for you. The sign bit is 1, so the number is negative. The exponent field holds 131; subtract the bias of 127 and the real exponent is 4. The mantissa is 0x340000, which with its implied leading 1 makes a significand of 1.40625. Put together: (−1)1 × 24 × 1.40625 = −22.5.

The exponent field is also how you tell the classes apart, which is worth knowing when you are staring at a bit pattern:

Two facts underneath are worth singling out:

• Exact decimal is the value in full, every digit of it. A binary float always terminates in decimal, so this is not a rounded display — it is why single-precision 0.1 reads as 0.100000001490116119384765625. This is the number your program is actually working with.
• Step to next value is the gap to the next representable float — one unit in the last place. It is how much precision you have left at this magnitude, and it grows as the value does.

Addresses run left to right from 0, so each row reads in the order the bytes appear in memory. Big-endian puts the most significant byte first; little-endian puts the least significant byte first, which is what x86 and ARM do by default. The highlighted byte is the one holding bit 0 — last in big-endian, first in little-endian.

So 0xC1B40000 is stored as C1 B4 00 00 on a big-endian machine and 00 00 B4 C1 on a little-endian one. Reading a memory dump from the wrong end is the usual reason a float comes out as nonsense.

Widths that are not a whole number of bytes are padded up with zeros at the top, and the panel says so.

Each operand has its own base selector, so you can add a hex value to a decimal one without converting first. Load converter value into A pulls in whatever the converter is holding; Send result to converter pushes the answer back. Press Enter in either operand to calculate.

Integer division truncates toward zero, so −7 ÷ 2 is −3, not −4, and mod takes its sign from the left operand. Dividing by zero is refused in integer modes; in the float modes it produces infinity, as IEEE-754 requires.

The result is shown in all four bases at once, and flags appear as chips:

Float arithmetic is rounded to the working precision after every step, which is why 0.1 + 0.2 lands exactly on 0.3 in Float32 but gives 0.30000000000000004 in Float64. Switch between the two modes and run it again to watch it happen.

Your width, representation, display options, current value and colour theme are saved in this browser and restored when you come back. Clearing site data resets everything to a 32-bit unsigned zero. Nothing is stored anywhere else.

• Everything runs in this tab. No value you type is sent anywhere, and the app works offline once loaded.
• Integer maths is exact at any width — a 256-bit multiply is computed in full before it is wrapped into the register.
• Float maths uses your machine's own IEEE-754 arithmetic rather than a simulation of it, so results match what your compiler would produce.
• In the decimal field of a float mode, e on its own means Euler's number. Exponent notation needs a mantissa in front of it — 1e5, not e5.