Features

• 100% safe Rust: #![forbid(unsafe_code)] is enforced crate-wide
• Standard byte-at-a-time crc32: compatible with zlib, PKZIP, Ethernet, FDDI
• Four-bytes-at-a-time crc32_little: slicing-by-4, ~2-4x higher throughput on large inputs
• Big-endian crc32_big: interoperable with big-endian hardware CRC devices
• Streaming Digest: incremental checksum without buffering the entire payload
• crc32_combine: merge two independently computed CRCs in O(log n) time
• Python bindings: via PyO3 / maturin (pip install crc32-rs)
• Node.js bindings: via napi-rs (npm install crc32-rs)

Rust Usage

Add to your Cargo.toml:

[dependencies]
crc32-v2 = "0.1.2"

Or run:

cargo add crc32-v2

One-shot checksum

use crc32_v2::crc32;

fn main() {
    let data = b"Hello, world!";
    println!("CRC-32: {:#010X}", crc32(0, data));  // CRC-32: 0xEBE6C6E6
}

Four-bytes-at-a-time (higher throughput)

use crc32_v2::byfour::crc32_little;

fn main() {
    let data = b"Hello, world!";
    println!("CRC-32 (little): {:#010X}", crc32_little(0, data));  // CRC-32 (little): 0xEBE6C6E6
}

Streaming checksum via Digest

use crc32_v2::Digest;

fn main() {
    let mut digest = Digest::new();
    digest.update(b"Hello, ");
    digest.update(b"world!");
    println!("CRC-32: {:#010X}", digest.finalize());  // CRC-32: 0xEBE6C6E6
}

Combining two checksums

use crc32_v2::{crc32, crc32_combine};

fn main() {
    let crc1 = crc32(0, b"Hello, ");
    let crc2 = crc32(0, b"world!");
    let combined = crc32_combine(crc1, crc2, b"world!".len() as u64);
    assert_eq!(combined, crc32(0, b"Hello, world!"));
    println!("Combined: {:#010X}", combined); // Combined: 0xEBE6C6E6
}

Python Usage

See PYTHON.md for full documentation.

pip install crc32-rs

from crc32_rs import crc32, crc32_little, Digest

print(hex(crc32(b"Hello, world!")))           # 0xebe6c6e6
print(hex(crc32_little(b"Hello, world!")))    # 0xebe6c6e6

d = Digest()
d.update(b"Hello, ")
d.update(b"world!")
print(hex(d.finalize()))                       # 0xebe6c6e6

Node.js Usage

See NODE.md for full documentation.

npm install crc32-rs

// If installed via npm: const { crc32, crc32Little, Digest } = require('crc32-rs');
// For local development:
const { crc32, crc32Little, Digest } = require(".");

console.log(crc32(Buffer.from("Hello, world!")).toString(16)); // ebe6c6e6
console.log(crc32Little(Buffer.from("Hello, world!")).toString(16)); // ebe6c6e6

const d = new Digest();
d.update(Buffer.from("Hello, "));
d.update(Buffer.from("world!"));
console.log(d.finalize().toString(16)); // ebe6c6e6

Benchmark

Running cargo bench measures throughput across five payload sizes. Results on a typical x86-64 machine:

Key takeaways

• crc32_little achieves ~800 MiB/s throughput for large inputs, making it over 2x faster than the simple byte-at-a-time crc32 (~350 MiB/s), thanks to the slicing-by-4 algorithm. For tiny inputs (< 16 B), crc32 is marginally faster due to lower alignment overhead.
• crc32_big falls back to a byte-at-a-time loop and achieves similar throughput to crc32 (~320 MiB/s).
• crc32fast achieves ~11.6 GiB/s on x86-64 because it uses runtime-detected SIMD hardware acceleration (pclmulqdq). For maximum raw throughput on known hardware, prefer crc32fast. For pure portability, full control, or embedding in a no_std context without CPU feature detection overhead, use crc32-v2.

Safety

This crate enforces a zero-unsafe policy via #![forbid(unsafe_code)] at the crate root. Every byte of the implementation, including table lookups, the slicing-by-4 loop, GF(2) matrix arithmetic, and the streaming Digest, is written in safe Rust. The compiler will reject any future unsafe block or unsafe fn introduced into the crate.

See Also

• A Painless Guide to CRC Error Detection Algorithms - the canonical reference for this algorithm.
• zlib - crc32.c - the C implementation this crate is ported from.
• crc32fast - SIMD-accelerated CRC-32 for Rust.
• crc - generic CRC computation for many widths and polynomials.
• IEEE 802.3 CRC-32 - Wikipedia overview.