323 posts
OptiRS 0.3.2 is a production-hardening release: fabricated p-values, un-cancelled secure-aggregation masks, and simulated GPU latency are replaced with real implementations or explicit errors. Workspace-wide zero-warning policy, ~90 dead scaffolding types removed, 4,200+ tests passing on Pure Rust ML optimizers built on SciRS2.
OxiGeo 0.2.4 fixes three real user-filed issues — GeoPackage overflow-page cells (#17), GDAL's fractional VRT SrcRect/DstRect values (#18), and VRT mosaic nodata-skip compositing (#19) — plus a new buffered sync-over-fetch driver that makes the browser COG viewer work end to end for the first time, and two large embedded EPSG registry correctness passes.
OxiGIS 0.1.0 is a full desktop and browser GIS application with zero C/C++/Fortran FFI in its default features: wgpu tile rendering (COG, XYZ, MVT, PMTiles), a built-in EPSG registry with complete Japanese coverage, vector editing, and PDF print — one source tree, a native binary and a WASM bundle. Live now at gis.cooljapan.tech. 2,565 tests passing.
OxiProj 0.1.5 is a correctness release for the EPSG authority (proj.db) coordinate path: twelve defects — from a 3.28x-oversized ellipsoid to a 380 m operation-selection miss — found and fixed against the Homebrew PROJ 9.7.0 oracle, every number measured, not derived. 2,855 tests passing, 0 failing.
OxiLLaMa 0.1.4 is the Pure Rust LLM inference engine and sovereign alternative to llama.cpp. This release fixes a remotely-crashable GGUF parser, an unauthenticated /admin/*, and a shipped server that ran with every middleware disabled; adds a GGUF-embedded tokenizer, K-quant encoders, and a GPU offload backend; and verifies logits token-for-token against real llama.cpp — plus a 37.5x Qwen3 decode speedup. 3,751 tests passing.
OxiProj 0.1.4 is a maintenance release: two Python-packaging fixes (missing LICENSE files in the maturin sdist, PyPI trusted publishing), a corrected cs2cs Quick Start example, ecosystem dependency bumps across seven COOLJAPAN crates, and a documentation-accuracy pass that corrects the README's own parity-corpus numbers. No public API changes, no behavior changes, no source changes to any library crate.
OxiONNX 0.1.7 grows oxionnx-cuda from 25 to 40 accelerated ops with real Conv support, session-lifetime weight/buffer residency, and batched MatMul up to 17x faster — plus a fix for a two-stream race that silently returned wrong GEMM results on real hardware. 3,595 tests passing. The sovereign Pure Rust ONNX layer for COOLJAPAN.
ToRSh 0.2.0 completes autograd backward coverage, consolidates GPU compute onto the pure-Rust oxicuda stack, ships full NumPy/pandas/SciPy interop and PyTorch-compatible LR schedulers, and replaces fabricated success paths with honest errors. 10,638 tests passing. The sovereign deep-learning layer for COOLJAPAN.
Kizzasi 0.2.3 removes the last C dependency (Oniguruma) from published crates via a candle fork — fixed for downstream users, not just this workspace. Ships pure-Rust video (OxiMedia Y4M decode + camera capture), pure mqtt-tls, and a new kizzasi-metal crate for safe cross-platform Metal acceleration.
OxiCUDA 0.5.5 audits oxicuda-metal and oxicuda-webgpu on real Apple Silicon, fixing conv2d/attention/softmax false completions where finished MSL kernels sat unused behind CPU scalar loops. Separately, a downstream investigation wires up an unreachable split-K GEMM path, replaces a silent Winograd no-op with a real kernel, and fixes wrong Ampere GA10x hardware constants — measured on a real RTX A4000. 38,987 tests, ~1.31M SLoC, 74 crates.
OxiMedia 0.2.1 fixes a ±35 dB K-weighting bug in its EBU R128 loudness stack, ships a new Pure-Rust oximedia-capture crate for AVFoundation/V4L2/Media Foundation camera input, and brings VP8/VP9 to bit-exact inter-frame decode against libvpx — plus a full RFC 9639 FLAC rebuild. The sovereign media layer for the COOLJAPAN ecosystem.
OxiCUDA 0.5.4 adds WarpVec/WarpMask, a SIMD-flavored warp-vector layer for oxicuda-ptx's builder DSL, six new IR instructions for warp shuffle/vote, and a foreign-compiler PTX interop test proving the driver/launch stack hosts upstream rustc-generated PTX too. 38,689 tests, ~1.30M SLoC, 74 crates.
OxiText 0.2.3 fixes a font-fallback bug where a single `.notdef` hit could re-point every already-shaped glyph in a run to the wrong font's glyph table — invisible whenever two fonts share glyph-id numbering. Adds a script-tag introspection API. 851 tests passing. The sovereign Pure Rust text layer for COOLJAPAN.
OxiONNX 0.1.6 ships GPU weight/activation residency and a direct implicit-GEMM Conv2D kernel (~692 GFLOP/s on M3) — plus the fix making wasm32 CPU inference actually run, and a CoreML compile cache ending 857 GB of orphaned recompiles. 3,212 tests passing. The sovereign Pure Rust ONNX layer for COOLJAPAN.
Kizzasi 0.2.2 ships a WebGPU acceleration backend, real tensorlogic-ir constraint compilation, PEAQ perceptual audio quality evaluation, and multi-speaker tokenization — alongside a wide correctness sweep that fixes training, SSM recurrences, and weight serialization that were silently broken since 0.2.1. 2,744 tests passing, 100% Pure Rust.
OxiXML 0.1.2 closes every documented API-parity divergence from oxrdf/oxttl/oxrdfxml/oxjsonld: borrowed-ref iteration, impl Into<String> builders, Send JSON-LD parsers, and a JsonLdSerializer that finally emits its @context/@graph envelope. Deliberately breaking vs 0.1.1, Pure Rust, 0 external crates by default.
OxiHTTP 0.2.1 is a security-hardening release for the COOLJAPAN Pure-Rust HTTP stack: it closes a redirect credential leak, two WebSocket unbounded-memory DoS paths, a chunked-encoding body-limit bypass, a spoofable rate-limiter key, a client decompression bomb, and more — 320 tests passing (446 with all features), the sovereign HTTP layer for the COOLJAPAN ecosystem.
OxiONNX 0.1.5 adds async execution, cancellation, streaming generation, and session serialization — backed by a 12-lens, 232-finding hardening pass across parsing, spec-conformance, and GPU/CUDA/DirectML dispatch. 23 new operators, 2,946 tests passing. The sovereign Pure Rust ONNX layer for COOLJAPAN.
OxiRPC 0.2.1 adds a 100% Pure-Rust HTTP/3 (gRPC-over-QUIC) transport behind the opt-in http3 feature, closes a bug where a missing grpc-status trailer could look like a successful empty stream, adds a frame-size overflow guard, and validates gRPC Content-Type on every native transport path — 702 tests passing (801 with all features), the sovereign gRPC layer for the COOLJAPAN ecosystem.
OxiSQL 0.4.1 ships oxisql-cache — a first-publish crate that inverts a former oxisql⇄oxistore dependency cycle — plus CREATE TRIGGER/row-trigger execution, TEMP objects and ATTACH/DETACH DATABASE multi-database support, PRAGMA index_list/index_info, fuzz targets, and quickstart examples for every driver. Six process-abort and undefined-behavior fixes land in the C-free oxisqlite engine. Part of the NoFFI sovereign Rust stack.
OxiStore 0.3.0 is a minor release that structurally severs the oxistore ⇄ oxisql circular dependency, adds EnvelopeTxn/EnvelopeSnapshot for encrypted stores, ships a PKCS#11 HSM-backed KeyProvider, and fixes S3/Azure key percent-encoding bugs. Part of the NoFFI sovereign Rust stack — zero *-sys crates on default features.
OxiArc 0.4.1 is a security-hardening release: ZIP AES/ZipCrypto salts and headers now always come from a real OS CSPRNG (no more silent low-entropy fallback), WinZip-AES is now constant-time, a silently-wrong x86_64 CRC-32 SIMD path is fixed and enabled, and 7z folder coder chains are bounded against decompression-bomb amplification. Plus Zstandard FSE_Compressed_Mode sequence tables and Brotli literal/command/distance block splitting close two long-standing encoder-ratio gaps. 2,658 tests passing, Pure Rust.
OxiAudio 0.2.1 is a deep Opus conformance-hardening release: the CELT frame-size ceiling is raised from 80 bytes (~32 kbps) to the RFC's real 1275-byte limit (510 kbps mono) by fixing a celt_bits2pulses/celt_pulses2bits partition-scale clamp bug, CBR frames stop silently shrinking, hybrid packets are now entropy-exact, and encode_opus is RFC 6716-conformant by default. Pure Rust audio codec + DSP layer for the COOLJAPAN ecosystem.
OxiBLAS 0.2.2 is a production-readiness hardening release: a 16-domain multi-agent audit plus adversarial re-verification closes numerical correctness bugs across BLAS/LAPACK/sparse, hardens PackedRef/BandedRef construction to unsafe fn, fixes an integer-overflow bug in the Matrix Market parser, turns 57 of 64 previously-`ignore`d doctests into real executed tests, and adds a libFuzzer harness for both untrusted-input parsers. No breaking API changes outside two now-`unsafe` constructors. Pure Rust BLAS/LAPACK for SciRS2.
OxiCode 0.2.6 hardens the serde bridge, closing an infinite-decode-loop bug and unbounded allocations 0.2.5 missed. A wire-format-relevant fix restores byte compatibility with bincode::serde (migration note included). Adds bounded-length decode entry points and decode contexts in the derive macros. 20,198 tests passing.
OxiCrypto 0.3.0 completes the FIPS 205 SLH-DSA parameter-set matrix (all 12 of 12), ships a new negotiate_aead TLS 1.3 cipher-suite resolver alongside negotiate_mac/negotiate_sig/negotiate_kex, adds coverage-guided fuzzing across AEAD/MAC/PQ/KDF, gives every sub-crate a runnable example, and fixes a byte/char-boundary panic-DoS in bcrypt verification — the sovereign Pure Rust cryptography layer for the COOLJAPAN ecosystem.
OxiFFT 0.4.2 fixes a wrong-answer bug (not a precision bug) in the x86_64 SSE3 SIMD butterfly kernel that every non-AVX2 x86_64 CPU takes — a wrong complex-multiply lane order and twiddle-recurrence drift together failed 93 of 1447 tests by 10-100x the tolerance. Found by running the suite on x86_64 for the first time. Plus a Miri-driven pointer-provenance fix, four new soundness hardenings against attacker-influenceable wisdom strings, and a fuzz-harness tolerance bug of its own. Pure Rust FFT, no FFTW.
OxiFont 0.2.2 ships oxifont-subset::instance() for pinning a variable font to one design location, a drop_variations subset option, TrueType Collection (.ttc) face-index support that unlocks stock Windows CJK fonts like msgothic.ttc, a public SubsetGidMap for PDF CIDFont embedding, and full GSUB/GPOS contextual-lookup remapping — the sovereign Pure Rust font layer for the COOLJAPAN ecosystem.
OxiH5 0.2.3 closes six writer roadmap gaps — compound records, vlen sequences, array/opaque/bitfield types, big-endian/half-precision floats, soft/external/hard links — makes extensible-array chunk indexes readable, fixes five crash/OOM classes. 987 tests passing — COOLJAPAN's sovereign scientific-data layer.
OxiNum 0.1.4 closes an unbounded-allocation class across add/sub, remainder, and binary-splitting transcendentals — a legitimately valid but extreme BigFloat exponent could previously drive memory proportional to the exponent gap, aborting the process. New MAX_EXACT_CONVERSION_BITS-guarded try_* fallible APIs, an enforced BigFloat exponent range (EMAX/EMIN, ilogb), a fixed IEEE-754 subnormal-rounding double-rounding bug, and a Rem correctness fix. Pure Rust, no GMP, no MPFR, no FFI.
OxiProto 0.1.5 ships Editions 2023 support end to end: full feature resolution (field_presence, enum_type, repeated_field_encoding, utf8_validation, message_encoding, json_format), enforcement at decode time, and a downlevel-to-proto2 rewrite so the prost-reflect facade — which panics trying to even format the 'unknown syntax editions' error — can handle Editions files at all. Plus a wrong-buffer bug in generated packed-repeated decode, a proto2 packing default that diverged from protoc, and two new nesting-depth DoS bounds. Pure Rust Protocol Buffers, no protoc required.
OxiQUIC 0.2.1 closes five RFC 9000 security gaps — spoofed-source reflection amplification, unbounded per-stream and CRYPTO-buffer memory growth, and a forgeable Retry handshake — adds bidirectional ECN (RFC 9000 §13.4 / RFC 9002 §7.4) and true per-path congestion control for multipath, and ships runnable QUIC/HTTP-3 examples. 445 tests passing, the sovereign Pure Rust QUIC layer for the COOLJAPAN ecosystem.
OxiSound 0.2.1 ships oxisound-pulse — a brand-new, 100% Pure Rust PulseAudio/PipeWire native-protocol backend with zero C in its Linux audio path — plus three denial-of-service fixes in oxisound-osc's untrusted-UDP decode path (an out-of-bounds read, unbounded nesting, and a 32-bit integer wraparound), a new fuzz workspace, and a stream_stats() correctness fix. The sovereign audio device I/O layer for the COOLJAPAN ecosystem.
OxiText 0.2.2 vendors its own fork of swash to fix a Devanagari reph-duplication bug and an out-of-bounds panic that has sat open and unfixed upstream since April 2025, adds a Pure-Rust PNG decoder to fully remove the `png`/`flate2` dependency chain, and fixes color-glyph misdetection for sbix/CBDT/SVG fonts — 845 tests passing, the sovereign text layer for the COOLJAPAN ecosystem.
OxiTLS 0.3.0 fixes an OCSP staple false-rejection on leaf-only certificate chains, converts an HPKE LabeledExpand panic into a propagated Result, and adds three new fuzz targets covering its own hand-rolled TLS parsers — 364 tests passing, the sovereign Pure Rust TLS layer for the COOLJAPAN ecosystem.
OxiUI 0.2.2 wires the facade's multi-window registry and menu bar into a real rendering path for the first time (egui opens real OS viewports, iced/headless render the bar too), makes oxiui-slint and oxiui-dioxus return an honest error instead of a fabricated Ok(()), fixes GPU device-loss/OOM panics in oxiui-compute-wgpu, and restores wasm32 compilation for oxiui-web. 2,024 tests passing, the sovereign Pure Rust GUI layer for the COOLJAPAN ecosystem.
OxiXML 0.1.1 is a hardening release: a new typed SVG 1.1/2.0 document model, arbitrary-precision xs:integer/xs:decimal by default, and the query/transform tier locked to its W3C suites — XPath and XQuery 100%, XSLT 98.9%, XSD 1.0/1.1 99.9%. Deliberately breaking, no compatibility shims: 0.1.0 is superseded. Pure Rust, 0 external crates in default features.
OxiGeo 0.2.3 fixes GitHub issue #15 — every gdalwarp -of VRT product was rejected at parse time — with a real backward warp engine in oxigeo-vrt, and issue #16 — Dataset::open on a GeoPackage always reported 0 layers — with a new Dataset::layers()/Layer::features() vector API for GeoPackage, Shapefile, and GeoJSON.
OxiProj 0.1.3 is a maintenance release: no public API changes, no behavior changes. It pulls forward real hardening from five upstream COOLJAPAN crates — a 44-agent HDF5 interop audit, a CUDA async-copy race-condition fix, faster zero-copy DEFLATE decoding, and OxiZ's soundness sweep — plus a `wide` 1.6 deprecation cleanup in the SIMD scalar power path. Still 100% Pure Rust, no C, no FFI.
OxiZ 0.3.2 is a soundness release driven by an external differential-testing report: 8 pull requests, 0 merged, every fix independently reimplemented from scratch and backed by a regression test. EUF congruence, Bool/EUF encoding, Arithmetic⇄EUF combination, and NLSAT conflict analysis are all corrected — 168/168 Correct on the Z3 parity suite, 9,953 tests passing. Pure Rust, Apache-2.0.
OxiZ 0.3.1 is a soundness-and-honesty release: five reported GitHub issues plus 40+ bugs of the same silently-wrong-answer shape are fixed, wide (>64-bit) bit-vectors are now exact via BigUint, and MBQI completeness brings the Z3 differential parity suite to 168/168 Correct, 0 Wrong. 9,668 tests passing. Pure Rust, Apache-2.0.
SciRS2 0.6.5 is a defect-hunting release: a workspace-wide audit of every #[ignore]d test found that scirs2-autograd's live backward pass silently identity-passed 223 of 281 differentiable ops instead of computing real gradients, plus real fixes across linalg, stats, graph, io, spatial, ndimage, and special. Pure Rust, Apache-2.0.
OxiArc 0.4.0 rewrites the DEFLATE/zlib decode path for throughput: a two-level Huffman table, a register-resident BitCache, and an output-buffer-as-history design that stops writing every decoded byte twice. New zero-copy inflate_into/zlib_decompress_into APIs, no wire-format change. 2,468 tests passing, Pure Rust.
OxiCode 0.2.5 is a hardening release: fixes decode-time allocation-DoS, decompression-bomb, and checksum-overflow issues across containers, streaming, and derive macros, and replaces a fabricated SIMD speedup claim with real AVX2/SSE2/NEON kernels. No wire-format change for valid input. 20,126 tests passing.
OxiFont 0.2.1 ships oxifont-hinting, a from-scratch Pure Rust TrueType bytecode hinting interpreter (grid-fitting VM) that never panics on hostile input, plus a WOFF2 spec-compliance fix and a closed large-allocation DoS in bundled CJK font resolution. The sovereign font layer for the COOLJAPAN ecosystem.
OxiGeo 0.2.2 fixes GitHub issue #14 — Dataset::read_band silently returned the whole multi-band image instead of one band, a defect pattern found and fixed in a dozen crates. Also ships 1.45-1.79x faster DEFLATE decoding and zero-allocation typed raster readers.
OxiText 0.2.1 fixes COLRv0/COLRv1 color-glyph rendering — previously 0% pixel coverage on every color emoji — into a complete paint-graph interpreter with gradients, transforms, clips, and all 28 composite modes, swaps in a Pure-Rust PNG encoder to clear the last banned dependency, and cuts font-cache overhead by up to 13,000x. The sovereign text layer for the COOLJAPAN ecosystem.
OxiUI 0.2.1 wires on_close/on_resize/on_focus into the real egui and iced event loops for the first time, makes with_persistent_state actually write to disk via oxicode, and closes an integer-overflow bounds bypass plus an unbounded-iteration DoS in the CPU rasterizer. The sovereign GUI layer for the COOLJAPAN ecosystem.
OxiXML 0.1.0 is the first release of the COOLJAPAN Pure-Rust foundation for all XML and RDF processing — 44 crates spanning a quick-xml-compatible parser, DOM/SAX/HTML5 trees, XSD 1.1/RELAX NG/Schematron validation, XPath/XQuery/XSLT, XMLDSig/XMLEnc, and the full RDF 1.2/Turtle/JSON-LD/RDFa/SPARQL stack. 137,656 of 138,249 W3C conformance cases passing (99.6%), 0 external crates in default features.
OxiRS 0.4.1 closes a full oxirs-fuseki authentication bypass, makes Raft storage genuinely fsync-durable, fixes a SPARQL parser that silently dropped FILTER clauses, and removes fabricated results from SHACL/AutoML/federation — 308 findings audited, ~300 fixed, 46,255 tests passing across 27 crates.
OxiGeo 0.2.1 is a production-hardening release: a multi-agent defect sweep found 342 bugs and fixed 314, including two CRITICAL silent-corruption decoders (JPEG2000, GRIB2) and a WFS-T fail-open security hole. A new axum gateway serving layer ships, and retiring oxigeo-kafka makes the workspace fully C-toolchain-free.
SciRS2 0.6.4 is a fast follow-up to 0.6.3: oxifft 0.4.1 added a hard compile_error! for its threading (rayon) feature on wasm32 targets, which scirs2-fft and scirs2-signal didn't gate for that target -- silently blocking scirs2-wasm and the scirs2 meta-crate from publishing. Both catch up now, with target-gated dependencies fixing wasm32 builds for good. Pure Rust, Apache-2.0.
OxiCUDA 0.5.2 fixes a class of PTX portability bugs that CUDA 11.x silently tolerated and CUDA 12.9+ toolchains reject outright (non-ASCII bytes in generated comments), closes several Windows-specific test and lock-contention bugs, and fixes a numerical-correctness bug in the tensor-network DMRG excited-states solver. 38,675 tests, ~1.30M SLoC, 74 crates.
OxiCUDA 0.5.3 fixes an async-copy race condition where cuMemcpyDtoHAsync/cuMemcpyHtoDAsync and DeviceBuffer::copy_from_host could return before the transfer had actually landed, letting the very next read observe stale or zeroed device/host memory. 38,675 tests, ~1.30M SLoC, 74 crates.
Pure Rust FFT and the rustfft replacement. OxiFFT 0.4.0 adds distributed real (r2c/c2r) MPI transforms, wires wisdom-based auto-tuning into MEASURE/PATIENT/EXHAUSTIVE planning so it really compares candidate algorithms, corrects the MSRV to 1.87, and ships a breaking cleanup of dead planner code plus a v2 wisdom binary format.
OxiFFT 0.4.1 is a small, focused release: it pulls in OxiCUDA 0.5.3, which fixes a race condition where async CUDA memory copies in oxicuda-fft could return before the transfer landed — risking silently corrupted or all-zero GPU transform results under load.
OxiProto 0.1.4 ships oxiproto-protoc — a protoc-argv-compatible binary letting any prost-build/tonic-build project skip the C++ compiler entirely by pointing PROTOC at pure Rust. This release also closes an unbounded-recursion decode DoS across all three nested-message paths and removes OxiProto's own last internal protoc dependency. Pure Rust, Apache-2.0.
SciRS2 0.6.3 fixes seven Windows-only crash-and-corruption bugs invisible on Linux CI: an alloc/dealloc alignment mismatch that corrupted the heap, a recursive Drop impl that overflowed the 1MB default stack, a ~5.5GB eager-allocation process abort, and a path validator that rejected every C:\ path — plus two numerical-correctness fixes in ESPRIT and N4SID system identification. Pure Rust, Apache-2.0.
OxiBonsai 0.2.3 ships a two-pass, 109-agent production-hardening audit: a P0 fix for a silent CUDA prefill/decode KV-cache desync, full Metal GPU coverage for Q4_0/Q8_0/K-quant and FP8 batch prefill, real OpenAI-compatible penalties and logprobs, and tokenizer fidelity fixes for CJK/emoji text — 91 confirmed findings closed, 5,158 tests passing. Sub-2-bit Pure Rust sovereign AI inference for the COOLJAPAN ecosystem.
OxiCUDA 0.5.1 adds oxicuda-nvrtc, a pure-Rust runtime loader for NVIDIA's NVRTC CUDA-C-to-PTX JIT compiler, completing the zero-SDK-dependency story alongside oxicuda-driver. Graceful degradation, process-wide caching, and direct PTX handoff to oxicuda-driver. 38,646 tests, ~1.30M SLoC, 74 crates.
OxiH5 0.2.2 ships a 44-agent interop audit against h5py 3.16 and netCDF4-python 1.7.4, fixing 33 conformance defects and closing 9 writer gaps — shuffle/Fletcher32 pipelines, custom fill values, true netCDF coordinate variables. 862 tests passing — the sovereign scientific-data layer for COOLJAPAN.
OxiZ 0.3.0 is a hardening-and-capability wave: a new ground string decision procedure and concrete floating-point model finder lift qf_s and qf_fp from partial to 10/10 on the Z3 parity suite, MBQI SAT certification advances three quantified logics, and a dozen soundness bugs are fixed — 8,119 tests passing, 0 Wrong verdicts across 154 decisive Z3 comparisons. Pure Rust, Apache-2.0.
SciRS2 0.6.2 replaces the C-linked hdf5 crate with pure-Rust oxih5, fixing a critical silent-data-loss bug in compressed HDF5 writes and a self-concealing dataspace-parsing bug along the way. libnuma, tracy-client, and opencl3 are gone from the dependency graph, plus a breaking TLS-provider hardening. Pure Rust, Apache-2.0.
OxiH5 0.2.1 adds DEFLATE compression on write, per-chunk tiling, in-place dataset overwrite, and nested groups — and fixes 9 correctness bugs, including a chunk B-tree defect that made every chunked dataset the writer produced unreadable by libhdf5. 682 tests passing — the sovereign scientific-data layer for COOLJAPAN.
OxiGDAL 0.1.7 is a production-hardening release: 233 verified defects fixed across 69 crates — a GeoTIFF corruption bug, JPEG2000 spec conformance, real FlatGeobuf/HDF5 codecs, an RBAC bypass — plus a blake3/Ed25519 attestation module and three new WASM demos. 76 crates, 16,909 tests. The sovereign geospatial layer for COOLJAPAN.
OxiGDAL is now OxiGeo. Version 0.2.0 is a rename-only release — functionally identical to v0.1.7 — that republishes all 74 crates, the CLI, and the Python/npm/WASM/mobile bindings under the oxigeo name. Old GitHub URLs redirect; v0.1.7 remains the final OxiGDAL release. The sovereign geospatial layer for the COOLJAPAN ecosystem, now under its permanent name.
OxiProj 0.1.2 is a hardening/correctness release for the Pure-Rust PROJ replacement: automatic epoch-aware datum pathfinding, exact-autodiff Tissot distortion reachable from the public engine API, guaranteed-bounds interval-arithmetic transforms, SIMD batch lane-correctness fixes, and an SQL-injection fix — still no C, no FFI.
OxiRS 0.4.0 ships oxirs-tdb as a genuinely durable on-disk backend (WAL, superblock, sorted bulk build), unifies SELECT/ASK/CONSTRUCT/DESCRIBE through a single real oxirs-arq dispatch, migrates every route to axum 0.8, and hardens DID crypto, SSO, and cluster BFT — 45,199 tests, zero warnings across 27 crates.
OxiZ is a high-performance SMT solver in pure Rust — a Z3 replacement. 0.2.4 lands the results of a 19-agent production-readiness audit and five fix waves — real Sturm sequences, sound SAT conflict analysis, honest Cooper QE, corrected BV division — plus new oxiz-py string, floating-point, and quantifier bindings, with 7,666 tests passing workspace-wide.
OxiCrypto 0.2.1 measures ML-DSA-87's worker-thread stack down to 2 MiB from a hardcoded 8 MiB, ships a default-on alloc feature for genuine no_std core-only builds, adds a PQ-to-AEAD hybrid encryption test, and fixes a truncated-HMAC panic — the sovereign Pure Rust cryptography layer for the COOLJAPAN ecosystem.
OxiH5 0.2.0 adds superblock v1 parsing, v2/v3 superblock-extension decoding (B-tree K values, shared message table, file space info, driver info), and fixes a silent OCHK object-header creation-order misdecode. 494 tests passing across four crates — the sovereign scientific-data layer for the COOLJAPAN ecosystem.
OxiSQL — the COOLJAPAN ecosystem's sovereign Pure-Rust SQL layer and C-free SQLite-compatible engine — ships 0.4.0: every inter-crate dependency floor across all 17 crates is pinned to the exact full-triple 0.4.0, a clean 0.4.x baseline no stale Cargo.lock can break. A packaging bump, no source changes since 0.3.3.
OxiH5 0.1.4, the COOLJAPAN Pure-Rust HDF5 reader, adds Virtual Dataset (VDS) resolution, chunked variable-length dataset reads, szip RAW-mode chunk decoding, and soft-link-to-external-link chains, plus a fix for a silently mis-decoded global-heap reference. 486 tests passing across four crates — the sovereign scientific-data layer for the COOLJAPAN ecosystem.
OxiLean 0.1.3 ships oxilean-verify, an independent Lean 4 proof checker with three-bucket verdicts, a 144 KB gzip WASM 'Kernel in a Tab,' a kernel soundness overhaul, and a structural-sharing rewrite cutting full-Init verification from 1h20m to 11m28s — the sovereign theorem-proving layer for the COOLJAPAN ecosystem.
OxiSQL 0.3.3 makes SQLite views first-class, lets compound SELECTs act as FROM-clause subqueries, adds open_from_bytes for WASI/browser use and PostgreSQL logical replication, and fixes a silent b-tree index-corruption bug — the sovereign Pure Rust SQL layer for the COOLJAPAN ecosystem.
OxiTLS 0.2.1 eliminates RUSTSEC-2026-0104 by forking its Pure-Rust CryptoProvider into a webpki-free oxitls-rustcrypto-provider crate, closes an OCSP staple replay bypass, and fixes SCT parsing — 443 tests passing, the sovereign Pure Rust TLS layer for the COOLJAPAN ecosystem.
OxiMedia 0.2.0 ships a real frame-level transcode engine, AV1/VP9/VP8 key-frame decoders verified bit-exact against dav1d, aomdec, and libvpx/libwebp, real CENC/cbcs packager encryption, and a sweep replacing fabricated success with honest errors — the sovereign media layer for the COOLJAPAN ecosystem.
SciRS2 0.6.1 replaces placeholder and silently-wrong code paths with real implementations: genuine model-serving codegen, a critical DLPack SIGBUS fix, honest GPU-dispatch and hardware-detection reporting, and a symbolic-engine soundness fix — plus F-distribution ppf, spatial hamming distance, and new finance facades. Pure Rust, Apache-2.0.
OxiCUDA 0.5.0, the sovereign GPU-compute layer for the COOLJAPAN ecosystem, fixes F64-precision PTX codegen bugs that made ptxas reject elementwise and reduction kernels, closes a mixed-precision GEMM accumulator bug, and hits zero unwrap()/expect() in library code. 38,622 tests, ~1.30M SLoC, 73 crates.
OxiMedia 0.1.9 ships a 100% Pure Rust default build (zero C/C++/Fortran), fixes four real security vulnerabilities (SRT crypto, MP4 DoS, WebRTC DTLS honesty, SQL injection), and launches oximedia-web — four WASM modules downstream of WebCodecs, live in OxiScope and OxiLink. 114 crates, ~2.95M SLOC.
sklears 0.2.0 ships sklears-core::gpu, a real oxicuda-backed CUDA foundation (GpuBackend, GpuArray, GpuMatrixOps) powering on-device GEMM, Cholesky/LU/QR/SVD solves, and HNSW k-NN across 9 downstream crates, plus a wide correctness sweep. 12,721 tests passing, 36 crates, >99% scikit-learn API coverage held.
SplitRS 0.3.5 fixes eight correctness issues found splitting a real sqlite3-parser crate: file-backed mod declarations, --split-impl-blocks cross-chunk calls, bitflags type exports, and grouped-import collisions, resolving E0583, E0624, E0425, and E0252. 608 tests passing, up from 570 in 0.3.4.
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.
OxiArc 0.3.6 pairs a security-hardening pass with a 22-auditor, 75-item reference-interop campaign: zstd's FSE fix takes real-frame decode from 0/64 to 64/64, brotli's RFC 7932 rewrite goes 141/172 failures to 608/608, plus LZMA2, bzip2, and SZIP fixes. 2,426 tests passing, Pure Rust.
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.