OxiArc 0.2.1 Released — ZIP Encryption, Async I/O, SIMD CRC, and Memory-Mapped I/O

Security and scale come to the COOLJAPAN compression layer.

Today we released OxiArc 0.2.1 — pure Rust archive and compression, now with ZIP encryption, async I/O, SIMD-accelerated CRC, and memory-mapped I/O.

No C. No Fortran. No zlib. No libzip. No libarchive. No 7-zip. No external shared libraries.
No FFI overhead. No build hell.
Just clean, memory-safe, blazing-fast archiving and compression that compiles to a single static binary (or WASM) and runs everywhere.

Why OxiArc 0.2.1 matters

The native incumbents — zlib, libzip, libarchive, 7-zip — still carry the same old weight: build-system pain, security exposure from large C codebases, awkward WASM and no_std stories, and patchy LZH/Shift_JIS support. OxiArc keeps replacing them piece by piece.

0.2.1 is about two things the previous releases didn’t have: security and scale. Password-protected ZIPs are now first-class, and the core learns to read large files without copying them through user space — via memory mapping — and to do I/O asynchronously when you don’t want to block.

Technical Deep Dive: Security and Scale in the Core

The familiar four-layer shape holds; 0.2.1 deepens the lower three.

1. Core Layer (oxiarc-core)
   Three capabilities land here: async I/O for non-blocking operations, SIMD-accelerated CRC, and memory-mapped (mmap) I/O for large files — plus enhanced CRC benchmarks and an improved internal ring buffer. The 0.2.1 build newly pulls in tokio (features io-util, rt, macros, sync) and memmap2, so async and mmap are real, not aspirational.

2. Codec Layer

   • oxiarc-lz4 gains dictionary support — better ratios on similar data, with a dictionary API for streaming.
   • oxiarc-lzhuf gains a streaming compress/decompress API (plus streaming integration tests), so LZH can run in bounded memory.
   • oxiarc-lzma improves LZMA2 chunking and optimal parsing.
   • oxiarc-deflate sharpens LZ77 match finding, adds more zlib-style compression options, and optimizes its Huffman coding.

3. Container Layer (oxiarc-archive)
   ZIP encryption arrives: traditional ZipCrypto for password-protected archives, with dedicated encrypt and decrypt modules and the supporting crypto primitives.

4. CLI Layer (oxiarc-cli)
   Improved list/extract, new utility modules, and better error handling throughout.

Getting Started

0.2.1 installs the same way as 0.2.0 — straight from crates.io:

cargo install oxiarc-cli            # the `oxiarc` CLI

cargo add oxiarc-archive            # or oxiarc-deflate / oxiarc-lz4 / ...

The core library API is stable:

use oxiarc_deflate::{deflate, inflate};
use oxiarc_archive::ZipReader;
use std::fs::File;

let compressed = deflate(b"Hello, World!", 6)?;   // level 0-9
let decompressed = inflate(&compressed)?;

let file = File::open("archive.zip")?;
let mut zip = ZipReader::new(file)?;
for entry in zip.entries() {
    println!("{}: {} bytes", entry.name, entry.size);
}

What’s New in 0.2.1

• ZIP encryption (oxiarc-archive) — traditional ZipCrypto for password-protected archives: encrypt and decrypt modules plus the crypto primitives behind them.
• Async I/O, SIMD CRC, and mmap (oxiarc-core) — non-blocking async operations, SIMD-accelerated CRC, memory-mapped I/O for large files, and enhanced CRC benchmarks.
• LZ4 dictionary support (oxiarc-lz4) — better compression ratios on similar data, with a dictionary API for streaming.
• LZHUF streaming (oxiarc-lzhuf) — a streaming compress/decompress API, with streaming integration tests.
• Codec tuning — LZMA2 chunking and optimal-parsing improvements; better DEFLATE LZ77 match finding and more zlib compression options.
• CLI polish — improved list/extract and new utility modules.
• Changed — enhanced ring buffer (core), optimized Huffman coding (deflate), better CLI error handling.
• Fixed — multi-file archive edge cases and DEFLATE edge cases in simple scenarios.

Tips

Putting the new capabilities to work:

• Encrypt a ZIP with a password. OxiArc now writes traditional ZipCrypto-protected archives — set a password when creating, and oxiarc-archive handles the encrypt/decrypt path.
• Memory-map large archives. For big files, the new mmap I/O lets the core read directly from the mapping instead of streaming bytes through a buffer.
• Go non-blocking. The async I/O (backed by tokio) lets reads and writes run without stalling your event loop.
• Use an LZ4 dictionary for many-similar files. Priming with a shared dictionary lifts ratios noticeably when inputs resemble each other — and the dictionary API works in streaming mode.
• Stream LZH in bounded memory. The new oxiarc-lzhuf streaming API compresses and decompresses incrementally, so memory stays flat regardless of archive size.
• Lean on SIMD CRC for integrity. Checksums on large payloads are noticeably faster now, so verifying archives stays cheap.

This is the foundation

OxiArc remains the compression and archival backend the rest of COOLJAPAN builds on, depending on no sibling projects itself.

With ZipCrypto encryption and memory-mapped I/O, OxiArc is now ready to serve as the storage backend for SciRS2, NumRS2, and PandRS datasets — large files read efficiently, sensitive archives protected, all in pure Rust.

Repository: https://github.com/cool-japan/oxiarc

Star the repo if you want high-performance archiving and compression without the traditional native toolchain headaches.

Pure Rust archiving and compression is here — fast, safe, and sovereign.

— KitaSan at COOLJAPAN OÜ February 9, 2026