OxiFFT 0.1.1 Released — Dependency Refresh and a Spotless Clippy Run

Three days after the debut, OxiFFT gets its first tidy-up patch.

Today we released OxiFFT 0.1.1 — a small maintenance release for the Pure Rust FFTW replacement, refreshing dependencies and clearing every last lint.

No C. No Fortran. No FFI.
And now, no stale dependencies and no clippy warnings either.
OxiFFT remains a single Pure Rust crate that compiles to a static binary — or to WASM.

Why 0.1.1 matters

A spectral library is foundational code: SciRS2, NumRS2, and the signal work downstream all build on it, so its dependency surface and lint hygiene are not cosmetic — they ripple outward. This patch keeps that surface current and the build noise-free.

• hashbrown 0.15.5 → 0.16.1 and spin 0.9.8 → 0.10.0, picking up the latest upstream fixes for the no_std hashing and synchronization primitives.
• MSRV pin removed. The rust-version field is gone, so OxiFFT can use the latest stable Rust features instead of being held to an artificial floor.
• 48 clippy warnings eliminated, restoring a clean -D warnings build.
• 652 tests passing — all green.

What’s New in 0.1.1

Changed

• Dependency updates: hashbrown 0.15.5 → 0.16.1, spin 0.9.8 → 0.10.0.
• Removed the rust-version (MSRV) field to allow using the latest Rust features.

Fixed

• 48 clippy warnings eliminated, including:
  • manual_is_multiple_of — n % x == 0 rewritten as n.is_multiple_of(x).
  • ref_as_ptr — x as *const _ rewritten as std::ptr::from_ref(x).
• All 652 tests passing.
• Zero clippy warnings with -D warnings.

Getting Started

cargo add oxifft

The API is unchanged from 0.1.0 — a forward then inverse 1D FFT still reads:

use oxifft::api::{fft, ifft};
use oxifft::Complex;

fn main() {
    let input: Vec<Complex<f64>> = (0..16)
        .map(|k| Complex::new((k as f64).sin(), 0.0))
        .collect();

    let spectrum = fft(&input);   // time -> frequency
    let recovered = ifft(&spectrum); // frequency -> time

    let max_error: f64 = input
        .iter()
        .zip(&recovered)
        .map(|(a, b)| (a.re - b.re).hypot(a.im - b.im))
        .fold(0.0, f64::max);

    println!("max roundtrip error: {max_error:.2e}");
}

Tips

• Upgrading from 0.1.0 is a no-op for your code. This patch touches dependencies and lints only — no public API changed, so a version bump is all you need.
• Bring your own toolchain. With the MSRV pin gone, OxiFFT follows current stable Rust; pin your own rust-toolchain.toml if your project needs a fixed compiler.
• Adopt the clippy idioms. The lint fixes here — n.is_multiple_of(x) over n % x == 0, and std::ptr::from_ref(x) over x as *const _ — are worth mirroring in your own FFT-adjacent code.
• Re-run with -D warnings. OxiFFT now builds clean under deny-warnings; flipping that on in CI keeps your downstream spectral code just as tidy.

This is the foundation

OxiFFT is the Pure Rust spectral layer for the SciRS2 numerical stack and the mandated replacement for rustfft, sitting alongside SciRS2, NumRS2, OptiRS, PandRS, OxiBLAS, OxiCode, and its same-day siblings OxiArc and OxiZ. Patches like this keep that foundation current and quiet.

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

Star the repo if you want fast, safe FFTs without ever linking FFTW again.

Pure Rust spectral computing is here — fast, safe, and sovereign.

— KitaSan at COOLJAPAN OÜ January 15, 2026