134 posts
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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 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.
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).
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.
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.
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.
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).
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).
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.
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.
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.
Pure Rust sovereignty just leveled up again. Privacy-first human bodies, full GDAL replacement, and production Semantic Web + AI reasoning — all dropped today.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.