CRC Lookup Table Generator – CRC32, CRC16, CRC8 Table Viewer & Export

What is a CRC Lookup Table?

A CRC lookup table is a precomputed array of 256 values that accelerates byte-wise CRC calculation. Instead of processing each bit individually, a byte-at-a-time implementation XORs the input byte with the current CRC, uses the result as an index into the 256-entry table, and combines the table value with the shifted accumulator — reducing an 8-step inner loop to a single table lookup.

This generator computes the authoritative 256-entry table for any supported CRC algorithm. Every entry is derived directly from the algorithm's polynomial and reflection settings, so the table matches what embedded and systems code actually uses at runtime.

How to Use This Tool

Settings Panel

The settings panel on the left controls what the tool generates:

• CRC Algorithm — Select any of the 100+ CRC algorithms from the dropdown, ranging from CRC-3 through CRC-64. The list follows the Catalogue of CRC Algorithms naming convention. Popular choices include CRC-32/ISO-HDLC (Ethernet, ZIP), CRC-16/MODBUS (industrial serial), CRC-8/MAXIM-DOW (1-Wire sensors), and CRC-64/WE (storage). Changing the algorithm instantly regenerates the full table.
• Output Format — Switch between Table and Script views. Table mode shows all 256 entries in a grid for visual inspection. Script mode generates a ready-to-paste array declaration for your target language.
• Table Format (Table mode only) — Choose how numeric values are displayed: Hex (e.g. 0x77073096), Decimal (e.g. 1996959894), or Binary (e.g. 0b01110111...). Hex is the most common format for embedded development.
• Language (Script mode only) — Select the target programming language for the exported array declaration: C, C++, Go, Java, JavaScript, Kotlin, Python, Rust, Swift, or TypeScript. Each export includes a comment header with the algorithm name and all parameters (poly, init, refin, refout, xorout).

Result Panel

The result panel shows three sections:

• Summary — Displays the algorithm's key parameters at a glance: Width (bit size), Poly (generator polynomial), Init (initial CRC value), XOR-out (final XOR mask), Check (CRC of "123456789"), Residue (expected CRC remainder for valid frames), RefIn (whether input bytes are bit-reflected), RefOut (whether the final CRC is bit-reflected). Use the Copy button to copy all parameters as a single line of text.
• Entry Inspector — Type any index from 0 to 255 (decimal or hex with 0x prefix) to instantly look up that table entry. For example, entering 0x01 for CRC-32/ISO-HDLC shows table[0x01] = 0x77073096. The corresponding row in the table is also highlighted in the grid view.
• Lookup Table / Export Script — In Table mode, all 256 entries are shown in an 8-column grid with row offsets as hexadecimal labels. In Script mode, the full array declaration is displayed ready to copy. Use the Copy button to copy the entire output to your clipboard.

Typical Workflow

1. Select your CRC algorithm from the dropdown (e.g. CRC-32/ISO-HDLC for Ethernet or ZIP)
2. Check the Summary panel to confirm the parameters match your specification
3. Switch Output Format to Script and select your language
4. Click Copy to copy the array declaration and paste it into your project
5. Verify your implementation using the CRC Calculator: compute CRC of "123456789" and compare to the Check value in the Summary

How Byte-Wise CRC Works

The standard table-driven CRC loop (reflected variant) looks like this:

crc = init
for byte in data:
    crc = table[(crc ^ byte) & 0xFF] ^ (crc >> 8)
crc ^= xorout

For non-reflected (normal) algorithms, the byte is shifted into the high end of the accumulator instead:

crc = init
for byte in data:
    crc = table[((crc >> (width-8)) ^ byte) & 0xFF] ^ (crc << 8)
crc ^= xorout

The exported Script output includes the exact array declaration for your target language, with polynomial and parameter annotations — ready to paste directly into your project.

Table Generation Method

Each of the 256 table entries is computed by treating the index as an 8-bit input byte, running it through the standard CRC bit-by-bit loop, and recording the result. For reflected algorithms the polynomial is bit-reversed before processing; for normal algorithms the input byte is positioned in the high bits of the accumulator. The output is masked to the algorithm's actual bit width.

Check Value Verification

The Summary panel shows the algorithm's check value — the CRC of the ASCII string "123456789". Use the CRC Calculator to verify your table-driven implementation produces the same result.

Storage Type Selection

Commonly Used CRC Lookup Tables

CRC-32/ISO-HDLC (Ethernet, ZIP, gzip, PNG)

CRC-16/MODBUS

CRC-8/MAXIM-DOW (1-Wire)

Frequently Asked Questions

What is a CRC lookup table and why is it used?

A CRC lookup table is a precomputed array of 256 values that accelerates byte-wise CRC calculation. Instead of processing all 8 bits of each input byte individually, an implementation XORs the current byte with the CRC accumulator, uses the result as an index into the table, and combines the table value with the shifted accumulator in a single step — reducing the inner loop from 8 iterations to one table lookup.

How is the CRC-32/ISO-HDLC (Ethernet, ZIP, gzip) lookup table generated?

The table uses the reflected polynomial 0xEDB88320 (bit-reversal of 0x04C11DB7'). Each of the 256 entries is computed by treating the index as an 8-bit input, running the standard 8-step bit-wise CRC loop with the reflected polynomial. Entry [1] is 0x77073096; entry [255] is 0x2D02EF8D.

What is the byte-wise CRC loop for a reflected (RefIn=true) algorithm?

crc = init
for byte in data:
    crc = table[(crc ^ byte) & 0xFF] ^ (crc >> 8)
crc ^= xorout

How does a non-reflected (RefIn=false) CRC table loop differ?

crc = init
for byte in data:
    crc = table[((crc >> (width-8)) ^ byte) & 0xFF] ^ (crc << 8)
crc &= mask
crc ^= xorout

What storage type is used for each CRC width?

How can I verify that my CRC lookup table implementation is correct?

Every CRC algorithm has a published check value — the CRC of the ASCII string "123456789". Run your table-driven implementation on that string and compare the result to the check value shown in the Summary panel. For CRC-32/ISO-HDLC the check value is 0xCBF43926; for CRC-16/MODBUS it is 0x4B37; for CRC-8/MAXIM-DOW it is 0xA1.

What is the CRC-16/MODBUS lookup table first entry?

The CRC-16/MODBUS table uses the reflected polynomial 0xA001 (bit-reversal of 0x8005). Table entry [0] is 0x0000 and entry [1] is 0xC0C1. Init is 0xFFFF.

Which output languages are supported for CRC table export?

The Script export supports: C, C++ (std::array), Go, Java (long[]), JavaScript, Kotlin (longArrayOf), Python, Rust (const [T; 256]), Swift, and TypeScript. Each export includes a comment header with algorithm name and full parameter set.

Is data sent to a server when generating CRC lookup tables?

No. All table generation runs entirely in WebAssembly compiled from Rust, executing locally in your browser. No input, algorithm selection, or table output is transmitted to any server. Settings are saved only to your browser's localStorage.

Related Tools

• TOTP Generator - Generate RFC 6238 TOTP codes from a Base32 secret: SHA-1/SHA-256/SHA-512, 15/30/60s steps, 6 or 8 digits. otpauth:// QR for authenticator apps, verify with time drift tolerance, optional HMAC debug. Client-side only.
• JWT Encoder & Decoder - Decode JWT header and payload, verify HS256/HS384/HS512 signatures with your secret, inspect exp/iat/nbf/iss/sub/aud, and encode new JWTs from JSON—all in the browser. No upload; ideal for API auth debugging and learning RFC 7519.
• TLS Certificate Analyzer - Decode PEM or DER X.509 certificates in the browser: subject/issuer, validity, SAN, key usage, fingerprints, and chain relationships—useful for HTTPS debugging and DevOps. No upload to a backend.
• CRC Calculator - Calculate CRC checksums with 100+ algorithms for data integrity verification
• File Hash Calculator - Compute cryptographic hashes for files and text in your browser: MD5, SHA-1, SHA-256, SHA-384, SHA-512, SHA3, Blake2, and more. Drag-and-drop files, hex/base64 output, side-by-side comparison. Nothing uploaded—runs locally with Web Crypto.