Hexadecimal Calculator – Convert and Calculate in Base 16

Related tools

How it works, in three steps

One number, four spellings: the probed conversions

The default conversion is the one every hex learner meets first. Type FF in hexadecimal and the panel shows decimal 255, binary 11111111 (displayed grouped as 1111 1111), octal 377, 2 hex digits, and 8 bits, with the sentence: FF is 8 bits, because one hex digit holds exactly 4 bits. Every figure in this section was read from the calculator’s own displayed results for the stated inputs. Work backwards and it checks: F is 15, so FF means 15 times 16 plus 15, which is 255, and the base guide’s own check for 255 to hex is the reverse division, 255 divided by 16 is 15 remainder 15, and both remainders are 15, which is F, so decimal 255 is hex FF.

Change the base and the same value appears in all four spellings at once. Type 255 in decimal and the panel shows hex FF, decimal 255, binary 1111 1111, and octal 377 — the same four answers as typing FF, because it is the same number. Type 1010 in binary and the panel shows hex A, decimal 10, binary 1010, and octal 12, with 1 hex digit and 4 bits: 1010 in binary is 8 + 2 = 10, and 10 in hex is the single digit A. Type 777 in octal and the panel shows hex 1FF, decimal 511, binary 111111111 (grouped 1 1111 1111), and octal 777, with 3 hex digits and 12 bits: 7 times 64 plus 7 times 8 plus 7 is 448 + 56 + 7 = 511, and 511 in hex is 1FF, because 1 times 256 plus 15 times 16 plus 15 is 256 + 240 + 15 = 511.

The last two rows need their own notes. A leading minus sign means a negative value written as minus followed by the magnitude: −1A means negative 26, shown as decimal −26, binary −11010, and octal −32, with 2 digits and 8 bits counted on the magnitude. That is not two’s complement notation, where the same bits mean something different depending on the width you assume, as the base guide warns — if you need two’s complement for a fixed width, convert the magnitude here first and then apply your width rule separately. And the very large row is the exactness proof: sixteen F’s convert to 18,446,744,073,709,551,615 in decimal, with 16 hex digits and 64 bits, computed by exact integer arithmetic with no floating-point rounding, as the base guide promises. There is no fixed size limit in the calculator itself, only what your browser can display.

Hex arithmetic: four probed sums, and the carry that makes a new digit

Switch to the hex arithmetic tab and the panel answers in hex and decimal together. The default arithmetic example, 1A plus 2B, equals 45 in hex, which is 69 in decimal: 26 + 43 = 69, and 69 in hex is 4 times 16 plus 5, which is 45. Every figure in this section was read from the calculator’s own displayed results for the stated inputs, with the arithmetic tab selected. Subtraction goes negative in the same plain way as conversion: 1A minus 2B equals −11 in hex, which is −17 in decimal, because 26 − 43 = −17, and −17 in hex is minus 11, since 1 times 16 plus 1 is 17. Multiplication is exact for large values too: FF times 2 equals 1FE in hex, which is 510 in decimal, because 255 × 2 = 510, and 510 in hex is 1 times 256 plus 15 times 16 plus 14, which is 256 + 240 + 14 = 510.

The most instructive sum is the smallest one: FF plus 1 equals 100 in hex, which is 256 in decimal. In decimal, 99 + 1 = 100 carries into a new digit; in hex, FF + 1 = 100 carries the same way, because F is the largest single hex digit, just as 9 is the largest single decimal digit. That carry is the whole reason the base guide’s common values list reads the way it does: 0 is 0, 10 in hex is 16, 7F is 127, FF is 255, 100 in hex is 256, and 1A3 is 419. Each of those landmarks is a carry boundary or a digit boundary, and misreading 10 in hex as ten, instead of sixteen, is the single most common hex mistake — the panel’s decimal answer beside every hex answer exists to catch exactly that slip.

Two input habits are worth confirming, because both were probed. Lowercase letters work and are normalised to uppercase in the display: typing ff in hex shows hex FF, decimal 255, binary 1111 1111, and octal 377, exactly as typing FF does, because the base guide states that A to F work in either case. Leading zeros are likewise harmless and are dropped in the display: typing 00FF shows hex FF with 2 digits and 8 bits, not 4 digits, because the value is 255 and the zeros contribute nothing. The 0x prefix is optional, as the base guide states: it is just a label that says the digits that follow are hexadecimal, common in programming and in colour codes, and FF and 0xFF mean the same value here.

Place value, digit by digit, and the binary shortcut

Converting is not guesswork, it is place value with 16 instead of 10, as the base guide says, and the page’s own table for 1A3 is the model. Each position is worth a power of 16, starting from 16 to the power 0 on the right: the digit 1 is worth 1, at place 16 squared = 256, contributing 256; the digit A is worth 10, at place 16 to the power 1 = 16, contributing 160; the digit 3 is worth 3, at place 16 to the power 0 = 1, contributing 3; and 256 + 160 + 3 = 419. Start at the right, as the base guide advises: the rightmost digit counts ones, the next counts sixteens, the next counts 256s, and each step left multiplies the place by 16 again. Letters are just digits past 9: A is 10, B is 11, C is 12, D is 13, E is 14, and F is 15.

The reverse direction, decimal to hex, is division with remainders, and the base guide’s 255 example is the model: 255 divided by 16 is 15 remainder 15, and both remainders are 15, which is F, so decimal 255 is hex FF. For a larger number, repeat: divide by 16, keep the remainder as the next hex digit from the right, and divide the quotient again until the quotient is zero. The panel does this for you, but knowing the method lets you check a single digit by hand: for 511, 511 divided by 16 is 31 remainder 15 (F), 31 divided by 16 is 1 remainder 15 (F), and 1 divided by 16 is 0 remainder 1, giving 1FF from the last remainder backwards — which matches the panel’s octal-777 conversion exactly.

The binary shortcut is why base 16 exists at all. Computers work in binary, but long binary strings are hard for people to read and easy to mistype, and hexadecimal is a compact shorthand for binary: every hex digit maps to exactly 4 bits, because 16 is 2 to the power 4, and four binary digits can hold exactly 16 different values, from 0000 to 1111, which is exactly the range of one hex digit, from 0 to F. That is why a byte, which is 8 bits, is always exactly two hex digits, and why you see hex in colour codes like #FF5733, in memory addresses, in network settings, and in file formats, as the base guide notes. To convert binary to hex by hand, group the binary digits in fours from the right and read each group as one hex digit: 1111 1111 groups as F F, and 1 1111 1111 groups as 1 F F, which is the panel’s grouping for 511.

Invalid input, negative numbers, and what this page does not do

Invalid input on this page fails quietly rather than loudly, and it is worth knowing the behaviour before you trust a result you did not expect. In probes of the page, typing G in hexadecimal mode left the panel showing the previous valid result, FF with decimal 255, rather than an error or a zero; typing 2 in binary mode, where only 0 and 1 are valid, did the same, leaving the previous FF result unchanged. The pattern matches the factorial page’s negative-input behaviour in this batch: an entry the page cannot interpret does not produce a new result, and the display keeps the last valid answer. So if the panel does not change after you type, do not read the old answer as the answer to your new input — check that every digit is valid for the base you selected, and re-enter it.

Negative numbers follow the plainest convention, and the base guide is explicit about its limits. A leading minus sign means a negative value, written as minus followed by the magnitude: −1A means negative 26. That is not two’s complement notation, because that meaning depends on a fixed bit width that you would have to choose separately, and this page does not ask you for a width. For programming or hardware work where bit width matters, the base guide’s closing advice applies: check the convention your platform uses, convert the magnitude here first, and then apply your width rule separately. The same caution covers the digit and bit counts for negative values, which are counted on the magnitude: −1A shows 2 digits and 8 bits, the same as 1A, because the minus sign is not a digit and carries no bits of its own.

Finally, what this page does not do is as useful as what it does. It converts and calculates in base 16, base 10, base 2, and base 8, and its arithmetic mode adds, subtracts, and multiplies two hex numbers — it does not divide, it does not convert fractions or decimals with fractional parts, and it does not apply two’s complement, fixed-width, or floating-point conventions. The base guide’s closing note states the scope plainly: this is a general-purpose math tool, negative hex values here use a minus sign in front of the magnitude, not two’s complement notation, and for programming or hardware work where bit width matters, check the convention your platform uses. Within that scope, the arithmetic is exact even for very large values, because all math on this page uses exact integer arithmetic rather than floating point.

Hex where you already meet it: colours, bytes, and nibbles

The most common place most readers meet hexadecimal is the colour code, and it is a perfect hex exercise because it is three small conversions in one string. Take the base guide’s example, #FF5733. Drop the # label, split the six hex digits into three pairs — FF, 57, and 33 — and convert each pair: FF is 15 times 16 plus 15, which is 255, for red; 57 is 5 times 16 plus 7, which is 87, for green; and 33 is 3 times 16 plus 3, which is 51, for blue. So #FF5733 means red 255, green 87, blue 51, each on the usual 0-to-255 scale, and the reason each colour channel is exactly two hex digits is the same reason a byte is exactly two hex digits: a channel holds 8 bits, and one hex digit holds exactly 4 bits, so two digits hold the whole channel with nothing left over. White, #FFFFFF, is 255 for all three channels; black, #000000, is 0 for all three; and any colour you can name on a screen is three bytes written as six hex digits.

The same grouping explains the word nibble, which is the standard name for a single hex digit’s worth of bits: a nibble is 4 bits, half a byte, and one hex digit. Two nibbles make a byte, four nibbles make a 16-bit word, and sixteen nibbles make the 64-bit value in the conversion table above — sixteen F’s, 64 bits, decimal 18,446,744,073,709,551,615. When programmers say a value is “two bytes”, they mean four hex digits; when they say a memory address is written in hex, they mean the long binary address has been grouped in fours so a human can read it and copy it without dropping a digit. The grouping is the whole point: hex does not change the value, it changes the readability, and every conversion on this page is a change of spelling, not a change of number.

Two reading habits follow from that. First, when you see a long hex string, read it in pairs from the left for bytes, or in fours from the right for bit groups, and check the length before the value: a colour code with five digits or seven digits is malformed before any conversion begins, and a byte written as a single digit has a missing leading zero, not a different value. Second, when a hex value surprises you — a colour that renders wrong, an address that points nowhere — convert it back to decimal and check the magnitude first, because the most common hex errors are magnitude errors: reading 10 as ten instead of sixteen, dropping a leading digit, or confusing a hex pair with a decimal pair. The panel’s four-way display exists for exactly that check: one value, four spellings, and any spelling that disagrees with the other three is the one to distrust.

Hex in dumps, digests, and addresses: length first, value second

Outside colour codes, the hex strings most readers meet are memory dumps, file digests, and addresses, and the length-first habit matters even more there, because the strings are longer and the eye skips digits. A digest or checksum is a fixed-length hex string, and its length in hex digits is its bit length divided by four: a 128-bit digest is 32 hex digits, a 256-bit digest is 64 hex digits, and a digest that is shorter than its expected length has been truncated or mistyped before any comparison begins. Comparing two digests character by character is the whole point of the format — a single differing digit means a different file — so copy digests rather than retyping them, and let the calculator’s conversion confirm the magnitude if a digest’s leading digits look wrong: leading zeros in a digest are significant for length even though they do not change the value, which is the opposite of this calculator’s display rule, where 00FF is shown as FF because the value is what matters here.

Addresses follow the same length discipline with a different convention: an address is usually written with a fixed width, leading zeros included, so that addresses line up in a column and sort correctly as text. That is a display convention for alignment, not a value rule — the address with its leading zeros and the same address without them denote the same location, just as 00FF and FF denote the same value on this page — but stripping the zeros from an address before comparing it with a list will break the comparison even though the value is unchanged. When you move between this calculator and an address list, keep the width the list uses, and use the calculator for the value, not for the formatting: convert here, then re-pad to the list’s width by hand. And when a dump shows a byte as a single digit rather than a pair, treat it as a formatting choice of the dump, not as a half byte: every byte is two hex digits, and a lone digit is a digit waiting for its partner.

The three primary colours are the quickest self-test of the colour-code method, because each one isolates a single channel. Pure red is #FF0000: red FF is 255, green 00 is 0, and blue 00 is 0. Pure green is #00FF00: red 0, green FF is 255, blue 0. Pure blue is #0000FF: red 0, green 0, blue FF is 255. If any of those three does not render as the colour its name promises, the rendering pipeline, not the hex, is at fault — the conversions are fixed by place value, and FF is 255 in every one of them. Mix the channels and the same rule gives every other colour: #FF5733, the base guide’s example, is red 255, green 87, blue 51, a warm orange-red, because the red channel is full, the green channel is about a third, and the blue channel is about a fifth.

Why one hex digit is exactly four bits

Hexadecimal feels arbitrary until you count: 16 is 2 × 2 × 2 × 2, so one hex digit carries precisely the information of four binary digits. That is the whole reason hex exists in computing. A byte is eight bits, so it is exactly two hex digits — no rounding, no leftover bits, no conversion arithmetic. When you see a colour like #1D6FF2, you are looking at three bytes (red 1D, green 6F, blue F2) written the shortest honest way.

The practical payoff is error-checking. A mistyped binary string is invisible — 10110101 versus 10110100 differ in one hard-to-spot position — while the hex versions, B5 versus B4, differ in a single readable character. Engineers did not choose hex to be cryptic; they chose it because it is the least cryptic way to write binary down.

The two conversions worth doing by hand once

Two conversions teach the whole system. Hex to decimal: multiply each digit by its place value (1, 16, 256, 4096 from the right) and add — 2F7 becomes 512 + 240 + 7 = 759. Decimal to hex: divide by 16 repeatedly and read the remainders backwards — 759 gives remainders 7, F, 2, read as 2F7. Do each once on paper and the method is permanent; the calculator then exists to save time, not to supply understanding. The commonest slip in both directions is alignment: misplacing one digit by a single place multiplies the error by sixteen, so writing the place values above the digits first is the single best habit to adopt.

Frequently asked questions

This is a general-purpose math tool. Negative hex values here use a minus sign in front of the magnitude, not two’s complement notation. For programming or hardware work where bit width matters, check the convention your platform uses.