Introduction

The barrier just dropped. NVIDIA’s Kimodo—the kinematic motion diffusion model trained on 700 hours of professional mocap—used to demand roughly 17 GB of VRAM per generation. That locked it behind datacenter iron.

kimodo.cpp changes the equation. This fresh C++/GGML port from the LocalAI team (led by Richard Palethorpe) runs the same text-to-motion pipeline on ordinary CPU or Vulkan hardware. You type a prompt, it spits out unconstrained SMPL-X22 local rotations and root translations. Fully offline. Fully local. Fully yours.

For game developers, technical artists, and anyone building real-time character systems, this is the moment text-to-motion stops being a cloud experiment and starts becoming engine-native infrastructure.

The Magic of Local Motion Diffusion

Kimodo itself is a two-stage transformer diffusion model. One stage handles root trajectory, the other body articulation. That separation kills the classic floating-and-skating artifacts that plague earlier motion generators. The original ships multiple skeletons (SOMA, Unitree G1, SMPL-X).

kimodo.cpp currently focuses on the SMPL-X22 checkpoint (Kimodo-SMPLX-RP-v1). Feed it a plain UTF-8 prompt or a precomputed 4096-dimensional LLM2Vec embedding and it returns clean joint rotations plus root motion.

Under the hood you get GGUF loading, safetensors conversion, DDIM sampling, full C and C++ APIs, and parity tests proving CPU and Vulkan paths match. The text encoder streams in eight-layer Vulkan chunks by default so you can dial VRAM with a single environment variable.

This is still early—five to ten commits, constraints not yet ported, no GLB export, no quantized models, no SOMA or G1 skeletons. But the foundation is rock solid. The same pattern that turned llama.cpp into the local-LLM standard is now being applied to high-quality human motion.

Pro Tip

Wire the C API directly into your animation pipeline instead of waiting for a full DCC exporter. The returned SMPL-X22 data is already in a format that maps cleanly onto most modern skeletal systems. Drop the rotations into a retargeting layer and you have live text-driven characters without ever leaving your engine.

Step-by-Step: Get Motion Running Locally

Here is the clean Linux path that works today.

  1. Clone and initialize the submodule
    git clone https://github.com/localai-org/kimodo.cpp
cd kimodo.cpp
git submodule update --init --recursive
  2. Install the basicsC++23 compiler, CMake 3.25+, Ninja, Python 3 with huggingface_hub, and the Vulkan loader/headers.
  3. Pull the native GGUF weights (after accepting the gated licenses on Hugging Face)
    scripts/download_gguf_weights.sh --output "$PWD"
  4. Build the debug preset
    cmake --preset debug
cmake --build --preset debug
  5. Launch the local browser demo
    go run ./demo -addr 0.0.0.0:8094

Open http://localhost:8094. Type a prompt, hit generate, watch the history fill with previous motions. Selecting an old entry reloads its prompt for rapid iteration.

Want reproducible everything? Drop into the Nix shell first:

nix develop path:. --command cmake --preset debug

The C API lives in include/kimodo/kimodo_capi.h. Call kimodo_generate with text or kimodo_generate_embedding with a 4096-float vector and you receive the full motion package ready for your pipeline.

Conclusion

kimodo.cpp is the first real step toward treating high-quality text-to-motion the same way we treat local LLMs—fast, private, and under your complete control. The original Kimodo proved the quality was possible. This port proves the accessibility is possible too.

Constraints, quantization, and full skeleton support are coming. When they land, the gap between “prompt” and “playable character animation” shrinks to almost nothing.

Get the repo, build it, and start feeding your characters language. The future of motion is already running on your machine.

—Titus