Crate zstd_pure_rs 

Pure-Rust port of the Zstandard (zstd) compression library.

See README.md for status and the overall plan.

Quickstart

use zstd_pure_rs::prelude::*;

let src = b"Pure-Rust zstd can compress this.".to_vec();

// Compress at level 3 (upstream default).
let mut compressed = vec![0u8; ZSTD_compressBound(src.len())];
let cSize = ZSTD_compress(&mut compressed, &src, 3);
assert!(!ERR_isError(cSize));
compressed.truncate(cSize);

// Decompress.
let mut decoded = vec![0u8; src.len()];
let dSize = ZSTD_decompress(&mut decoded, &compressed);
assert_eq!(dSize, src.len());
assert_eq!(decoded, src);

Skippable frames

use zstd_pure_rs::prelude::*;

// Skippable frames embed arbitrary user data that decoders skip.
let payload = b"custom-metadata-goes-here";
let mut frame = vec![0u8; payload.len() + 8];
let wn = ZSTD_writeSkippableFrame(&mut frame, payload, 7);
assert_eq!(wn, payload.len() + 8);

// Read back the payload + magic variant.
let mut out = vec![0u8; payload.len()];
let mut variant = 0u32;
let rn = ZSTD_readSkippableFrame(&mut out, Some(&mut variant), &frame);
assert_eq!(rn, payload.len());
assert_eq!(variant, 7);
assert_eq!(&out, payload);

Dictionary-based compression

use zstd_pure_rs::prelude::*;

let dict = b"common prefix shared across messages ".to_vec();
let src = b"common prefix shared across messages \
            plus per-message content".to_vec();

// One-shot dict compression via raw content.
let mut cctx = ZSTD_createCCtx().expect("alloc");
let mut dst = vec![0u8; ZSTD_compressBound(src.len())];
let n = ZSTD_compress_usingDict(&mut cctx, &mut dst, &src, &dict, 3);
assert!(!ERR_isError(n));
dst.truncate(n);

// Decompress with the same dict.
let mut dctx = ZSTD_createDCtx();
let mut out = vec![0u8; src.len() + 64];
let d = ZSTD_decompress_usingDict(&mut dctx, &mut out, &dst, &dict);
assert_eq!(&out[..d], &src[..]);

Streaming compression

use zstd_pure_rs::prelude::*;

let src = b"streaming compression demo ".repeat(30);
let mut cctx = ZSTD_createCCtx().expect("alloc");
ZSTD_initCStream(&mut cctx, 3);

// Stage input, then drive endStream until fully drained.
let mut dst = vec![0u8; ZSTD_compressBound(src.len())];
let mut dst_pos = 0usize;
let mut src_pos = 0usize;
ZSTD_compressStream(&mut cctx, &mut dst, &mut dst_pos, &src, &mut src_pos);
loop {
    let rc = ZSTD_endStream(&mut cctx, &mut dst, &mut dst_pos);
    if rc == 0 || ERR_isError(rc) { break; }
}

// Decompress via the public one-shot entry.
let mut out = vec![0u8; src.len() + 64];
let d = ZSTD_decompress(&mut out, &dst[..dst_pos]);
assert_eq!(&out[..d], &src[..]);

Parametric API (advanced)

use zstd_pure_rs::prelude::*;

let src = b"parametric api demo".repeat(20);
let mut cctx = ZSTD_createCCtx().expect("alloc");
// Opt into XXH64 checksum + exact frame-header FCS.
ZSTD_CCtx_setParameter(&mut cctx, ZSTD_cParameter::ZSTD_c_compressionLevel, 5);
ZSTD_CCtx_setParameter(&mut cctx, ZSTD_cParameter::ZSTD_c_checksumFlag, 1);
ZSTD_CCtx_setParameter(&mut cctx, ZSTD_cParameter::ZSTD_c_contentSizeFlag, 1);

let mut dst = vec![0u8; ZSTD_compressBound(src.len())];
let n = ZSTD_compress2(&mut cctx, &mut dst, &src);
assert!(!ERR_isError(n));
dst.truncate(n);

let mut out = vec![0u8; src.len() + 64];
let d = ZSTD_decompress(&mut out, &dst);
assert_eq!(&out[..d], &src[..]);

See upstream’s zstd.h for API semantics. The main public ZSTD_ entry points are available under the zstd_pure_rs::prelude re-exports. Lower-level HUF_ and FSE_ helpers remain in their module namespaces unless explicitly re-exported there; unsupported experimental parameters return the corresponding error codes.

Re-exports

pub use common::error::ErrorCode;

pub use common::error::ZstdError;

pub use common::mem::is_little_endian;

pub use common::zstd_common::ZSTD_getErrorCode;

pub use common::zstd_common::ZSTD_getErrorName;

pub use common::zstd_common::ZSTD_getErrorString;

pub use common::zstd_common::ZSTD_isDeterministicBuild;

pub use common::zstd_common::ZSTD_isError;

pub use common::zstd_common::ZSTD_versionNumber;

pub use common::zstd_common::ZSTD_versionString;

pub use common::zstd_common::ZSTD_VERSION_MAJOR;

pub use common::zstd_common::ZSTD_VERSION_MINOR;

pub use common::zstd_common::ZSTD_VERSION_NUMBER;

pub use common::zstd_common::ZSTD_VERSION_RELEASE;

pub use common::zstd_common::ZSTD_VERSION_STRING;

Modules

common

lib/common/ translation: shared primitives (bits, mem, errors, entropy).

compress

lib/compress/ translation.

decompress

lib/decompress/ translation.

dict_builder

Dictionary trainer — mirror of zstd/lib/dictBuilder/.

prelude

Re-exports of the most commonly-used public API, so callers can write use zstd_pure_rs::prelude::*; instead of drilling into compress::zstd_compress / decompress::zstd_decompress.

Constants

ZSTD_BLOCKSPLITTER_LEVEL_MAX

Upstream ZSTD_BLOCKSPLITTER_LEVEL_MAX.

ZSTD_SEQUENCE_PRODUCER_ERROR

Upstream ZSTD_SEQUENCE_PRODUCER_ERROR.

ZSTD_c_blockDelimiters

ZSTD_c_blockSplitterLevel

ZSTD_c_deterministicRefPrefix

ZSTD_c_enableDedicatedDictSearch

ZSTD_c_enableSeqProducerFallback

ZSTD_c_forceAttachDict

ZSTD_c_forceMaxWindow

ZSTD_c_format

Upstream macro aliases for implemented experimental parameter names.

ZSTD_c_literalCompressionMode

ZSTD_c_maxBlockSize

ZSTD_c_prefetchCDictTables

ZSTD_c_repcodeResolution

ZSTD_c_rsyncable

ZSTD_c_searchForExternalRepcodes

ZSTD_c_splitAfterSequences

ZSTD_c_srcSizeHint

ZSTD_c_stableInBuffer

ZSTD_c_stableOutBuffer

ZSTD_c_useRowMatchFinder

ZSTD_c_validateSequences

ZSTD_d_forceIgnoreChecksum

ZSTD_d_format

Type Aliases

ZSTD_frameHeader

Upstream-compatible legacy alias for ZSTD_FrameHeader.

ZSTD_frameParameters

Upstream-compatible alias for ZSTD_frameParameters.

ZSTD_frameType_e

Upstream-compatible legacy alias for ZSTD_FrameType_e.

ZSTD_paramSwitch_e

Upstream-compatible legacy alias for ZSTD_ParamSwitch_e.

ZSTD_sequenceFormat_e

Upstream-compatible legacy alias for ZSTD_SequenceFormat_e.

ZSTD_threadPool

Upstream-compatible alias for ZSTD_threadPool.