◉ COOLJAPAN
← All posts
June 19, 2026 • 8 min read

OxiHuman 0.2.0 Released — Real Multibody Dynamics, GLB Skinning Export, and Procedural Sky for the Client-Side Human Generator

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.

release oxihuman 3d-human parametric-modeling wasm webgpu biomechanics rigid-body-dynamics gltf pure-rust

OxiHuman’s physics and export layers just stopped faking it — eight placeholder kernels are now real, from multibody dynamics to skinned glTF.

Today we released OxiHuman 0.2.0 — the privacy-first, pure Rust parametric human body generator that runs entirely client-side, with a wave of genuine algorithm implementations replacing the last of its scaffolding stubs.

No cloud. No Python. No server ever receives your body parameters. No data leakage. No network calls by default. Just clean, memory-safe, deterministic 3D human mesh synthesis that runs in the browser via WASM + WebGPU or natively anywhere — now backed by real rigid-body dynamics, real skinned export, and a real procedural environment.

Why OxiHuman 0.2.0 is a game changer

For a generator that prides itself on determinism and correctness, “returns 0 for now” is not good enough. 0.2.0 is the release where eight of those compromises get retired and replaced with textbook-correct, test-verified math. This is the minor-version bump that turns several “it compiles” paths into “it’s actually right.”

The headline wins, all grounded in real algorithms and analytic test checks:

All of this lands with 33,410 passing tests (up from 33,364), 0 clippy warnings across the workspace, and 0 unwrap in production code.

Technical Deep Dive: real math in the physics and export layers

OxiHuman’s layered workspace is unchanged in shape, but several layers got substantially more honest in 0.2.0:

  1. Physics & Biomechanics (oxihuman-physics) The big story. rigid_body_tree.rs now does true articulated-body forward dynamics (CRBA for H(q), RNEA for the bias term, a linear solve for q̈). fracture.rs computes exact cell volumes by the divergence theorem. To support this, ArtBody gains com_offset: [f32; 3] and link_length: f32 so links carry real geometry into the dynamics.

  2. Mesh Pipeline (oxihuman-mesh) Discrete differential operators got real: edge_flow_field_curl_magnitude now implements Stokes’ theorem (its ring argument changed to &[(usize, [f32; 3])] so each ring vertex maps to its flow vector), and ambient occlusion smoothing became a genuine Laplacian diffusion. AoMesh gains an indices: Vec<u32> field to carry triangle topology for the 1-ring operator.

  3. Export Pipeline (oxihuman-export) glb.rs now produces fully skinned glTF binaries with JOINTS_0/WEIGHTS_0 and inverse-bind matrices, and CrcTable::combine is bit-exact. expression_io.rs parses real expression weights.

  4. Viewer (oxihuman-viewer) background_renderer.rs renders a procedural cubemap sky with a real elevation gradient, horizon haze, and a sun highlight — BackgroundType::CubemapStub is renamed BackgroundType::Cubemap.

0.2.0 also removes thirteen dead-code scaffolding modules that were never part of the public API — unreachable files carrying #![allow(dead_code)] across core, mesh, physics, and viewer — trimming the codebase of code that compiled but did nothing.

Getting Started

cargo add oxihuman

Generate a mesh from a few slider parameters and export it to a binary glTF:

use oxihuman_morph::engine::MorphEngine;
use oxihuman_export::gltf::GltfExporter;

fn main() -> anyhow::Result<()> {
    let mut engine = MorphEngine::default();
    engine.set_param("height", 0.6);
    engine.set_param("weight", 0.4);
    engine.set_param("age", 0.35);
    let mesh = engine.build_mesh();

    let exporter = GltfExporter::new();
    let glb_bytes = exporter.export_glb(&mesh)?;
    std::fs::write("human.glb", glb_bytes)?;
    Ok(())
}

In the browser, the same engine runs entirely client-side via WebAssembly:

import init, { WasmEngine } from "./oxihuman_wasm.js";

await init();
const engine = new WasmEngine();
engine.set_param("height", 0.6);
engine.set_param("weight", 0.4);
const mesh_bytes = engine.export_mesh_bytes();

What’s New in 0.2.0

Tips

This is the foundation

OxiHuman is the privacy-first, client-side human modeling layer for the COOLJAPAN ecosystem. As of this release it sits among a broad set of Pure Rust siblings — SciRS2 and NumRS2 for scientific and numerical computing, ToRSh and TenfloweRS for deep learning, OxiMedia for media and video pipelines, OxiPhysics for general physics, OxiBLAS and Oxicode for the low-level building blocks, and OxiGAF for Gaussian-avatar reconstruction. Everything stays C-, C++-, and Fortran-free, compiling to a single static binary or to WASM, with no body data ever leaving the machine.

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

Star the repo if you want a human generator whose physics and export paths are real, verified, and sovereign.

Pure Rust client-side human modeling is here — fast, private, and sovereign.

— KitaSan at COOLJAPAN OÜ June 19, 2026

↑ Back to all posts