SolidRS

A generic 3D model loading and saving library for Rust — designed on the
same split as serde / serde_json:

solid-rs defines the scene IR, the Loader/Saver traits, and the format
Registry. Format crates implement those traits for a specific file format and
are pulled in à-la-carte.

Crate Ecosystem

Quick Start

Add the core crate plus whichever format crates you need:

[dependencies]
solid-rs   = "0.1"
solid-fbx  = "0.1"   # Autodesk FBX
solid-obj  = "0.1"   # Wavefront OBJ
solid-gltf = "0.1"   # glTF 2.0 / GLB
solid-stl  = "0.1"   # Stereolithography STL
solid-ply  = "0.1"   # Stanford PLY

Load a file

use solid_rs::prelude::*;
use solid_rs::registry::Registry;
use solid_fbx::FbxLoader;

fn main() -> solid_rs::Result<()> {
    let mut registry = Registry::new();
    registry.register_loader(FbxLoader);

    let scene = registry.load_file("model.fbx")?;
    println!("Loaded {} mesh(es), {} material(s)",
        scene.meshes.len(),
        scene.materials.len());
    Ok(())
}

Save a file

use solid_rs::prelude::*;
use solid_rs::registry::Registry;
use solid_obj::{ObjLoader, ObjSaver};

fn main() -> solid_rs::Result<()> {
    let mut registry = Registry::new();
    registry.register_loader(ObjLoader);
    registry.register_saver(ObjSaver);

    let scene = registry.load_file("input.obj")?;
    registry.save_file(&scene, "output.obj")?;
    Ok(())
}

Convert between formats

use solid_rs::prelude::*;
use solid_rs::registry::Registry;
use solid_fbx::FbxLoader;
use solid_obj::ObjSaver;

fn main() -> solid_rs::Result<()> {
    let mut registry = Registry::new();
    registry.register_loader(FbxLoader);
    registry.register_saver(ObjSaver);

    let opts = LoadOptions { triangulate: true, ..Default::default() };
    let scene = registry.load_file_with_options("scene.fbx", &opts)?;
    registry.save_file(&scene, "scene.obj")?;
    Ok(())
}

A ready-to-run conversion example lives in
examples/fbx-to-obj:

cargo run -p fbx-to-obj -- input.fbx output.obj

Architecture

┌────────────────────────────────────────────────────┐
│                     solid-rs                       │
│                                                    │
│  Scene ── Node ── Mesh ── Material ── Texture      │
│  Camera ── Light ── Animation ── Skin              │
│                                                    │
│  trait Loader   trait Saver   Registry             │
│  SceneBuilder   LoadOptions   SaveOptions          │
└──────────────────────┬─────────────────────────────┘
                       │  implements
       ┌───────────────┼───────────────────┐
       ▼               ▼                   ▼
   solid-fbx       solid-obj          solid-gltf
   solid-stl       solid-ply          solid-usd …

Scene IR

The intermediate representation is a flat, index-based scene graph —
similar in spirit to glTF's document model:

Scene
 ├── nodes:     Vec<Node>          (parent refs by NodeId index)
 ├── meshes:    Vec<Mesh>          (Mesh.primitives: Vec<Primitive>)
 ├── materials: Vec<Material>      (PBR metallic-roughness)
 ├── textures:  Vec<Texture>       (URI or embedded bytes)
 ├── images:    Vec<Image>
 ├── cameras:   Vec<Camera>
 ├── lights:    Vec<Light>
 ├── animations:Vec<Animation>
 └── skins:     Vec<Skin>

Every cross-reference is an integer index, keeping Scene fully Clone-able
without Arc or reference cycles.

Traits

// dyn-compatible — usable as Arc<dyn Loader>
pub trait Loader: Send + Sync {
    fn format_info(&self) -> &'static FormatInfo;
    fn load(&self, reader: &mut dyn ReadSeek, options: &LoadOptions)
        -> Result<Scene>;
}

pub trait Saver: Send + Sync {
    fn format_info(&self) -> &'static FormatInfo;
    fn save(&self, scene: &Scene, writer: &mut dyn Write, options: &SaveOptions)
        -> Result<()>;
}

Both traits are dyn-compatible — format drivers can be stored in the
registry as boxed trait objects and dispatched at runtime by file extension or
MIME type.

Building

# Build everything
cargo build --workspace

# Run the full test suite (~350 tests)
cargo test --workspace

# Run the FBX → OBJ converter example
cargo run -p fbx-to-obj -- input.fbx output.obj

Format support matrix

Format Feature Details

Legend: ✅ supported · ⚠️ partial · ❌ not supported · — not applicable to this format

FBX — Autodesk Filmbox (solid-fbx)

Extensions: .fbx · MIME: model/fbx

OBJ — Wavefront (solid-obj)

Extensions: .obj, .mtl · MIME: model/obj

glTF 2.0 — Khronos (solid-gltf)

Extensions: .gltf, .glb · MIME: model/gltf+json, model/gltf-binary

STL — Stereolithography (solid-stl)

Extensions: .stl · MIME: model/stl, application/sla

PLY — Stanford Polygon (solid-ply)

Extensions: .ply · MIME: model/ply

Implementing a Format Crate

See the step-by-step guides in docs/:

Minimal loader skeleton:

use solid_rs::prelude::*;
use solid_rs::traits::{Loader, ReadSeek};

pub static MY_FORMAT: FormatInfo = FormatInfo {
    name:         "My Format",
    id:           "my-format",
    extensions:   &["mfmt"],
    mime_types:   &["model/x-my-format"],
    can_load:     true,
    can_save:     false,
    spec_version: None,
};

pub struct MyLoader;

impl Loader for MyLoader {
    fn format_info(&self) -> &'static FormatInfo { &MY_FORMAT }

    fn load(&self, reader: &mut dyn ReadSeek, _opts: &LoadOptions)
        -> Result<Scene>
    {
        let mut builder = solid_rs::builder::SceneBuilder::new();
        // … parse reader, call builder methods …
        Ok(builder.build())
    }
}

License

MIT — see LICENSE.