240 posts
CeleRS 0.3.0 eliminates sqlx and reqwest workspace-wide for oxisql/oxihttp-client, swaps mock XOR encryption for real AES-256-GCM/ChaCha20-Poly1305, and fixes chord/chain execution and Kombu middleware that were silent no-ops. 18 crates, 5,676 tests passing. The sovereign task-queue layer for COOLJAPAN.
OxiHuman 0.2.1 is the BodyLab production release: the first real CC0 asset pack (OHPK v1, 38 targets), in-memory browser GLB/VRM/STL/OBJ export, a live three.js demo, and a measurement-fit solver accurate to within 0.66 cm — plus three P0 bugs fixed and 33,569 passing tests.
TenfloweRS 0.2.0 rewires the Python-facing, PyTorch-style implicit autograd system for real: every layer type gets tape-backed .backward()/.grad(), all 9 optimizers perform genuine gradient updates, and a correctness sweep fixes wrong Softmax/BatchNorm/GroupNorm/LayerNorm gradients — 14,536+ tests passing.
OxiRS 0.3.2 extracts NVML, CUDA, GEOS, DuckDB, Kafka, and Pulsar C-FFI into six opt-in publish=false adapter crates, migrates GeoSPARQL's GeoPackage backend off rusqlite onto the Pure-Rust OxiSQL engine, and closes the last transitive zstd-sys dependency with a Pure-Rust zstd shim — 45,034 tests, zero warnings.
OxiEphemeris 0.1.1 adds a full RDF/SKOS/PROV-O astrology vocabulary with a live SPARQL endpoint, new Python and WebAssembly bindings sharing one compute facade with the CLI, and a deeper astrology layer — ayanamshas, dignities, declinations, Arabic Parts, synastry. The sovereign ephemeris layer for COOLJAPAN.
OxiSQL 0.3.2 closes the final C-FFI gap in its --all-features dependency closure with a new Pure-Rust zstd-shim replacing zstd-sys (pulled in by DataFusion's Arrow IPC), and fixes a GROUP BY … HAVING COUNT(*) accumulator-reset bug in the oxisqlite-core query engine. The sovereign SQL layer for the COOLJAPAN ecosystem.
OxiWhisper 0.1.2 adds a full speaker-diarization pipeline (VAD, clustering, RTTM/DER export, optional ECAPA-TDNN embeddings), word-level timestamps, a translation task, and temperature-fallback decoding — the sovereign speech-recognition layer for the COOLJAPAN ecosystem, still zero C or Python.
TrustformeRS 0.2.0 gives CUDA the same device-resident attention pipeline Metal already had, adds batched CUDA matmul and refcounted GPU buffers, fixes a silent CUDA data race, and drops the torch/libtorch backend workspace-wide. The sovereign transformer layer for the COOLJAPAN ecosystem.
TenfloweRS 0.1.2 adds PyTorch-style implicit autograd for Python, real ONNX protobuf import/export, a pure-Rust Blosc codec for Zarr, and a wide honesty-hardening sweep that replaces fabricated results with real computation or honest errors across the framework.
OxiArc 0.3.5 rewrites the -lh4-/-lh5-/-lh6-/-lh7- codec from a private bitstream format into genuine canonical LHA wire format, validated against real third-party .lzh archives and a live lha (Lhasa) CLI oracle. Also fixes a Miri-flagged CRC UB class, three writer resource leaks, and a CLI exit-code bug. 1,878 tests passing, Pure Rust.
OxiCUDA 0.4.1 extends on-device GPU validation into BLAS, DNN, and the driver/memory/launch stack, catching concurrency races that single-threaded testing can't. Plus the first correctness pass across five non-CUDA backends and real driver-backed CUDA Graph capture. 38,612 tests, ~1.28M SLoC, 73 crates.
Spintronics 0.3.2 adds a k·p altermagnet band model with GMR-like spin valves, d-orbital orbitronics, a resonating-valence-bond spin-liquid solver, streaming simulation with binary OVF I/O, and fixes to Hermitian eigenvectors and the Kane-Mele Z2 invariant. 2059 tests, 118 doc tests, 0 warnings.
SplitRS 0.3.4 fixes five correctness issues in --split-nested-mods surfaced by a focused review: E0603 visibility widening for relocated private mods, E0425/E0599 parent-scope glob retention, and E0432/E0659 macro-import ambiguity. 570 tests passing. The AST-based Rust refactoring tool for the COOLJAPAN ecosystem.
OxiArc 0.3.4 is an interoperability hardening release: spec-conformance defects surfaced by downstream FVRS integration testing were root-caused and fixed across LZMA/LZMA2, bzip2, 7z, ZIP, TAR, XZ, and LZH. Every codec is now validated bidirectionally against liblzma, libbz2, bsdtar/libarchive, and CPython, with hermetic golden-vector regression suites. 1,799 tests passing, Pure Rust.
SplitRS 0.3.3 adds domain-mapping for --target-modules (seeded assignment by reference affinity, unknown-name validation, dry-run attribution), recursive --split-nested-mods descent into inline mod blocks, a --facade style flag, verbatim method extraction, and 565 passing tests. The AST-based Rust refactoring tool for the COOLJAPAN ecosystem.
OxigenAI 0.1.1 replaces its contradiction heuristic with genuine OxiZ SMT verification, adds JP/US/EU multi-jurisdiction statute registries via a new -j flag, and ships /predict-ruling and /translate-check — 231 tests passing. The sovereign computational-law layer for the COOLJAPAN ecosystem.
TrustformeRS 0.1.4 migrates CUDA and Metal from cudarc/scirs2-MPS to the Pure-Rust oxicuda stack, passes 12/12 CPU↔CUDA parity tests on a real RTX A4000, ships real PyRwkvModel/PyMambaModel classes on PyO3 0.28, and goes unwrap()-free workspace-wide. The sovereign transformer layer for the COOLJAPAN ecosystem.
OxiCUDA 0.4.0 is an on-device validation pass: for the first time, hand-written PTX across 60+ crates was JIT-compiled and run on real NVIDIA hardware (RTX A4000, sm_86, CUDA 12.4) instead of only checked for CPU-logic parity — catching register-shadowing bugs, base-2/base-e math errors, invalid PTX, and literal stub kernels. 38,093 tests passing, ~1.27M SLoC, 73 crates.
SciRS2 0.6.0 introduces the pure-Rust oxicuda-* CUDA stack as a direct, per-crate NVIDIA performance backend and decentralizes GPU out of scirs2-core. Ten crates — fft, symbolic, interpolate, special, stats, graph, linalg, optimize, datasets, and vision — gain an off-by-default, runtime-probed, f64-native cuda feature standing alongside the existing wgpu/WebGPU portability path, now standardized under one wgpu feature name across the ecosystem. A default build still compiles zero oxicuda. Pure Rust, Apache-2.0.
sklears 0.1.2 brings 12 real preprocessing implementations (no more stubs), SciRS2 0.5.1 upgrade, AVX2 quicksort in sklears-simd, advanced categorical imputers, and a full benchmarking regression-detection subsystem — 12,242 tests across 36 crates, >99% scikit-learn API coverage held.
ToRSh 0.1.3 lands the oxicuda GPU backend (no CUDA SDK at build time), eliminates the last C/asm dependency, ships a bandwidth-optimal ring all-reduce, completes the Node.js N-API layer, and delivers 15–30% throughput gains from phase-4 chunking helpers.
phop 0.1.0 — a pure-Rust differentiable symbolic-discovery engine that learns the topology and constants of closed-form laws by gradient descent over trees of a single operator, eml(x,y)=exp(x)−ln(y), then certifies and SMT/Lean-proves them. Runs the whole pipeline in the browser via WASM.
SciRS2 0.5.1 is a correctness and Pure-Rust hardening release: exact autograd gradients for matrix functions (Sylvester / Daleckii–Krein / reduced-SVD VJP), a restored CoreError #[non_exhaustive] contract, honest GPU/CUDA reporting, public Zarr v2/v3, and the removal of the C/MPFR rug, C rusqlite, and tokenizers dependencies. 36,606 tests, zero warnings — the sovereign scientific-computing layer of the COOLJAPAN ecosystem.
TrustformeRS 0.1.3 patch — real SHAP/LIME/Integrated-Gradients interpretability, ZeroCopyTensorView + GlobalMemoryPool + GlobalProfiler, Miri-verified memory-pool fixes, real SHA-256 on the HuggingFace upload path, and real OOXML .xlsx export via oxiarc-archive.
OxiSQL is the COOLJAPAN Pure-Rust unified SQL layer: a single async facade over embedded engines, PostgreSQL and MySQL wire clients, and a C-free SQLite-compatible path — replacing libpq, libmysqlclient, libsqlite3, and rusqlite with no FFI. Part of the NoFFI / COOLJAPAN sovereign Rust stack.
OxiHTTP is the COOLJAPAN Pure-Rust HTTP stack: an async client and server for HTTP/1.1, HTTP/2, and HTTP/3 with no curl, no OpenSSL, and no -sys crates. Transport security comes from OxiTLS. A reqwest/hyper-free facade and part of the NoFFI sovereign Rust stack.
OxiRPC is the COOLJAPAN Pure-Rust gRPC stack: tonic-style gRPC over HTTP/2 whose proto codegen, TLS, and compression are 100% Pure Rust. No protoc binary, no OpenSSL, no ring by default — codegen via OxiProto, TLS via OxiTLS, gzip/zstd via OxiARC. Part of the NoFFI sovereign Rust stack.
Meet OxiStore: the COOLJAPAN Pure Rust low-level storage layer — embedded key-value (B-tree + LSM), columnar in-memory & on-disk, and a blob abstraction (local fs + S3/Azure/GCS). Replaces librocksdb-sys, lmdb-sys, and leveldb-sys with zero FFI. Part of the NoFFI sovereign Rust stack.
OxiText is the COOLJAPAN Pure-Rust text pipeline — shaping, UAX #9 bidi reordering, UAX #14 line-breaking, layout, and glyph rasterization. A NoFFI replacement for the HarfBuzz + FriBidi + ICU + FreeType C/C++ stack, pairing with OxiFont. Part of the sovereign Rust stack.
OxiUI is the COOLJAPAN Pure Rust UI layer — no GTK (C), no Qt (C++), no SDL (C), no raw AppKit/Win32/Cocoa bindings. A thin facade over egui and iced, rendered through wgpu or a CPU rasteriser, windowed through winit, with text shaped by OxiText + OxiFont. Part of the NoFFI sovereign Rust stack.
OxiAudio is the COOLJAPAN Pure-Rust audio codec and DSP layer — decode FLAC/WAV/MP3/Vorbis/AAC/ALAC/Opus/WavPack/Musepack/MIDI and encode WAV/RF64/FLAC/AIFF/AU with no FFI, plus a full DSP toolkit (filters, dynamics, reverb, phase vocoder, pitch detection, EBU R128 loudness, MFCC/STFT). A clean, memory-safe alternative to libFLAC, libvorbis, libopus, and dr_libs — part of the NoFFI / COOLJAPAN sovereign Rust stack.
Meet OxiCrypto: the COOLJAPAN Pure Rust cryptographic primitives layer — hashes, MACs, AEADs, signatures, key exchange, KDFs, password hashing, CSPRNGs, and a post-quantum preview (ML-KEM / ML-DSA / SLH-DSA). Zero *-sys crates by default, no C toolchain, the NoFFI replacement for OpenSSL, BoringSSL, ring, and aws-lc-rs as crypto backends.
OxiFont is the COOLJAPAN Pure Rust font discovery, parsing, subsetting, and web-font layer for the oxi* ecosystem. It replaces the fontconfig + FreeType C/C++ pair with zero-FFI Rust: enumerate system fonts on Linux/macOS/Windows, parse TTF/OTF/TTC/WOFF/WOFF2, do CSS Level 4 family matching, and subset to WOFF2. Part of the NoFFI sovereign Rust stack.
OxiQUIC is the COOLJAPAN Pure Rust QUIC transport and HTTP/3 stack. It implements RFC 9000/9001/9002 directly on the rustls QUIC TLS 1.3 API, driven by a Pure Rust crypto provider over tokio UDP — with zero dependency on ring, aws-lc-rs, or any C/C++ cryptographic library. Part of the NoFFI sovereign Rust stack.
OxiSound is the COOLJAPAN Pure-Rust audio device I/O layer — cross-platform playback and capture over ALSA, CoreAudio, and WASAPI, plus MIDI, SMF, and OSC. A NoFFI replacement for cpal/PortAudio and raw ALSA/CoreAudio/WASAPI bindings, part of the sovereign Rust stack.
OxiTLS is the COOLJAPAN Pure Rust TLS transport stack — a NoFFI replacement for OpenSSL, native-tls, and the ring / aws-lc-rs C-and-assembly crypto backends. TLS 1.3 and 1.2, mTLS, ALPN, session resumption, OCSP stapling, post-quantum key exchange, and a Pure-Rust CryptoProvider by default. The transport-security foundation under OxiHTTP, OxiQUIC, and OxiRPC.
Two days after its debut, OxiProj 0.1.1 adds Python (PyO3) and WASM bindings, Tissot indicatrix and covariance/autodiff analysis, SIMD + rayon + oxicuda GPU reprojection, and geo-types/geozero/GeoParquet interop. Still a Pure-Rust PROJ replacement — no C, no FFI.
TrustformeRS 0.1.2 patch — full Kubernetes/ACI/OpenShift deploy manifests, EnhancedProfiler exports (Flamegraph/OTLP/Jaeger), scaled-dot-product attention kernel fusion, NMS + token-classification pipelines, Q2_K/Q3_K GGUF quant; the stub-only TPU backend is removed for honesty.
OxiH5 is the COOLJAPAN Pure-Rust HDF5 reader — it parses real HDF5 files written by h5py and libhdf5 from raw bytes, with no hdf5-sys, no C libhdf5, and no unsafe in production paths. All 11 datatype classes, every chunk index, deflate/shuffle/fletcher32/szip/nbit/scaleoffset filters, mmap, and a NetCDF-4 reader on top — part of the NoFFI sovereign Rust stack.
OxiNum is the COOLJAPAN Pure-Rust arbitrary-precision math layer: bignum integers, exact rationals, high-precision floats, and complex numbers — replacing GMP, MPFR, and the rug / gmp-mpfr-sys bindings with zero C and zero FFI. Part of the NoFFI sovereign Rust stack.
OxiProto is the COOLJAPAN Pure-Rust Protocol Buffers stack — a native .proto parser, codegen, and wire runtime that replaces the protoc C++ compiler. No protoc binary, no build-time C++, no -sys crates. Proto2 + proto3, multi-file imports, reflection, JSON, and a CLI, all part of the NoFFI sovereign Rust stack.
This AmateRS patch activates horizontal sharding (QueryRouter, ShardRegistry, a placement scheduler that drives shard splits over Raft), adds end-to-end OpenTelemetry tracing, an io_uring WAL, an FHE circuit cache, constant-time API-key auth, and an async Python SDK.
OxiGAF 0.1.1 turns the monocular-video Gaussian-avatar reconstructor into a complete studio: FLAME rigging & FACS expressions, a full post-processing/volumetric render pipeline, an extended sampler & adapter suite, curriculum/meta-learning training, and a vastly expanded CLI. 12,537 tests, 100% Pure Rust.
A major step for OxiHuman, the privacy-first pure Rust parametric human body generator that runs entirely client-side via WASM/WebGPU. 0.2.0 replaces eight placeholder kernels with real implementations: articulated-body forward dynamics (CRBA + RNEA), skinned GLB export with JOINTS_0/WEIGHTS_0 and inverse-bind matrices, a procedural cubemap sky, exact CRC-32 combine, divergence-theorem fracture volumes, Stokes curl, and Laplacian AO. ~968,000 lines of Rust, 33,410 passing tests, 0 clippy warnings.
OxiProj 0.1.0 debuts: a 100% Pure-Rust replacement for proj-sys / PROJ. A near-complete port of PROJ 9.8.0 with ~197 projections, full Karney geodesics, ISO-19111 CRS, the EPSG proj.db via oxisql-sqlite-compat, and 1345 passing tests — no C, no FFI.
OxiCUDA 0.2.0, the pure-Rust replacement for the NVIDIA CUDA Toolkit, lands the 'Wave AAA+64' expansion: adaptive RK45 with Richardson extrapolation, Extended Persistence and Discrete Morse theory (oxicuda-tda), Parametric UMAP, and Fisher Information estimation — plus a workspace-wide zero-unwrap reliability pass and 32,320 passing tests. ~783K lines across 73 crates. No CUDA SDK, no nvcc.
rs3gw is a Pure Rust S3-compatible object-storage gateway. 0.2.2 adds feature-gated profiles — including a 100% C/FFI-free storage-only build — a pure-Rust protox proto compiler that removes the system protoc requirement, per-bucket usage/cost tracking via /api/usage, and an SSE HEAD Content-Length fix.
IPFRS 0.2.0, the Network Release, turns the Pure Rust InterPlanetary File System into a fully distributed node: libp2p with QUIC, a Kademlia DHT, Bitswap and a custom TensorSwap protocol, a Semantic DHT, GossipSub, and Apache Arrow zero-copy tensor streaming.
Pure-Rust legal statute engine. 0.1.6 adds real NVIDIA CUDA GPU acceleration for population-scale simulation (optional, with transparent CPU fallback), a hardened security/governance API layer, an autonomous and post-quantum-safe compliance audit subsystem, legal analytics with risk heatmaps, French civil/company law, and a fully C-free storage backend via OxiSQL. 18,398 tests passing.
OxiGDAL 0.1.6 eliminates rusqlite/libsqlite3-sys and ring from the workspace — SQLite now runs on oxisql-sqlite-compat (Limbo) and TLS on OxiTLS, making the default build 100% C/FFI-free. Plus GPX/KML/TopoJSON formats, non-UTF-8 DBF encoding, Delaunay triangulation, HDF5 v2/v3 superblocks, terrain GLCM/geomorphons/cost-distance, batch QC validators, and W-TinyLFU caching. 78 crates, 18 drivers, 14,605 tests.
A focused patch on top of the production-grade 0.3.0 release. The micromagnetic demag convolution gets flat kernel indexing plus optional rayon parallelism, BbhModel::hamiltonian_at now returns Result for proper error propagation, and scirs2-core/scirs2-spatial move to 0.5.0 with lean default features. 1829 tests passing, zero warnings.
OxiZ is a high-performance SMT solver in pure Rust — a Z3 replacement. 0.2.3 lands sound incremental BV & Simplex solving, a full term-level MaxSMT/OMT optimization pipeline, real BMC and k-induction model checking, and generic in-memory DRAT/LRAT proof writers — with 6,826 tests passing and 100% Z3 parity.
SplitRS 0.3.2 adds an SMT-verified extraction pass: it factors pure integer sub-blocks out of over-budget functions and commits the rewrite only when OxiZ proves the result is equivalent for all inputs. Plus array-splitting, a test-module splitter, shipped editor plugins, and 450 passing tests.
This patch adds exact finite-trace LTL operators (Next/Until/Release/WeakUntil/StrongRelease), tape-based GPU autodiff on OxiCUDA, Monte Carlo + variational probabilistic execution, SPARQL-as-tensor evaluation, neural architecture search, and SVM kernels — all on the SciRS2 stack, all Pure Rust.
OxiBonsai 0.2.2 adds `oxibonsai repl`: a resident ImageSession that loads the DiT, VAE, and text encoder once and iterates on prompts without re-paying the load/dequant cost — with images shown inline in Ghostty via a pure-Rust kitty graphics protocol, a `:fast`/`:hq` preview→finalize loop, and documented per-platform GPU flags. Sub-2-bit Pure Rust sovereign AI inference for the COOLJAPAN ecosystem.
OxiRS 0.3.1 completes SHACL Advanced Features (recursive + qualified value shapes + a rule-based reasoning engine), pushes RDF-star quoted triples through the whole query pipeline, adds GraphSAGE inductive embeddings, and finishes the Pure-Rust migration — the default build now links zero ring / aws-lc-sys C crypto.
OxiArc 0.3.3 is a correctness release: Brotli now round-trips high-entropy and incompressible data byte-for-byte across all quality levels 1–11. A package-merge Huffman code generator and an extended insert-length table fix two long-standing encoder bugs. Pure Rust, on-the-wire compatible, 1,679 tests passing.
A quality-of-life and correctness release for OxiBonsai: optimized test/dev compile profiles turn minutes-long numeric tests fast while keeping float parity bit-stable, a VAE precheck fix that finally accepts a .safetensors file, and corrected HuggingFace asset paths. Sub-2-bit Pure Rust sovereign AI inference for the COOLJAPAN ecosystem.
OxiPhysics 0.1.2 — the unified pure-Rust physics engine (Bullet/OpenFOAM/LAMMPS/CalculiX replacement) replaces approximation stubs with real algorithms: winding-number CSG mesh booleans, IMLS Poisson surface reconstruction, a hybrid QM/MM module (PM3, SCC-DFTB, HF, B3LYP), obstacle-aware RRT/PRM planning, and a real BGK Lattice-Boltzmann step. 16 new correctness tests; 100% C/Fortran-free by default.
QuantRS2 0.2.0, the pure-Rust quantum framework — production surface-code QEC (rotated codes d=3/5/7, MWPM & union-find decoders, Pauli-frame tracking), 3D state visualization (Bloch/Q-sphere/Wigner/Husimi), new Tytan samplers (Tabu, Simulated Bifurcation, population annealing), and a PennyLane device backend.
NumRS2 0.4.0 is the biggest release in the series: forward/reverse automatic differentiation with Hessians and hyperdual numbers, a distributed data/model-parallel framework, WebAssembly bindings that run numerics in the browser, plotters-based visualization, and a vast applied-math expansion — reinforcement learning, quantum computing, computer vision, computational geometry, FEM, wavelets, graphs, information theory, and control systems — all on pure-Rust SciRS2 0.5.0 with 128+ SIMD functions and 3,921+ passing tests.
The high-performance Pure Rust DataFrame library reaches 0.4.0 — a correctness landmark. PandRS replaces a large swath of fabricated and stubbed ML and statistical results with real algorithms: Jacobi-rotation PCA, t-SNE, DBSCAN, agglomerative clustering, IRLS logistic regression, isolation-forest/LOF/OneClassSVM anomaly detection, real silhouette and ROC-AUC, and genuine chi-square/t/F p-values. SciRS2-Core becomes a non-optional core dependency, and the SciRS2 stats/linalg integration deepens onto the 0.5 line. The DataFrame layer of the COOLJAPAN scientific stack — no pandas, no scikit-learn C-extensions, no GIL.
OxiCode 0.2.4 makes the streaming encoder/decoder generic over the Config type so encoder and decoder pairs can share an explicit codec configuration via new_with_config, implements core::error::Error for DeError/SerError in no_std + alloc, bumps the MSRV to 1.81, and moves OxiARC pure Rust compression to 0.3.2. Same 100% bincode-2.0 binary compatibility.
OxiMedia 0.1.8 — patent-free, memory-safe FFmpeg + OpenCV replacement in pure Rust. A feature-rich release: a Whisper-compatible AutoCaption ONNX pipeline, mmap-backed file repair, log-mel spectrograms, filmic ACES/Reinhard tone curves, and zero-copy CMAF segment output via bytes::Bytes. 109 crates, 100,278 tests, zero C/Fortran in default builds.
OxiBonsai 0.2.0 opens the 0.2 series: a concurrent engine pool that shares one 1.16 GB embedding table across replicas, a CPU↔Metal byte-identical parity guard, a parity-first CUDA imagen backend (~3.2× to ~31.7s on A4000), --seed byte-exact reproducible images, and a stable-toolchain build — sub-2-bit Pure Rust sovereign AI inference for the COOLJAPAN ecosystem.
SciRS2 0.5.0 brings real pure-Rust wgpu/WebGPU acceleration — GpuNdarray, GPU graph algorithms, GPU optimizers (L-BFGS/CG/Newton), GPU RBF interpolation — plus correct Pantelides DAE index reduction, high-order SDE Lévy-area, Hilbert curves, and a maturing symbolic CAS. The NumPy/SciPy/scikit-learn replacement, in pure Rust.
OxiBonsai 0.1.5 adds the oxibonsai-image crate — the first pure-Rust, zero-FFI, C/C++/Fortran-free FLUX.2-Klein text-to-image pipeline (DiT + VAE + Qwen3-4B text encoder), parity-validated at cos≥0.999, with Metal flash-attention and ~52–62s end-to-end on an M3. Sub-2-bit Pure Rust sovereign AI inference for the COOLJAPAN ecosystem, now spanning text and image.
OxiArc 0.3.2 introduces oxiarc-szip: a Pure Rust implementation of AEC/SZIP (CCSDS-121.0-B-2), the lossless codec behind the HDF5/NetCDF SZIP filter and widely used in satellite and scientific data. Byte-for-byte compatible with libaec. No C, no zlib — 1,666 tests passing.
OxiZ is a pure-Rust SMT solver reimplementing Z3. 0.2.2 ships real LBD clause scoring (replacing the old stub), Big-M primal simplex for LP, an LRU lemma cache, ML conflict-hook branching, and deeper Z3-compat APIs — all with 100% Z3 parity and zero C/C++/Fortran.
OxiArc 0.3.1 adds front-to-back archive repair and recovery for corrupt ZIP and TAR files, custom-dictionary compression for LZH and LZMA, and a thread-safe LZMA memory pool. Pure Rust, no zlib, no libarchive — 1,647 tests passing, zero warnings.
Pure Rust FFT and the rustfft replacement. OxiFFT 0.3.2 completes multi-rank MPI execution for the 3D pencil decomposition, gates AVX-512 codelets behind a default-off feature so the build stays clean on rustc 1.95 stable, hardens ND-plan error handling, and refreshes the OxiCUDA GPU backend.
OxiGDAL 0.1.5 is a focused fix release: a stray padding field in the RayMarchUniforms WGSL layout was shifting every field by 4 bytes, making the GPU compute kernel read a billion-step max and hang indefinitely on macOS Metal. With the layout corrected, the ray-march GPU/CPU parity test passes in 0.127s. 78 Pure Rust workspace crates, 14,605 passing tests.
OxiMedia 0.1.7 — patent-free, memory-safe FFmpeg + OpenCV replacement in pure Rust. A focused stability release fixing five tracked issues: Theora plane copy, Windows/WASM gating for IPC sockets, globally-unique temp filenames, an AVC SPS doctest, and collision-free scope temp files. 109 crates, 84,064 tests, zero C/Fortran in default builds.
Pure-Rust CUDA Toolkit replacement: a maintenance release with numerical-stability refinements in the HMC variational sampler, stream-ordered allocator tuning, and TriMap reduction polish — 23,535 passing tests. No CUDA SDK, no nvcc.
The 0.3 line of Pure Rust archive and compression: a Zopfli-style optimal DEFLATE parser, an LZMA BT4 match finder that delivers SDK-grade level-9 quality, true bounded-memory LZ4 streaming, parallel Snappy, optimal LZSS for LZH, and memory-mapped archive access. ~71k SLoC across 227 files, 1,640 tests, 13 crates. API-stable as of v0.3.0.
OxiPhysics 0.1.1 — the unified pure-Rust physics engine (Bullet/OpenFOAM/LAMMPS/CalculiX replacement) gains real, feature-gated PyO3 0.28 Python bindings: 210 #[pyclass] types across 14 domain modules, plus wasm-bindgen 0.2 browser bindings. Most domain crates graduate from Alpha to Stable. Still 100% C/Fortran-free in default builds.
OxiBonsai 0.1.4 makes Pure Rust sub-2-bit inference production-grade for serving: adaptive KV-cache compression and adaptive speculative decoding that self-tune under load, full Prometheus observability with per-request X-Request-ID tracing, new FP8 and K-quant GGUF model support, and grammar-constrained decoding for guaranteed-valid JSON — sovereign AI inference for the COOLJAPAN ecosystem.
Pure-Rust replacement for the entire NVIDIA CUDA Toolkit. 0.1.7 adds a SYR2K Tensor Core kernel (fused A×Bᵀ + B×Aᵀ rank-2k update) to oxicuda-blas, cross-subsystem CUDA kernel enhancements, and Multi-Operation Scheduling improvements. No CUDA SDK, no nvcc, no C/C++ toolchain.
rs3gw is a Pure Rust S3-compatible object-storage gateway powered by scirs2-io. The 0.2.1 patch migrates compression to COOLJAPAN OxiArc (oxiarc-zstd/lz4/deflate), expands Object Lock, RestoreObject, and SSE test coverage to 961 tests, and resolves an OpenTelemetry version conflict.
SciRS2 0.4.4 turns scirs2-symbolic into a full computer algebra system — EML-IR-native canonical form, real OxiZ SMT verification, Cranelift JIT, symbolic regression, and LaTeX export. A pure-Rust SymPy/Mathematica alternative on top of the NumPy/SciPy replacement.
A maintenance patch for the AmateRS FHE database: a resolved clippy doc_lazy_continuation lint, a corrected MerkleTree intra-doc link, and a cargo fmt cleanup across the server hot-reload and main modules. Zero-warning, docs-clean discipline — no API changes.
Pure-Rust replacement for the NVIDIA CUDA Toolkit. OxiCUDA 0.1.6 adds a Tensor Core fast path for SYRK in oxicuda-blas and sixteen new ML crates (adversarial, SSL, continual, multimodal, 3D geometry, PINN, ANN, anomaly, causal, meta, MoE, NeRF, quantum, recsys, RLHF, tabular). No CUDA SDK, no nvcc.
Pure Rust archive and compression gets faster and broader. OxiArc 0.2.8 adds SIMD CRC32 via aarch64 PMULL and Snappy CRC32C via SSE4.2, ISO 9660 read support with Joliet filenames, byte-for-byte raw-preserve append for ZIP/LZH, progress/cancel builders for LZ4/Zstd/LZMA, and a per-entry memory limit. ~58k SLoC, 1,281 tests, 12 crates.
A small OxiCode patch that restores a fully clean clippy run across the workspace and eliminates temp-file collisions in seven async and file-I/O test modules under concurrent execution. No API or wire-format changes — same 100% bincode-2.0 binary compatibility, same Pure Rust guarantee.
OxigenAI is a Pure Rust GovTech reimplementation of the Digital Agency's government legal-AI system (源内 / GenAI). It keeps the familiar law-report API but adds OxiZ SMT contradiction detection and Legalis-RS LegalResult<T> outcome classification — turning a probabilistic LLM+RAG service into a verifiable computational-law platform.
A maintenance release for OxiHuman, the privacy-first pure Rust parametric human body generator that runs entirely client-side via WASM/WebGPU. 0.1.2 makes the MakeHuman-backed test suite fully portable — dataset and asset roots now resolve through MAKEHUMAN_DATA_DIR and OXIHUMAN_ASSETS_DIR, and fixtures skip gracefully when unset. ~943,000 lines of Rust, 32,791 passing tests, zero hard-coded paths.
OxiLLaMa 0.1.3 is the Pure Rust LLM inference engine and sovereign alternative to llama.cpp. This release adds BLOOM + Phi-3.5-MoE architectures (now 27 total), a 5-stage advanced sampler suite (DRY/XTC/TypicalP/TopA/Eta) that is byte-identical at defaults, embedding pooling modes, a drop-in /v1/responses API with per-API-key rate limiting, AVX-512 IQ kernels at ~2x per-iteration throughput, GPU-resident sampling kernels, and zero-copy DLPack PyTorch interop — 2,461 tests passing.
OxiRS 0.3.0 turns the Rust-native Semantic Web stack enterprise-ready: SOC2/GDPR audit logging, OIDC + SAML 2.0 single sign-on, a HuggingFace/Ollama/GGUF model marketplace, LoRA fine-tuning for GraphRAG, and published LTS + enterprise support policies.
OxiBonsai 0.1.3 makes sub-2-bit serving smarter: a prefix-cache-aware engine that reuses KV-cache across requests with byte-identical cold/warm parity, runtime tokenizer auto-detection, and a GPU weight cache that uploads once. Sub-2-bit Pure Rust sovereign AI inference for the COOLJAPAN ecosystem.
A focused OxiCode patch: a deny.toml policy gate to ban unsafe or incompatible crates, the bincode dev-dependency pinned to =2.0.1, OxiARC pure Rust compression bumped to 0.2.7, and more robust temp-file handling in the file-I/O test suite. Same 100% bincode-2.0 binary compatibility, same Pure Rust guarantee.
The pure-Rust NVIDIA CUDA Toolkit replacement adds nine new GPU deep-learning crates — generative diffusion, graph neural nets, Mamba SSMs, vision transformers, audio/speech, time-series, Bayesian DL, federated learning, and NAS — growing to ~320K lines across 37 crates with 9,568 passing tests. No CUDA SDK, no nvcc.
OxiLean 0.1.2 lands real SMT solving via OxiZ, a complete 157-instruction WebAssembly bytecode interpreter wired to the real kernel/parse/elab pipeline, keccak256-correct EVM/Solidity ABI selectors, real Gröbner-basis reduction for polyrith, and 33,091 passing tests — all in a Pure Rust theorem prover.
Pure Rust autonomous semantic federation engine: learned source selection for SPARQL federated queries — context-aware, ML/RL-driven, edge & WASM-ready. 501 tests, 23k LoC, no_std-capable. No JVM. No C. No server farm.
SciRS2 is the pure-Rust SciPy/scikit-learn replacement. 0.4.3 introduces the brand-new scirs2-symbolic crate (symbolic differentiation + algebraic simplification), full WASM TypeScript declarations & React hooks, an inverse wavelet packet transform, and modernized dependencies — 34,883 tests, 2.94M lines, 32 crates, zero warnings.
Pure Rust FFT and the rustfft replacement: OxiFFT 0.3.1 adds Winograd mixed-radix Cooley-Tukey for smooth-7 sizes (retiring Bluestein for them), FFTW-style MEASURE/PATIENT auto-tuning with a binary wisdom format and an oxifft_tune CLI, plus an opt-in ndarray integration.
Kizzasi 0.2.1 turns the Pure-Rust AGSP into a full training + deployment stack: full backprop through SSM recurrence, RWKV v5/v7, Neural ODE and Spiking models, LoRA fine-tuning, GGUF loading, gRPC/REST servers, Python bindings, and no_std embedded inference.
sklears 0.1.1 is a correctness patch for pure-Rust scikit-learn: HDBSCAN cluster-persistence fix, streaming scaler/imputer Default cleanups, a pipeline lifetime fix, and serialization fixes — 11,586+ tests across 36 crates, >99% scikit-learn API coverage held.
TensorLogic compiles logical rules (predicates, quantifiers, implications) into optimized einsum graphs for unified neural, symbolic, and probabilistic models. It now graduates from 0.1.0-rc.1 to its first stable 0.1.0 on an upgraded SciRS2 0.3.4 / OxiRS 0.2.2 / SkleaRS 0.1.0 / ToRSh 0.1.1 stack — fully Pure Rust, zero warnings, 6,397 tests at 100%.
ToRSh is a pure-Rust, PyTorch-compatible deep-learning framework with native tensor sharding. 0.1.2 lands real AVX2/NEON SIMD for f32 ops and activations, a true zero-copy buffer pool (100% heap-block reduction on hot loops), and SIMD + parallel enabled by default.
TrustformeRS 0.1.1 patch — 22 new transformer architectures (49+ total: Falcon2, Gemma2, Mamba2, Qwen2.5, Phi4, Whisper, StarCoder2, xLSTM, and more). ONNX Runtime replaced by Pure Rust oxionnx, tar replaced by oxiarc-archive, Kafka feature-gated. Load any architecture through one AutoModel call — no Python, no PyTorch, no C++ ONNX runtime.
AmateRS is a distributed database with Fully Homomorphic Encryption that computes on encrypted data without ever decrypting it server-side. 0.2.0 — our biggest changelog yet — adds UPDATE queries with atomic rollback, query-result caching, OCSP revocation, JWT algorithm expansion, GPU detection, graceful shutdown, and 3 end-to-end FHE examples.
OxiMedia 0.1.6 — patent-free, memory-safe FFmpeg + OpenCV replacement in pure Rust. This release resolves 13 codec stubs (accel color conversion, Vorbis VQ decode, ACES ODT variants), upgrades to OxiFFT 0.3.0 for a ~4x faster DCT-II, and splits the EXR reader into 9 modules. 108 crates, 81,582 tests, zero C/Fortran in default builds.
OxiWhisper 0.1.1 adds transparent GGUF loading, an optional rayon-parallel attention feature, memory-mapped models, f16 KV-cache, FLAC/OGG/MP3/AAC/Opus decoding, and true banded-DTW word timestamps — still Pure Rust, no C or Python.
OxiZ is a pure-Rust SMT solver and Z3 replacement. 0.2.1 sharpens the EUF (congruence-closure) hot path: reusable allocation buffers, O(k) incremental pop() via a sig_table/fingerprint_table trail, cache-friendly ENode layout, and new production EUF criterion benchmarks. 100% Z3 parity, still pure Rust.
Pure Rust FFT and the rustfft replacement. OxiFFT 0.3.0 lands an FFT-based Makhoul DCT (~4× flop reduction), a 7-gate FFTW parity harness, GPU batch FFT with auto-chunking, 3D pencil MPI, a cache-oblivious 4-step transform, and real WASM SIMD v128 — 1360 tests passing, default build still 100% Rust.
OxiLLaMa 0.1.2 is the Pure Rust LLM inference engine and sovereign alternative to llama.cpp. This release adds `oxillama hub pull/list/rm` (hf-hub, no Python), a full-screen TUI chat with live streaming (ratatui), conversation save/resume serialized via oxicode with SHA-256 integrity, and real weight loading for DBRX, Grok-1, and Mamba-2.
SplitRS is the AST-based Rust refactoring tool that splits monolithic source files into clean, compilable modules. 0.3.1 ships splitrs-lsp — a language server with diagnostics, a Refactor with splitrs code action, and live config watch — so the split happens right inside Neovim, Helix, or VS Code.
OxiLLaMa is a Pure Rust LLM inference engine — the sovereign alternative to llama.cpp. Version 0.1.1 ships a tiled FlashAttention CPU kernel, true continuous batching with zero padding waste, fused dequant+GEMM (~12% Q4_K_M decode gain), 5 new architectures (DBRX, Grok-1, Mamba-2, DeepSeek-V3, and more), and GPU coverage extended to 10 quantization types.
TenfloweRS 0.1.1 is an ergonomics + compatibility patch for the pure-Rust TensorFlow alternative: a declarative tensor! macro, an expanded prelude (transformers and RNNs), ndarray interop, ONNX re-exports, wgpu v29 compatibility across 57 sites, and richer typed Python FFI errors.
Pure-Rust legal statute engine: 0.1.5 is a sovereignty and hardening release. The last non-pure-Rust dependency (printpdf) is replaced by the COOLJAPAN fop-render PDF backend, an RSA CVE is eliminated, every unwrap() is removed from production code, and the default build is now 100% Pure Rust across 23 jurisdictions. 14,763 tests passing.
Pure Rust archive and compression with a new in-place editing workflow. OxiArc 0.2.7 adds the `oxiarc add` command for appending files to existing ZIP/TAR/LZH archives, lenient recovery of malformed archives, async LZH/TAR streaming, cooperative cancellation, colored output, and man pages. 12 formats, 10 codecs, 12 crates, ~47k SLoC, 1,041 tests.
Pure-Rust FFmpeg+OpenCV replacement: OxiMedia 0.1.5 adds the oximedia-ml crate — typed ML pipelines (SceneClassifier, ShotBoundaryDetector, and more) on the Pure-Rust OxiONNX runtime, with a Python oximedia.ml submodule and an opt-in, symbol-free-by-default design. Plus a codec-decoder honesty pass. 108 crates, ~2.68M SLoC, 81,383 tests.
OxiMedia is the pure-Rust FFmpeg + OpenCV replacement. Release 0.1.4 wires MJPEG and APV codecs end-to-end, adds OpenDML AVI and animated JPEG-XL containers, low-latency DASH/CMAF streaming, deeper FFmpeg CLI compat (-crf/-vf/two-pass), and fixes the JPEG encoder (round-trip PSNR 6.16 -> 32.53 dB). 108 crates, ~2.67M SLoC, 81,150+ tests passing.
OxiBonsai 0.1.2 adds ONNX ingestion: pull an onnx-community Ternary ONNX release (MatMulNBits, bits=2) and repack it straight to OxiBonsai's GGUF TQ2_0_g128 with a single command — driven by the pure-Rust oxionnx-proto reader, no Python and no onnxruntime. Sub-2-bit sovereign AI inference for the COOLJAPAN ecosystem.
OxiGDAL 0.1.4 lands Weiler-Atherton polygon clipping, Karney geodesic area, DE-9IM topology predicates, and marching-squares contours, plus AVX2/NEON SIMD resampling, a completed COPC point-cloud reader, R-tree STR bulk loading + kNN, and a migration from ort to oxionnx for fully Pure Rust ONNX inference. 76 crates, 12,064 passing tests.
High-performance DataFrame library for Rust — pandas-class API with SIMD, parallel, and distributed processing. 0.3.1 swaps the Excel/xlsx C-dependency chain (zip/flate2/miniz_oxide via calamine + simple_excel_writer) for an in-tree OxiARC-backed xlsx engine, removes the dirs -sys crate, and pins datafusion/parquet/arrow to drop liblzma/zstd-sys/lz4-sys. 1809 tests + 117 doc tests passing, zero clippy warnings. The DataFrame layer of the COOLJAPAN scientific stack.
A same-day patch on the heels of PandRS 0.3.1. Converts the root Cargo.toml into a virtual workspace, hoists ~55 common dependencies into [workspace.dependencies] for consistent versions across the crate and py_bindings, fixes clippy and test hygiene, makes test temp paths portable, and purges 134 stale backup files. No public API changes; 1813 tests pass.
A measurement-focused patch for NumRS2, the pure Rust NumPy alternative. 0.3.3 adds criterion benchmark suites for I/O, complex-number, and sparse-matrix operations, refreshes every dependency to its latest version, clears clippy warnings, and nudges the distributed-optimization module forward. Same numerical core, on SciRS2 0.3.0 and OxiBLAS.
Five days after its 1-bit debut, OxiBonsai grows GPUs: a native CUDA NVRTC backend (~21.9 tok/s on Ternary-Bonsai-1.7B, RTX 3060) and a fused Metal full-forward path (~50 tok/s, ~13x speedup) — plus the new ternary TQ2_0_g128 quant family, with NEON/AVX2/AVX-512 GEMV so it flies on CPU too. Sub-2-bit Pure Rust sovereign AI inference for the COOLJAPAN ecosystem, still with no llama.cpp, no BLAS, no C/Fortran.
A small maintenance release for OxiCUDA, the pure-Rust replacement for the NVIDIA CUDA Toolkit. Workspace-wide documentation and quality improvements, with all 28 crates aligned to 0.1.4 so the stack ships in lockstep. The only runtime dependency is the NVIDIA driver.
A quality-and-docs maintenance release for the pure-Rust NVIDIA CUDA Toolkit replacement — workspace-wide polish, internal version alignment to 0.1.3, and continued growth to ~260K lines of safe Rust across 28 crates. The only runtime dependency is still the NVIDIA driver.
Complete, type-safe, memory-safe rewrite of the entire NVIDIA CUDA Toolkit in pure Rust. cuBLAS/cuDNN/cuFFT/cuSPARSE/cuSOLVER/cuRAND and more — all in 253k SLoC across 28 crates. Only runtime dependency is the NVIDIA driver. PTX codegen + autotuner, 7 GPU backends (Metal/Vulkan/WebGPU/ROCm/LevelZero). ≥90–95% of native CUDA performance. The sovereign GPU computing layer for SciRS2 and the entire COOLJAPAN ecosystem (now 21M+ SLoC total).
Pure Rust implementation of the eml(x, y) = exp(x) − ln(y) operator + constant 1 that expresses ALL elementary mathematical functions via uniform binary trees. Symbolic regression engine, lowering to efficient IR, code generation, CLI, SMT solving via OxiZ, SIMD/parallel batch evaluation via oxiblas-core. 173 tests, zero FFI. The sovereign mathematical foundation for SciRS2 and the entire COOLJAPAN ecosystem (now 26M+ SLoC total).
Complete GGUF loading + 25 quantized formats + OpenAI-compatible API server — all in pure Rust. 56.2k SLoC, 11 crates, no C/C++/Fortran, built on SciRS2/OxiBLAS/OxiFFT. ≥80% of llama.cpp throughput, WASM/GPU/Python bindings, LLaMA/Mistral/Gemma/Phi/LLaVA support. The sovereign LLM inference layer for SciRS2 and the entire COOLJAPAN ecosystem (now 21M+ SLoC total).
Patent-free, memory-safe multimedia and computer-vision framework in pure Rust. Full reconstruction of FFmpeg (codecs, containers, streaming) + OpenCV (detection, tracking, enhancement). 2.65M+ SLoC, 106 stable crates, GPU (wgpu), WASM, async pipelines, royalty-free codecs only. High-performance media processing without C dependencies. The sovereign media layer for SciRS2 and the entire COOLJAPAN ecosystem (now 21M+ SLoC total).
Kaccy 0.2.0 hardens the Bitcoin-native Personal Token Platform for production: complete rustdoc (0 missing_docs), 375 new tests, 32 bonding-curve property tests, closed-form O(1) curves, BIP 340 Schnorr, bech32m, a memory profiler, custom LLM endpoints, and a dockerized stack.
First patch on the pure-Rust NVIDIA CUDA Toolkit replacement: six new oxicuda-blas elementwise activations (HardSigmoid, HardSwish, Softplus, LeakyRelu, Ceil, Floor) plus substantial ROCm/Vulkan/WebGPU backend growth. ~248K lines across 28 crates.
OxiFFT, the Pure Rust FFT and rustfft replacement, turns runtime panics into compile-time errors: 0.2.0 makes 2D/3D and real plans Option-returning with honest types, ships a drop-in fftw-compat API to port C code, and adds Debug and #[must_use] across every plan type. 858 tests passing.
High-performance IPFS-based decentralized content delivery network with dynamic rewards, bandwidth proofs, gamification, and anti-fraud. 198k+ SLoC pure Rust, Tauri desktop node, web creator portal, OxiARC compression. Node operators earn real rewards for bandwidth and storage. The sovereign content distribution layer for SciRS2 and the entire COOLJAPAN ecosystem (now 26M+ SLoC total).
An 8B-parameter language model at roughly 1 bit per weight, running from a single static Rust binary with no llama.cpp, no BLAS, no C/C++/Fortran. OxiBonsai 0.1.0 debuts sub-2-bit Pure Rust sovereign AI inference for the COOLJAPAN ecosystem — SIMD-accelerated, Rayon-parallel, and OpenAI-compatible out of the box.
OxiCUDA 0.1.0 is a pure-Rust, type-safe, memory-safe replacement for the entire NVIDIA CUDA Toolkit software stack — cuBLAS, cuDNN, cuFFT, cuSPARSE, cuSOLVER, cuRAND and more in ~239K lines across 28 crates. The only runtime dependency is the NVIDIA driver. PTX code generation plus a built-in autotuner, all from safe Rust.
SciRS2 0.4.2 — pure-Rust SciPy/NumPy/scikit-learn replacement, 2.94M SLoC, 27,632 tests, 29 crates. This release adds Neural Architecture Search, CMA-ES, Mamba SSM, async/unified GPU memory, H-matrix compression, streaming FFT, DLPack zero-copy, and Apache Iceberg/DataFusion IO. No C/Fortran.
OxiFFT 0.1.4, the Pure Rust FFT and rustfft replacement, adds a full signal-processing module — Hilbert transform, Welch PSD, cepstrum, and FFT resampling — plus mel-spectrogram and MFCC audio analysis. No C, no Fortran, no FFTW.
The first public release of OxiPhysics: a unified, pure-Rust physics engine targeting Bullet (rigid body), OpenFOAM (CFD), LAMMPS (molecular dynamics), and CalculiX (FEM) in one workspace. 17 crates spanning collision, SPH/LBM fluids, FEM, MD, soft body, materials, and visualization — with zero todo!()/unimplemented!() stubs and no C or Fortran in default features.
OxiZ 0.2.0 ships an ergonomic EasySolver builder, no_std support for bare-metal/zkVM (RISC-V), a Pure-Rust ML heuristics crate (oxiz-ml), Skolemization, a modular WASM js_api, and 100% Z3 parity across 88 benchmarks. Zero C/C++.
OxiRS 0.2.4 ships a production-hardening pass for the Rust-native Semantic Web stack: a completed unwrap() audit, GPU feature-gating for Pure-Rust default builds, CLI flag fixes, and a fresh SciRS2 0.4 / OxiARC dependency refresh — 40,786 tests, zero warnings.
Production-ready, binary-level compatible drop-in replacement for Python Celery. 18 crates (100% complete), 4,075 tests, 10× throughput, type-safe macros, 5 brokers + 3 backends, Canvas workflows, DLQ, priority queues, task cancellation, and full observability. <50 MB memory, 10,000 tasks/sec per worker. The sovereign distributed task queue layer for SciRS2 and the entire COOLJAPAN ecosystem (now 26M+ SLoC total).
SciRS2 0.4.1 is a pure-Rust SciPy/NumPy/scikit-learn replacement: 2.91M SLoC, 25,863 tests, 32 crates. This release improves JIT compilation in scirs2-core, ships a 76-test WebGPU/WASM backend for browser GPU compute, and validates 15+ distributions to numerical accuracy. No C. No Fortran.
A small packaging and distribution patch for NumRS2, the pure Rust NumPy alternative. 0.3.2 smooths out PyPI publishing so the maturin-built Python wheels pip install cleanly, and resolves a minimum-output-size constraint. Same numerical core as 0.3.1, on SciRS2 0.3.0 and the OxiBLAS pure-Rust backend.
OptiRS is the Pure Rust ML optimizer suite — 22 optimizers across 7 crates — built on SciRS2. 0.3.1 is a maintenance patch: version sync across every crate's doc comments, a new optirs-wasm README, and fixed stale version strings. Honest housekeeping on top of 0.3.0.
OxiWhisper 0.1.0 is a Pure Rust OpenAI Whisper inference engine — GGML loading, Q4_0/Q5_0/Q8_0 quantized inference, beam search, 99-language detection, streaming, and SRT/VTT export, with zero C/C++/Python dependencies.
High-performance pure Rust DataFrame library — a pandas-class API with SIMD, parallel processing, and distributed compute. 0.3.0 purges the entire SQL/database stack (sqlx, rusqlite, libsqlite3-sys) to enforce Pure Rust, modernizes the columnar engine to Arrow/Parquet 58.1 and DataFusion 53.0, and upgrades SciRS2 integration to 0.4.0. The DataFrame layer of the COOLJAPAN scientific stack, alongside NumRS2.
QuantRS2 0.1.3, the pure-Rust quantum framework — real KAK/ZYZ/holonomic decompositions, parameter-shift VQE gradients, ZX-calculus rewrites, SABRE routing, MPS tensor-network compression, ML circuit optimizers, PyO3 0.26, and a ~210-unwrap robustness pass.
High-performance ONNX runtime written entirely in pure Rust. Zero C/C++ dependencies, 147 operators fully supported, wgpu GPU acceleration, SIMD (AVX2/NEON), WASM + no_std ready, graph optimizer, async execution, model encryption. 30k+ SLoC, 590+ tests. The sovereign ONNX inference layer for SciRS2 and the entire COOLJAPAN ecosystem (now 21M+ SLoC total).
SciPy-compatible scientific computing and AI framework in 100% Pure Rust. 2.91M SLoC, 29 crates, 25,800+ tests. Flash Attention 2, LoRA/DoRA/GPTQ, ONNX export, GPU PDE/FFT/SpMV, Temporal GNNs, NeRF/instant-NGP, WebGPU backend, Delta Lake / Kafka I/O and more. 10–100× faster, zero system deps. The sovereign scientific computing and AI foundation for the entire COOLJAPAN ecosystem (now 21M+ SLoC total).
Production-grade pure Rust Text-to-Speech (TTS), Voice Recognition, and Sound framework. VITS + HiFi-GAN/DiffWave vocoders, real-time ≤0.05× RTF on GPU, streaming synthesis, SSML, 20+ languages, ONNX/Kokoro-82M support, SafeTensors checkpoints. Full integration with SciRS2/NumRS2. WASM, GPU (CUDA/Metal), Python/FFI bindings. The sovereign speech AI layer for the entire COOLJAPAN ecosystem (now 21M+ SLoC total).
Next-generation distributed mail server written entirely in Rust. Full SMTP/IMAP/JMAP/POP3 support, Mailet-based processing pipeline, AI integration (OxiFY), legal archiving (Legalis-RS), and AmateRS distributed storage. 16 crates, 1,942 tests, 10–50 MB memory footprint, >50,000 messages/second throughput. The sovereign mail infrastructure layer for SciRS2 and the entire COOLJAPAN ecosystem (now 21M+ SLoC total).
High-performance numerical computing library in pure Rust — the production-grade NumPy alternative. 222k+ SLoC, 4,704+ tests, 128+ SIMD-vectorized functions, N-dimensional arrays, advanced linalg via OxiBLAS, automatic differentiation, FFT, GPU (wgpu), Python bindings (PyO3), Arrow interop. 80–172% of OpenBLAS performance, zero C/Fortran deps. The sovereign numerical layer for SciRS2 and the entire COOLJAPAN ecosystem (now 21M+ SLoC total).
12 archive formats and 10 compression algorithms implemented from scratch in pure Rust. DEFLATE up to 400 MB/s, SIMD-accelerated CRC (3–4.5× faster), full async streaming, Brotli + Snappy support, LZH (Japanese legacy) full support. ~47k SLoC, 12 crates, 1,041 tests. The sovereign data packaging layer for SciRS2 and the entire COOLJAPAN ecosystem (now 21M+ SLoC total).
Pure Rust Hugging Face Transformers — the first stable release. 27+ transformer architectures, 17x CPU BLAS acceleration, GGUF/AWQ/GPTQ quantization, and WASM + server + mobile deployment. No Python, no PyTorch.
The first stable release of sklears: a pure-Rust scikit-learn alternative spanning 36 crates with >99% API coverage, type-safe Untrained→Trained state machines, and a SciRS2 foundation. No Python runtime, no GIL, no C or Fortran.
TenfloweRS is a pure-Rust alternative to TensorFlow, and this is its first stable release. It ships dual eager + graph execution, reverse-mode autodiff, 150+ research domains, and WGPU GPU acceleration — built on the SciRS2 and NumRS2 ecosystem, with no C++, CUDA-C, or Python runtime.
ToRSh is a PyTorch-compatible deep-learning framework in pure Rust with native tensor sharding. The 0.1.1 release hardens the 33-crate workspace onto consistent, published crates.io dependencies and adds the new torsh-convert model-converter CLI.
Production-grade machine learning optimization library with 22 optimizers (SGD→K-FAC), SIMD 2–4×, parallel 4–8×, GPU 10–50× acceleration. 251K+ SLoC, 7 crates, 1,220+ tests. Full extension of SciRS2-Core — no external deps allowed. The sovereign optimizer layer for SciRS2 and the entire COOLJAPAN ecosystem (now 21M SLoC total).
OxiArc 0.2.5 adds two brand-new compression crates — Brotli (RFC 7932, quality 0-11) and Snappy (block + framed with CRC32C) — bringing the workspace to 12 crates and 12 container formats. Plus DEFLATE/GZip/Zlib streaming with flush modes, LZW streaming, and an EntryBuilder fluent API. 1,038 tests, all passing. Pure Rust archive and compression — no C, no zlib, no libarchive.
SciRS2 0.3.4 is the pure-Rust SciPy/NumPy/scikit-learn replacement: 2.59M SLoC, 19,700+ tests, 29 workspace crates. This release upgrades OxiARC to 0.2.5 and purges the last C-library (GMP/MPFR) and the zip crate from the dependency tree for a leaner, smaller-attack-surface, 100% Pure Rust supply chain.
OxiGDAL 0.1.2 adds a PMTiles v3 writer with Hilbert tile IDs and content dedup, a full geometry validation/operations module (centroid, area, point-in-polygon, simplify, convex hull), and a unified umbrella crate with 12-format conversion planning. Now 76 Pure Rust workspace crates, 15 format drivers, 10,935 passing tests — zero C dependencies in default features.
Production-grade pure Rust geospatial data abstraction library. 11 format drivers (GeoTIFF/COG, GeoParquet, Zarr, NetCDF, etc.), 211+ EPSG definitions, cloud-native async I/O (S3/GCS/Azure), GPU acceleration (wgpu), WASM + Python bindings. ~480k SLoC, 69 crates, 7,486 passing tests. 10× faster than GeoPandas, <50 MB Docker, no C deps. The sovereign geospatial layer for SciRS2 and the entire COOLJAPAN ecosystem.
Patent-free, memory-safe multimedia and computer-vision framework in pure Rust. Full reconstruction of FFmpeg (codecs, containers, streaming) + OpenCV (detection, tracking, enhancement). 2M+ SLoC, 107 crates, GPU (wgpu), WASM, async pipelines, royalty-free codecs only. 10–50× faster than Python+FFmpeg/OpenCV, single static binary, no C deps. The sovereign media layer for SciRS2 and the entire COOLJAPAN ecosystem.
SciRS2 is a pure-Rust SciPy/NumPy/scikit-learn replacement — 2.59M SLoC, 19,700+ tests, 29 crates, no C or Fortran. The 0.3.2 patch upgrades the Python bindings to pyo3 0.28.2 (Python::attach) for free-threaded CPython 3.13, plus benchmark modernization with std::hint::black_box.
2.59 million lines of pure Rust. SciPy-compatible APIs, 10-100× faster with SIMD, no C/Fortran deps, 29 crates, 19,700+ tests, Python + WASM + no_std. The sovereign scientific computing and AI foundation for the entire COOLJAPAN ecosystem.
10 archive formats and 8 compression algorithms implemented from scratch in pure Rust. DEFLATE up to 400 MB/s, SIMD-accelerated CRC (3–4.5× faster), full async support, LZH (Japanese legacy) support, ZIP/TAR/GZIP/Zstd/LZ4/XZ and more. The sovereign data packaging layer for SciRS2 and the entire COOLJAPAN ecosystem.
Production-grade BLAS and LAPACK entirely in Rust. Up to 172% of OpenBLAS performance on Apple M3, full sparse solvers, f128 precision, RuntimeAutoTuner, no_std support. The sovereign mathematical foundation for SciRS2 and the entire COOLJAPAN scientific computing stack.
OxiCode's first 0.2 minor: a major API expansion with a BorrowDecode derive for zero-copy decoding, the SizeWriter / encoded_size pre-allocation API, encode_to_file / decode_from_file, lazy DecodeIter streaming, CRC32 checksums, versioned-value helpers, and a rich set of derive attributes — all while keeping 100% bincode 2.0 binary compatibility. 19,929 passing tests, zero warnings.
100% binary-compatible drop-in replacement for bincode with zero-copy decoding, SIMD-accelerated arrays (2–4× faster), built-in LZ4/Zstd compression (powered by OxiARC), CRC32 checksums, async streaming, schema evolution, and no_std support. 513k LOC of pure Rust, 19,927 passing tests. The sovereign serialization layer for SciRS2 and the entire COOLJAPAN ecosystem.
OxiRS 0.2.2 is a hardening release: a production unwrap() audit confirming zero panic paths outside tests, a workspace-policy migration across all 27 crates, an oversized module split via splitrs, two security advisories reviewed, and dependency refreshes — 40,786 tests passing.
rs3gw is a Pure Rust S3-compatible object-storage gateway. 0.2.0 brings streaming PUT with backpressure and incremental hashing, graceful shutdown with multipart GC, SigV4 rate limiting, gRPC range GET / parallel delete, and the new rs3ctl admin CLI.
Privacy-first 3D human mesh synthesis in pure Rust. Runs entirely client-side (WASM + WebGPU or native). Parametric morphing, FACS expressions, biomechanics physics, 10+ export formats (glTF, VRM, USD, 3MF). 943,000+ LOC, 32,644 passing tests. No server ever sees your body data. The sovereign human modeling layer for SciRS2 and the entire COOLJAPAN ecosystem.
Production-ready pure Rust library for spintronics simulations. LLG/LLB solvers, skyrmions, ISHE/SSE, spin pumping, altermagnets, hopfions and more. 52–100× faster than Python/NumPy, SIMD + memory pool allocator (99% reduction), Python bindings (PyO3), WASM support, HDF5/JSON/VTK export. Validated against Saitoh Group experiments. The sovereign spintronics layer for SciRS2.
OxiArc 0.2.3 brings non-blocking I/O to the compression layer: async ZIP, async DEFLATE, and a new GZip module for Tokio/async-std pipelines, alongside a dedicated GIF LZW codec with LSB bitstream support. Plus across-the-board codec refinements. Pure Rust archive and compression — no C, no zlib, no libarchive.
Pure Rust sovereignty just leveled up again. Privacy-first human bodies, full GDAL replacement, and production Semantic Web + AI reasoning — all dropped today.
OxiArc 0.2.2 ships a complete Zstandard encoder built from scratch — FSE, canonical Huffman, and an LZ77 match finder with 22 levels — so the workspace now writes real .zst, not just reads it. Plus an n-gram Zstd dictionary trainer, LZ4 dictionary frames, and richer ZIP64 with AES-256 and ZipCrypto. Pure Rust archive and compression, no C, no zlib, no libzstd.
Production-grade AC/DC power flow, transient & small-signal stability, battery modelling, renewable integration, optimal power flow, harmonic analysis, and protection systems — all in pure Rust. No C, no Fortran.
OxiMedia 0.1.1 is a pure-Rust FFmpeg + OpenCV replacement. This release adds a drop-in FFmpeg CLI compatibility layer (oximedia-ff), an OpenCV cv2 Python API, a complete MP4 demuxer and end-to-end transcode pipeline, a plugin system, and FFV1/JPEG-XL/DNG/Y4M support — 97 crates and ~1.49M SLoC of pure Rust.
A major milestone for the pure Rust DataFrame library — PandRS 0.2.0 delivers all planned v1.0.0 features. Google Zanzibar-style ReBAC authorization, 6,984 unwrap() calls eliminated, a zero-vulnerability default build, optional SQL backends, new SciRS2 0.3.1 stats/linalg integration, 300+ pages of docs, and 24-month LTS. 3-9x faster than pandas with up to 89% less memory.
no_std-compatible. Zero heap allocation. Full industrial protocols (Modbus, CANopen, EtherCAT). The complete sovereign control systems stack for robotics and industrial automation — all in pure Rust.
Pure Rust reimplementation of Lean 4’s Calculus of Inductive Constructions. 99.7% Mathlib4 compatibility, zero unsafe in kernel, full tactics + metaprogramming — bringing industrial-grade formal verification directly into the Rust ecosystem.
FDTD (2D/3D), Transfer Matrix Method, RCWA, mode solvers, silicon photonics devices, fiber optics, quantum photonics, and type-safe optical units — all in pure Rust. No C, no Fortran.
2.59M SLoC. 29 crates. 19,700+ tests. 10–100x faster than NumPy/SciPy. The complete sovereign scientific computing platform is here — no C, no Fortran, no Python.
Patent-free. Memory-safe. Zero C/FFI. The complete multimedia stack (FFmpeg + OpenCV replacement) is finally here — all written in pure Rust.
OxiRS 0.2.0 lands a ~10x cumulative SPARQL speedup, Tantivy full-text search, 3D GeoSPARQL, 1000+ node clustering, and hardened AI — 26 new modules across 15 rounds, 39,468 tests passing across all 26 crates. A JVM-free Apache Jena.
OxiBLAS 0.2.0 is a major step up: cache-oblivious recursive and parallel factorizations, batched BLAS, runtime auto-tuning, multifrontal sparse solvers, mixed-precision refinement, NUMA-aware allocation, and no_std support — with the Fortran FFI retired in favor of a fully pure Rust workspace.
A minimal DSL + IR that compiles logical rules (predicates, quantifiers, implications) into optimized einsum graphs. Full neurosymbolic integration with differentiable fuzzy/probabilistic semantics — now available as 0.1.0-rc.1.
NumRS2 0.3.0 replaces the O(n²) cyclic spline solve with a Sherman-Morrison O(n) cyclic Thomas algorithm, enables DEFLATE compression for .npz via OxiARC (no zlib, no C), and lifts the entire scirs2-* stack to v0.3.0 — faster KD-trees, SIMD, and special functions.
TenRSo is a production-grade, Rust-native tensor computing stack — generalized contraction plus a cost-based planner, sparse/low-rank mixed execution, CP/Tucker/TT decompositions, and out-of-core processing. This release candidate adds masked einsum, executor element-wise ops, TT-SVD gradients, and CP regularization as we approach our first stable cut.
OxiLean 0.1.0 is the debut of a memory-safe Interactive Theorem Prover written entirely in Rust, inspired by Lean 4 — a zero-dependency kernel implementing the full Calculus of Inductive Constructions, a complete tactic framework, and a WASM REPL that runs in the browser.
SciRS2 is a pure-Rust SciPy/NumPy/scikit-learn replacement, and 0.3.0 is the biggest release yet — transformers, GNNs, diffusion, MoE/RLHF, Gaussian processes, MCMC, survival analysis, radar/compressed sensing, LOBPCG/AMG, plus new Julia and Python bindings. 19,644 tests, ~2.59M lines of Rust. No C, no Fortran.
XSL-FO 1.1 to PDF (and SVG/text) pipeline in pure Rust. 10–1200x faster than Java FOP, zero JVM, full Knuth-Plass line breaking, 294 properties supported. Production-grade document generation is now memory-safe and sovereign.
A complete distributed mail server in pure Rust. Full SMTP/IMAP/JMAP/POP3 support, Mailet-based processing pipeline (Apache JAMES port), AI integration via OxiFY, and AmateRS-backed storage. 10–50 MB memory footprint, no JVM, no GC pauses.
From a single monocular video → consistent 3D Gaussian avatar in pure Rust. Full differentiable Gaussian Splatting (wgpu) + Multi-View Diffusion (Candle) + FLAME binding. 796 passing tests, zero C/Fortran, production-ready digital twin reconstruction.
The first public release of OxiGDAL: a 100% Pure Rust reimplementation of GDAL with zero C/C++/Fortran in default features. 11 format drivers (GeoTIFF/COG, GeoParquet, Zarr, NetCDF, HDF5, GRIB, JPEG2000, ...), a Pure Rust PROJ with 211+ EPSG definitions, SIMD raster/vector algorithms, cloud-native async I/O, and WASM + Python bindings — across 68 workspace crates.
Drop-in PyTorch replacement in pure Rust. Full SciRS2 integration (18 crates), SIMD CPU backend, autograd, and native sharding support. 2—3× faster inference, 50% less memory, single-binary deployment — no Python, no CUDA required.
OptiRS is the Pure Rust ML optimizer suite (19 optimizers) built exclusively on SciRS2-Core. The 0.2.0 release relicenses to Apache-2.0 only and upgrades to SciRS2 v0.2.0 across every crate — fully backward compatible, with no API changes and no breaking changes. A one-line dependency bump.
NumRS2 0.2.0 closes the last native escape hatches: the numpy dependency is replaced by scirs2-numpy, OpenBLAS linker flags are gone in favor of the OxiBLAS pure-Rust backend, and the build is hardened to link cleanly with --all-features. A focused COOLJAPAN compliance release.
SciRS2 is the pure-Rust SciPy/NumPy replacement. 0.2.0 restores the entire workspace to zero compile errors, makes Pure Rust OxiFFT the default FFT backend (rustfft now optional), rebuilds the neural stack, and ships the first WebAssembly bindings. ~11,400 tests, zero warnings. No C. No Fortran.
OxiFFT 0.1.3 is a correctness patch for the Pure Rust FFTW replacement: it eliminates an infinite-recursion bug in the size-512/1024/4096 SIMD fallback dispatch for non-f32/f64 element types, drops a redundant buffer allocation, and consolidates licensing to a single Apache-2.0 LICENSE.
OxiArc 0.2.1 brings security and scale: traditional ZipCrypto encryption for password-protected ZIPs, plus async I/O, SIMD-accelerated CRC, and memory-mapped I/O in the core. Also LZ4 dictionary support and LZHUF streaming. Pure Rust archive and compression — no C, no zlib, no libarchive.
Pure-Rust SciPy/NumPy replacement. 0.1.5 is a polish release — workspace version alignment, strict scirs2-core import policy, correct GPU feature wiring, and a leaner dependency tree. OxiFFT stays the Pure Rust default. No C, no Fortran, no system dependencies.
OxiRAG 0.1.1 lands production OxiZ SMT verification for Layer 3, real Candle Phi-2/Phi-3 inference and LoRA training, and 5.6x–9.0x faster cosine similarity — all in a Pure Rust RAG engine backed by 1,472 tests.
Pure-Rust SciPy/NumPy replacement. This release: SIMD phase 60-69 (8 new AVX2/NEON modules), modular Bowyer-Watson Delaunay (2D/3D/ND + constrained), OxiFFT now the 100% Pure Rust FFT default, and autograd optimizer fixes. 11,400+ tests, 27 crates. No C, no Fortran.
OxiArc 0.2.0 adds full LZW compression for TIFF and GIF — MSB/LSB bitstreams, variable bit widths — bringing the workspace to 10 pure-Rust crates. Now on crates.io, with a default test suite cut 76% faster (137s → 32s) and 427 passing tests. Pure Rust archive and compression with no C, no zlib, no libarchive.
A complete, high-performance Satisfiability Modulo Theories solver written entirely in Rust. Full CDCL(T) architecture, comprehensive theory support, proof generation, and Z3-level performance — with zero C/C++ dependencies and full memory safety.
Pure-Rust legal statute engine. 0.1.4 adds 5 new jurisdictions (Korea, Mexico, Malaysia, Russia, Saudi Arabia) for 23 total, 6 production examples proving one generic engine handles Civil/Common/Supranational law, real-time self-healing verification on the OxiZ SMT solver, and auto-generated TypeScript/Python SDKs. 14,705 tests passing.
OxiFFT 0.1.2 is a packaging patch for the Pure Rust FFTW replacement: it removes a stray examples/**/CLAUDE.md path that broke crate unpacking on Windows, restoring clean cross-platform installs and unblocking PyPI publishing for dependent crates like scirs2-python.
SciRS2 0.1.3 expands Python (PyO3) bindings across autograd, datasets, graph, io, metrics, ndimage, neural, sparse, text, transform and vision; adds PCHIP linear extrapolation; better manylinux wheels and an Adam scalar fix. 100% Pure Rust on OxiBLAS + OxiFFT.
OxiRAG 0.1.0 is the first release of a Pure Rust Retrieval-Augmented Generation engine: a four-layer pipeline (semantic search, draft verification, SMT logic checking, and knowledge-graph retrieval) that compiles to a single static binary or WASM.
A polish patch for QuantRS2, the pure-Rust quantum computing framework — Python-binding bugfixes, refreshed docs, dependency-compatibility bumps, and the removal of legacy C++ SymEngine tooling now that symbolic math is 100% Rust.
Legalis-RS 0.1.3 doubles jurisdiction coverage from 8 to 18 — adding the UAE, Australia, Brazil, Canada, China, India, Indonesia, Laos, Thailand, Vietnam and South Africa — across 41 crates, 863,282 lines and 13,083 passing tests.
OxiRS 0.1.0 is the first stable release of a Rust-native Semantic Web platform: complete SPARQL 1.1/1.2, a Fuseki-compatible HTTP server, GraphQL over RDF, SHACL validation, and industrial IoT bridges — a JVM-free alternative to Apache Jena + Fuseki.
OxiZ 0.1.2 adds PyO3 Python bindings (oxiz-py), a Pure-Rust BLAS + multi-precision (MPFR-style) math layer, an SMT-COMP benchmark suite, and a vastly expanded CLI (dashboard/server/distributed/TPTP/interpolation). A Pure Rust Z3 replacement with zero C/C++.
QuantRS2 is a pure-Rust quantum computing framework — type-safe circuits, state-vector/stabilizer/tensor-network simulators, Grover/QFT/VQE/QAOA, and IBM/Azure/AWS/D-Wave hardware integration. This is the first stable release.
The first patch for QuantRS2, the pure-Rust quantum computing framework. Fixes conditional compilation and feature gating for cloud backends (IBM, Azure, AWS) and photonic modules so the modular workspace builds cleanly with any feature set.
AmateRS is a distributed database with Fully Homomorphic Encryption — run queries and computation directly on encrypted data without ever exposing plaintext to the server. Built in Pure Rust with LSM-tree storage, an FHE compute engine, Raft consensus, and gRPC.
IPFRS — Inter-Planet File RUST System — debuts at 0.1.0: a Pure Rust, content-addressed distributed file system with Sled-backed block storage, DAG-CBOR/IPLD, an HNSW semantic search index, and TensorLogic logic programming. Local-first, ~4,417 lines, 8 crates.
Kaccy 0.1.0 is here — a Bitcoin-native Personal Token Platform for professionals. ~206k lines of safe Rust, 3,296 tests, 7 bonding curves, a 0-1000 reputation system, Lightning, PSBT, and threshold crypto. Proof of Output, not speculation.
Kizzasi 0.1.0 is the first release of an Autoregressive General-Purpose Signal Predictor (AGSP) in Pure Rust — neuro-symbolic prediction for audio, sensors, robotics, and video that fuses State Space Models (Mamba/RWKV/S4) with TensorLogic constraints.
OxiFY 0.1.0 is a Pure Rust, Dify-class LLM workflow orchestration platform: compose AI applications as type-safe directed acyclic graphs. 13 specialized crates, 15+ node types, in-process vector search, CeleRS-backed distribution, 2520+ tests. No Python, no Node.
Legalis-RS 0.1.2 replaces the C++ Z3 backend in its legal verifier with OxiZ, the Pure-Rust SMT solver — rigorous proofs with no native toolchain. Plus a zero-warning build across 25 crates and 11,365 passing tests.
SciRS2 0.1.2 completes the Pure Rust journey — FFT migrates from FFTW to Pure Rust OxiFFT, plus zero-allocation SIMD ops and functional optimizers (SGD/Adam/RMSprop). 100% Pure Rust by default on OxiBLAS + OxiFFT. No C, no Fortran.
OxiFFT 0.1.1 is a maintenance patch for the Pure Rust FFTW replacement: hashbrown and spin bumped to their latest, the MSRV pin dropped to track current Rust, and 48 clippy warnings eliminated for a zero-warning build at 652 passing tests.
The first real release of OxiArc: pure Rust archive and compression with 9 crates, 8 compression algorithms, and 10 container formats — ZIP, TAR, GZIP, LZH, XZ, 7z, CAB, LZ4, Zstd, Bzip2 — all reimplemented from scratch. No C, no zlib, no libarchive. ~19,600 lines, 371 tests, Rust 1.85+ / Edition 2024.
OxiFFT 0.1.0 debuts — a 99% Rust port of FFTW3. Complex/real transforms, DCT/DST, multi-dimensional and batch FFTs, runtime-dispatched SIMD, and 20+ features beyond RustFFT (Sparse FFT, STFT, NUFFT, autodiff, GPU, MPI, WASM). The spectral backbone for the SciRS2 numerical stack.
OxiZ is a Pure Rust Satisfiability Modulo Theories solver reimplementing Z3 — a full CDCL(T) architecture with EUF/LRA/LIA/BV/Arrays/Strings/FP/Datatypes theories, SMT-LIB2 support, and roughly 90% Z3 feature parity, all with zero C/C++. This is its first public release.
OxiZ 0.1.1 ships a new unified `oxiz` meta-crate with feature-flagged modular usage (solver/nlsat/optimization/spacer/proof/full), plus MBQI and CDCL(T) theory-propagation fixes. A Pure Rust Z3 replacement with zero C/C++.
Legalis-RS 0.1.1 adds United Kingdom and Singapore jurisdictions to the Pure Rust legal-DX framework and grows the test suite from 6,100+ to 9,568 across 23 crates, with a near-zero-warning quality pass.
MeCrab is a pure Rust morphological analyzer compatible with MeCab IPADIC dictionaries. The 0.1.0 debut brings memory-mapped zero-copy dictionary loading, a SIMD-accelerated Viterbi lattice, runtime word addition, and the KizaMe CLI — Japanese tokenization in a single safe binary.
Legalis-RS is a Pure Rust framework that turns legal statutes into structured, machine-verifiable code — a Legal DSL parser, formal verifier, population simulator, and multi-jurisdiction support (JP/DE/FR/US). An honest first release.
rs3gw is a Pure Rust, S3-compatible object storage gateway for AI/ML and HPC. The 0.1.0 debut ships a 100+ operation S3 API, multi-protocol REST/gRPC/GraphQL access, content-addressed deduplication, and a pushdown-capable S3 Select query engine — in a single 50MB static binary.
NumRS2 0.1.0 is the first stable release of a NumPy-inspired numerical computing library for Rust: ~155k lines, 1,111+ tests, 86 AVX2 + 42 ARM NEON SIMD functions, pure-Rust linear algebra via OxiBLAS, and zero C/Fortran dependencies.
NumRS2 0.1.1 is a same-day point release that locks in our first stable as the installable baseline: `cargo add numrs2` now resolves to 0.1.1, with the same public API, zero warnings, and 1,111+ passing tests — a drop-in over 0.1.0.
OptiRS is the Pure Rust ML optimization layer for the COOLJAPAN stack — the torch.optim / optax replacement built exclusively on SciRS2-Core. The 0.1.0 first stable release ships 19 optimizers, SIMD acceleration (2-4x), parallel parameter groups (4-8x), 1,134 passing tests, and zero clippy warnings.
OxiBLAS 0.1.2 brings complex-aware LAPACK to ndarray: SVD and QR for complex matrices, Cholesky and eigendecomposition for Hermitian matrices, plus relaxed trait bounds so solve() works with Complex32/Complex64. Pure Rust BLAS/LAPACK, no C or Fortran.
PandRS 0.1.0, the first stable release — a 100% Pure Rust DataFrame library with 70+ pandas-compatible methods, SIMD vectorization, Rayon parallelism, and up to 89% memory reduction. 1334+ tests, 175,000+ lines of Rust. No C, no Cython, no GIL.
SciRS2 0.1.1, a maintenance release one day after the first stable build — documentation refinements, dependency updates, build improvements and minor fixes on the 100% Pure Rust, OxiBLAS-backed SciPy/NumPy stack. No C, no Fortran.
OxiBLAS 0.1.1 fixes a critical sign bug in the symmetric eigenvalue QR algorithm so eigenvectors accumulate correctly for matrices that need multiple QR sweeps. The pure Rust BLAS/LAPACK foundation now powering the just-launched SciRS2 core.
SciRS2 0.1.0, the first stable release — a 100% Pure Rust scientific computing & AI/ML stack with SciPy-compatible APIs, built on OxiBLAS, refactored into clean modules with zero warnings and 10,861 passing tests. No C, no Fortran.
The first public release of OxiBLAS — a pure Rust implementation of BLAS and LAPACK. Full Level 1/2/3 BLAS, LU/Cholesky/QR/SVD/EVD, 9 sparse formats, f16/f128 precision, and DGEMM already matching OpenBLAS on large matrices. No C, no Fortran, no MKL.
The first real release of OxiCode: a compact, fast, no_std-friendly binary serialization library for Rust with 100% bincode 2.0 binary compatibility. Drop-in encode/decode, derive macros, optional SIMD, compression, schema versioning, streaming, and validation. 10,860 lines of pure Rust, 211 passing tests, zero unwrap.
The second release of the pure Rust spintronics library: PyO3 Python bindings, serde + HDF5 export, a memory pool allocator that cuts hot-path allocations by 99%, an HTMX/Axum web demo, runtime unit validation, and 17 worked examples. Simulate LLG dynamics, spin pumping, ISHE/SSE, skyrmions and more — fast, safe, and sovereign.
The first release of Spintronics: a pure Rust library for simulating spin dynamics, spin-current generation, and spin-charge conversion (ISHE, SSE) in magnetic and topological materials. LLG solvers, magnons, skyrmions, FEM micromagnetics, and WASM — an alternative to slow Python/NumPy scripts and fragile C++/Fortran lab codes.