OxiHuman 0.1.2 Released — Portable, Path-Free Test Fixtures for the Client-Side Human Generator

The privacy-first, client-side human body generator just got easier to build and test anywhere — with zero hard-coded paths.

Today we released OxiHuman 0.1.2 — a focused maintenance release that makes the entire test suite portable across machines, CI runners, and contributor laptops.

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 — and now builds and tests cleanly on any machine, with no developer-specific paths baked into the repo.

Why 0.1.2 matters

OxiHuman ships a large, serious test suite: 32,791 passing tests across eight workspace crates and roughly 943,000 lines of pure Rust. Some of those tests exercise the real MakeHuman base mesh and the OxiHuman asset packs — and until now, a handful of fixtures reached for dataset roots via absolute paths. That is exactly the kind of thing that works on one machine and quietly breaks on every other.

0.1.2 fixes that the right way:

• No hard-coded absolute paths. Test fixtures that depend on the MakeHuman dataset now resolve the data root from the MAKEHUMAN_DATA_DIR environment variable — point it at the MakeHuman data/ directory (the one containing 3dobjs/base.obj and targets/).
• Asset packs resolve via a variable too. Asset-pack tests read their root from OXIHUMAN_ASSETS_DIR (the directory containing alpha_pack/oxihuman_assets.toml).
• Graceful skips, not failures. When either variable is unset, the dependent tests skip cleanly. The standard cargo nextest run --all-features still passes on a fresh checkout — no dataset required.
• CI- and contributor-friendly. Drop the data wherever you like, export two variables, and the full fixture-backed suite runs. Nothing in the repo assumes a particular user’s home directory.

It’s a small release by line count, but it removes real friction: reproducible builds shouldn’t depend on where you happened to clone the project.

Technical Deep Dive: where the fixtures live

OxiHuman is a clean, layered workspace. The 0.1.2 change touches how tests locate external data, not the synthesis pipeline itself — so the architecture is unchanged:

1. Core Layer (oxihuman-core) Arena allocator, graph algorithms, asset cache, spatial index, codecs, and the event bus — the no-network foundation everything else builds on.

2. Morph Engine (oxihuman-morph) Target-based parametric morphing over thousands of vertices, FACS facial action units, age and body-composition models, the pose graph and constraint system.

3. Mesh Pipeline (oxihuman-mesh) Halfedge topology, dual contouring with sharp-feature preservation, UV mapping/packing, LOD generation, LBS and DQS skinning.

4. Export & Viewer (oxihuman-export + oxihuman-viewer) glTF/GLB, COLLADA, OBJ, STL, USD, VRM, 3MF export, plus a wgpu/WebGPU renderer with a large set of debug views.

5. WASM Bindings (oxihuman-wasm) The 68-method browser API via wasm-bindgen — zero network, fully client-side, with optional WebGPU rendering.

The fixture resolution now flows through environment variables read at test time, so the same binaries run identically whether the data sits in your home directory, a CI cache, or a mounted volume.

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(())
}

To run the fixture-backed tests, point OxiHuman at your local data and asset roots:

export MAKEHUMAN_DATA_DIR=/path/to/makehuman/data
export OXIHUMAN_ASSETS_DIR=/path/to/oxihuman/assets
cargo nextest run --all-features

Leave them unset and the suite still passes — the data-dependent tests simply skip.

What’s New in 0.1.2

• Portable MakeHuman fixtures. Tests that depend on the MakeHuman dataset resolve the data root via MAKEHUMAN_DATA_DIR instead of hard-coded absolute paths. Set it to the MakeHuman data/ directory (containing 3dobjs/base.obj and targets/).
• Portable asset-pack fixtures. Asset-pack tests resolve their root via OXIHUMAN_ASSETS_DIR (the directory containing alpha_pack/oxihuman_assets.toml).
• Graceful skipping. Tests that require this data skip cleanly when the variables are unset, so a plain checkout still passes the full suite.

Tips

• Set both variables once in your shell profile. If you do OxiHuman development regularly, exporting MAKEHUMAN_DATA_DIR and OXIHUMAN_ASSETS_DIR in your shell rc means every cargo nextest run --all-features automatically picks up the full fixture coverage.
• CI without the dataset is fine. Because data-dependent tests skip gracefully, you can run the entire suite in a minimal CI environment and still validate the bulk of the codebase — then add a second job that mounts the dataset and exports the two variables for full coverage.
• MAKEHUMAN_DATA_DIR points at data/, not the repo root. The expected directory is the one that actually contains 3dobjs/base.obj and targets/. If your fixtures skip when you expected them to run, double-check you pointed at the inner data/ folder.
• No paths in the repo means easy contribution. You can clone, build, and run the default suite on any machine without editing a single path — a good first-PR experience.
• Still client-side by default. None of this changes OxiHuman’s core promise: the core crates compile without an HTTP stack and make no outbound connections at runtime. Your body parameters never leave the machine.

This is the foundation

OxiHuman is the privacy-first, client-side human modeling layer for the COOLJAPAN ecosystem. As of this release it sits alongside siblings like SciRS2 and NumRS2 for the numerical and scientific-computing groundwork, OxiMedia for media and video pipelines that can consume generated avatars, OxiBLAS and Oxicode for the low-level Pure Rust building blocks, and OxiGDAL for geospatial workflows. Everything stays C-, C++-, and Fortran-free, compiling to a single static binary or to WASM.

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

Star the repo if you want privacy-first, server-free 3D human generation that builds and tests cleanly on every machine.

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

— KitaSan at COOLJAPAN OÜ May 5, 2026