Monster Forge: building reproducible modular characters with Python

By Mr Q. Public contact: https://github.com/QoobIY

A character editor produces more than a preview. It produces a selection of source parts, material choices and an exported artifact that someone must be able to reproduce later. Monster Forge is an open-source low-poly character constructor built around that relationship.

The repository includes 33 race and creature templates, 193 presets, and its existing face, hair, clothing, body-shape, limb and accessory choices. The application and the declared built-in source resources are licensed under Apache-2.0. You can run the constructor locally without installing a separate game project or obtaining an image-generation API key.

Composition in the browser

The Body Parts workspace exposes the existing catalog and appearance controls. A shared viewer updates after changes without reloading the page. Assembly stores character revisions so that a saved selection can be opened again.

Exports contain an assembly.json instruction and one model.glb. Templates that have a rig export their skeleton and skin weights. Existing authoring templates without a rig export static geometry and identify that limitation explicitly. A catalog entry is not a claim that a complete animation rig exists for every creature.

These files are inputs to your own asset workflow. Test the imported model and its conventions in the engine or tool you intend to use; the constructor does not certify every engine integration.

Treat generated files as build products

The permanent source library holds geometry recipes, metadata, appearance presets and required reference inputs. Compiled parts, weight sidecars and UI cards are reconstructible cache files under /tmp/monster-forge.

That boundary matters when another developer clones the project. A preview on the maintainer's machine is not enough: the checkout needs the inputs required to rebuild it. Conversely, thumbnails and intermediate GLBs should not become the only surviving copy of an asset.

Source hashes and revision identifiers make changes explicit. Updating a source part creates a new revision rather than silently replacing the bytes behind an existing character. Saved assemblies preserve the selected settings and reference the built result.

Keep one implementation of geometry and weights

Python calculates geometry, bind transforms and weights. The browser displays the returned result. The same ConstructorService boundary is used for validation, building, preview and storage, which makes it possible to test the result independently of clicking through the UI.

For example, run this from a checkout with the application dependencies installed:

from pathlib import Path
from tempfile import TemporaryDirectory
from monsterforge.constructor import ConstructorService

service = ConstructorService()
settings = service.default_settings()

with TemporaryDirectory() as temporary:
    instruction, model = service.compact_assembly(settings, Path(temporary))
    assert instruction["schema_version"] == 2
    assert instruction["model"]["path"] == "model.glb"
    print(len(model))

Tests check finite coordinates, allowed bone influences, normalized skin weights, bind consistency, shared floor placement, source hashes and reopening saved settings. Those numerical checks establish technical properties, not artistic quality.

Try it and extend it

The tested launch environment uses Linux, Python 3.12, uv and make:

git clone https://github.com/QoobIY/monster-forge.git
cd monster-forge
make run

The first run installs the locked application dependencies. Open http://127.0.0.1:5050/characters/ to use the included catalog.

The contributor documentation describes ConstructorRegistry, SourceBundle and ConstructorService. Presets live in versioned JSON files. New production source extensions use the humanoid_v1 contract; the existing additional authoring templates remain available.

A complete game Playground and an end-to-end text-to-character generation workflow remain future work. Some stored positioning references were generated with AI, while the running constructor builds geometry from versioned recipes rather than issuing live generation requests.

Code, screenshots and contributor documentation: https://github.com/QoobIY/monster-forge

Disclosure: this article was drafted by an AI agent on behalf of the project maintainer. Its technical claims were checked against the project source, and the Python example above was executed successfully.