OxiCode 0.2.3 Released — A Clean Clippy Run and Collision-Free Concurrent Tests

Five days after 0.2.2, a tidy follow-up that keeps the lights green.

Today we released OxiCode 0.2.3 — a focused patch that restores a spotless cargo clippy run and makes the test suite collision-free under heavy parallelism. No public API changes, no wire-format changes. If you’re on 0.2, this is a drop-in bump.

No C. No Fortran. No warnings.
OxiCode stays a pure-Rust binary codec that compiles to a single static binary (or WASM).

Why 0.2.3 matters

The COOLJAPAN no-warnings policy isn’t cosmetic — a clean clippy -D warnings run is a gate that the whole workspace passes or fails on. 0.2.3 exists to keep that gate green and to make the file-I/O tests deterministic when many of them write temp files at the same time. Small fixes, but they’re the kind that keep CI trustworthy.

Technical Deep Dive: what changed under the hood

1. Back to a clean clippy run
   A needless_borrows_for_generic_args lint had crept into the compatibility crate. 0.2.3 removes the redundant & borrow at 10 bincode::encode_to_vec call sites in compatibility/src/lib.rs, restoring cargo clippy --all-features --workspace -- -D warnings to a clean run and satisfying the no-warnings policy.

2. Collision-free concurrent tests
   Seven test modules — async_advanced7_test.rs, file_io_advanced15_test.rs, file_io_advanced17_test.rs, file_io_advanced29_test.rs, file_io_advanced30_test.rs, file_io_advanced31_test.rs, and file_io_advanced32_test.rs — now use the canonical std::process::id()-suffixed temp-path helper that was introduced for file_io_advanced13_test.rs back in 0.2.2. With unique paths per process, concurrent test invocations no longer step on each other’s temp files.

3. Version bump only, by policy
   Workspace and crate versions move from 0.2.2 to 0.2.3 under the branch-name-drives-version policy. Nothing in the runtime crate’s public surface changed.

Getting Started

cargo add oxicode

Your code is unchanged from the rest of the 0.2 line:

use oxicode::{Encode, Decode};

#[derive(Encode, Decode, PartialEq, Debug)]
struct Sample {
    timestamp: u64,
    values: Vec<f64>,
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let sample = Sample { timestamp: 1_700_000_000, values: vec![0.1, 0.2, 0.3] };

    let bytes = oxicode::encode_to_vec(&sample)?;
    let (decoded, _): (Sample, _) = oxicode::decode_from_slice(&bytes)?;

    assert_eq!(sample, decoded);
    Ok(())
}

What’s New in 0.2.3

• Fixed: the needless_borrows_for_generic_args clippy lint in the compatibility crate — removed redundant & borrows at 10 bincode::encode_to_vec call sites, restoring a clean clippy --all-features --workspace -- -D warnings run
• Fixed: temp-file collisions across concurrent test runs in seven async and file-I/O test modules, now all using the std::process::id()-suffixed temp-path helper
• Changed: bumped workspace and crate versions from 0.2.2 to 0.2.3 (branch-name-drives-version policy)

Tips

• Run clippy with -D warnings. OxiCode is verified clean under cargo clippy --all-features --workspace -- -D warnings — wire it into your own CI to catch regressions like the borrow lint this patch fixed.
• Suffix every temp path with the PID. When tests write files in parallel, std::process::id() in the path is the simplest way to avoid the exact collisions 0.2.3 eliminated; reach for std::env::temp_dir() as the base directory.
• Upgrading from 0.2.2? It’s a pure swap — no code edits, no re-encoding, no feature-flag changes.
• Running the async suite? The async-tokio feature’s streaming tests are part of the collision fix, so concurrent cargo nextest runs over the async path are now reliable.

This is the foundation

OxiCode is the binary codec the COOLJAPAN data stack leans on — checkpoints for SciRS2 and NumRS2, tensor buffers for ToRSh, archive-embedded payloads with OxiARC. Releases like 0.2.3 are how a foundation stays dependable: zero warnings, deterministic tests, and not a byte of C or Fortran.

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

Star the repo if you value a serializer that keeps its CI spotless.

Pure Rust binary serialization is here — fast, compatible, and sovereign.

— KitaSan at COOLJAPAN OÜ May 8, 2026