CRC-64 Calculator (XZ, ECMA-182, ISO)

Calculate the 64-bit cyclic redundancy check of any text or hex input across the CRC-64 variants you actually meet in the wild: CRC-64/XZ (used by the xz compressor), CRC-64/ECMA-182, and CRC-64/GO-ISO. Each variant's polynomial, initial value, reflection, and final XOR are applied for you, and results are shown in hex and decimal. It computes live and entirely in your browser.

How to use the CRC-64 Calculator (XZ, ECMA-182, ISO)

Type or paste into the input and choose Text or Hex bytes. In hex mode you can separate bytes with spaces or commas and use an optional 0x prefix; in text mode the characters are converted to UTF-8 bytes first. The table updates live and shows, for each variant, the 64-bit CRC in both hexadecimal (16 digits) and decimal.

Three variants are computed side by side because, just as with the shorter CRCs, there is no single "CRC-64". The classic check string 123456789 is provided as a default so you can confirm the values against published check constants: CRC-64/XZ yields 0x995DC9BBDF1939FA, while CRC-64/ECMA-182 yields 0x6C40DF5F0B497347. Match the variant name to whatever tool or format you are working with — the .xz container and many checksum utilities use the XZ row, while ECMA-182 appears in tape and storage standards.

Because JavaScript numbers cannot hold 64 bits exactly, the calculation uses big-integer arithmetic internally, so every digit is accurate. It runs entirely in your browser, so it is instant, works offline, and nothing you enter is uploaded anywhere.

What CRC-64 is and where it shows up

A cyclic redundancy check treats your data as the coefficients of a large binary polynomial and divides it by a fixed shorter polynomial; the remainder of that division is the CRC. Flip a single bit anywhere in the message and the remainder changes, so a receiver that recomputes the CRC and compares it against the stored one can detect corruption. The 64-bit family produces an eight-byte result, which makes accidental collisions astronomically unlikely and is the natural choice when you are checksumming large objects — a multi-gigabyte compressed archive, a database page, or a deduplication chunk — where a 32-bit value would start to see collisions.

The reason there is more than one CRC-64 is the same as for the smaller widths: the algorithm has free parameters and different standards bodies chose different ones. Both of the dominant variants share the famous ECMA-182 polynomial 0x42F0E1EBA9EA3693, but they differ in the surrounding setup. CRC-64/XZ — the one computed by the xz and LZMA tools — initialises the register to all ones, reflects both the input bytes and the output, and XORs the final value with all ones. CRC-64/ECMA-182 uses a zero initial value, no reflection, and no final XOR, so the very same data produces a completely different number. A third variant, CRC-64/GO-ISO, uses the ISO 3309 polynomial 0x000000000000001B with reflection and all-ones init and XOR, and is what Go\'s hash/crc64 ISO table produces.

The check value — the CRC of the nine ASCII bytes 123456789 — is the quickest way to pin down which combination an implementation uses, exactly as it is for CRC-8, CRC-16, and CRC-32. If your code produces 0x995DC9BBDF1939FA for that string it is running the XZ parameters; 0x6C40DF5F0B497347 means ECMA-182. Because reflection alone flips the result so dramatically, mixing up two variants that share a polynomial is one of the most common reasons a CRC fails to match between two systems, and laying the variants side by side makes that mismatch obvious at a glance. The underlying math is identical to the narrower CRCs; only the register width and the constants change, which is why a 64-bit calculator is a useful companion to its 8-, 16-, and 32-bit siblings.

Common use cases

  • Archive integrity. Recompute the CRC-64/XZ checksum that the xz format stores for a compressed stream.
  • Storage formats. Verify an ECMA-182 CRC used in tape and disk standards.
  • Go programs. Match the value from hash/crc64 using the ISO or ECMA table.
  • Identifying a variant. Use the check value to discover which CRC-64 parameters an unknown implementation uses.

Frequently asked questions

Which CRC-64 variant should I use?
Use whatever your format or library specifies. The xz/lzma compressors and many checksum utilities use CRC-64/XZ; ECMA-182 and ISO 3309 appear in storage standards and Go's crc64 package. The table shows all three so you can match the one you need.

Why do XZ and ECMA-182 differ if they share a polynomial?
Because the initial value, bit reflection, and final XOR also differ. XZ reflects input and output and uses all-ones init and XOR, while ECMA-182 uses none of these, so identical data yields different results.

Is the arithmetic exact for 64 bits?
Yes. JavaScript numbers lose precision above 53 bits, so the tool computes the CRC with BigInt arithmetic. Every one of the 16 hex digits is accurate.

What is the check value 123456789?
It is the standard test string. Computing the CRC of the ASCII bytes 1 through 9 gives a published constant for each variant — 0x995DC9BBDF1939FA for XZ — which confirms an implementation uses those exact parameters.