A software development kit for the mechatronics and simulation space.

What it is

CortenForge provides the building blocks spanning the path physical → digital → physical: get a real object into a simulation, design something against it, optimize that design through the physics, and gate the result for manufacture.

The kit is the product.

Most tools cover one leg of that path and hand off through file exchange. CortenForge’s components share one geometric kernel instead: an Sdf trait implemented across design, meshing, and the soft-body engine, with the rigid engine consuming the same kernel’s sampled grids. A design therefore reaches a simulation in memory, with no export step in between — the design-to-sim example is that path, start to finish, in a single source file.

The soft-body FEM and the soft↔rigid contact coupling are differentiable, running a single reverse-mode tape across both engines. The rigid engine supplies analytic and finite-difference derivatives. MISSION.md sets out where that leads.

What it’s for

Get started

Applications depend on a single crate — the cortenforge facade — and reach the headless core of the SDK through it, so the internal crate structure can evolve behind one import surface.

[dependencies]
cortenforge = { git = "https://github.com/via-balaena/CortenForge" }

Depend on the repository, not crates.io — the published listings lag this workspace by months, so cargo add will silently give you a stale version.

// Two umbrellas plus the design and fabrication crates, all through one dependency:
use cortenforge::sim;          // rigid + soft physics, soft↔rigid coupling, RL/opt
use cortenforge::mesh;         // load / repair / measure / print meshes
use cortenforge::cf_design;    // implicit-surface design kernel
use cortenforge::cf_cast;      // multi-material mold generation

Simulation lives under sim, mesh work under mesh, and the design and fabrication crates are re-exported individually. The facade is headless by construction, so anything built against it runs without a window or a graphics driver — on a build server, or inside a training loop. Left out: the Bevy, GUI, and GPU crates, and most of the research and application code under tools/, of which it re-exports only the headless scan-prep and mold-CLI crates. Everything excluded is still in the repository; you can depend on it directly.

To work on the SDK itself rather than depend on it:

git clone https://github.com/via-balaena/CortenForge.git
cd CortenForge
cargo build -p cortenforge          # the facade; --workspace builds all 300 members
cargo xtask grade <crate-name>      # run the quality gate on a single crate

The stack

70 crates outside examples/. Pure Rust with no framework dependencies in the physics and mesh cores; the mold-CSG stage builds a vendored C++ kernel through CMake. The facade pulls it in by default, so a first build needs CMake and a C++ compiler; default-features = false, features = ["sim", "mesh"] skips it. Layer-0 core crates are checked against the wasm32-unknown-unknown target as part of the quality gate.

Depending on it

The API still moves. These are the terms.

Where to start

Read a worked example to see the components composed, or open an issue on GitHub — questions and bug reports are both welcome there.

Elsewhere