# I built a free open-source tool for generating game assets as structured objects instead of one-off meshes — retained record

> Retained reddit record from reddit:gamedev.

Canonical: https://highsignal.app/data/records/8f1927490d683cdd

[← sources](https://highsignal.app/data)


source: [reddit](https://highsignal.app/data/reddit) (reddit:gamedev)  published 2026-11-17 15:48 ingested 2026-11-18 02:37

[original source ↗](https://www.reddit.com/r/gamedev/comments/1xynux1/i_built_a_free_opensource_tool_for_generating/)

## retained text



```
I've been working on a different approach to AI-generated 3D that I thought might be useful to people here. It's called **Construct**, and the basic idea is pretty simple: instead of asking an agent to generate the final mesh, it describes the object first. That distinction sounds minor, but it started mattering a lot once I tried taking generated things into game engines.

If I ask Claude to make me a car or even an entire game level directly, it can absolutely write geometry or code that produces something visually convincing. The problem is that most of the useful information about *what the thing is* tends to live implicitly in the generation process. Construct keeps that information as the source of truth. An object is stored as named parts at real dimensions, with parent/child relationships, joints, materials and provenance. Construct validates that representation and deterministically compiles the geometry from it. So a vehicle isn't just triangles that happen to look like a vehicle. It can contain `front-left-wheel`, `driver-door`, `hood`, etc., with actual relationships and articulation axes.

This [VW T1 Samba](https://rtmandreyev.github.io/construct/examples/volkswagen-t1-samba/), for example, has both front doors, both cargo doors, the engine lid and even the folding sunroof as working articulated parts. The same underlying object can then be compiled differently depending on what the game needs: keep it assembled and preserve the joints, export the pieces separately for rigid-body/destruction workflows, or merge static geometry and generate colliders when runtime efficiency matters more than keeping every piece independent. Those aren't separately generated versions of the vehicle. They're different compilations of the same object.

The same idea scales to levels. For [Rain Harbour](https://rtmandreyev.github.io/construct/worlds/rain-harbour/construct.html), I started with one cyberpunk concept image. The parent agent planned the scene as 21 distinct objects, built each object once, and then placed them 50 times to assemble the world. That means the car sitting in the street is still an independent car with working doors. A repeated prop is still one reusable object placed multiple times, and I can change one of those objects without asking the model to regenerate everything around it. The assembled world then exports to Godot as a roughly 28 MB GLB in about 20 seconds on my laptop.

I tested the opposite case with [Stortorget](https://rtmandreyev.github.io/construct/worlds/stortorget/construct.html), Stockholm's old square. Starting from one photograph, the agent identified and researched the real buildings separately before reconstructing and placing them. And it isn't limited to recreating existing things: [KESTREL](https://rtmandreyev.github.io/construct/examples/kestrel-v2/) is a fictional spacecraft designed from a brief and real engineering references before being built as a Construct.

So why not just ask Claude to generate the level directly? For a background that I'm going to look at once and throw away, I probably would. Construct adds overhead. The agent has to reason about dimensions, decomposition and relationships, validation has to pass, and difficult objects can take multiple review rounds. Curved geometry and vehicles are still particularly hard. Where I think the extra structure starts paying for itself is when objects need to be reused or instanced, doors or machinery need to articulate, something needs to break into physical pieces, the same asset needs different engine representations, or you want to change one object without regenerating everything around it.

For game engines, Construct isn't tied to Godot. It exports standard 3D formats such as glTF/GLB that can go through normal Blender, Unity, Unreal or web workflows. Godot currently has the deeper built-in integration, which is why a lot of my examples use it. For other engines or proprietary pipelines, there is an adapter system which can translate the same underlying Construct into whatever representation that pipeline expects, without changing the Construct itself.

It's still experimental, and generated geometry doesn't magically remove normal game-art work. Materials, optimization, LODs, art direction and cleanup are still real problems. I'm much more interested in preserving useful structure than claiming AI can one-shot a shippable level.

Construct is completely free and open source:  
[https://github.com/rtmandreyev/construct](https://github.com/rtmandreyev/construct)

Gallery:  
[https://rtmandreyev.github.io/construct/](https://rtmandreyev.github.io/construct/)

It can run as an agent skill, through MCP with other agents/clients, or as a native Hermes plugin. I'm actively working on it, so if anyone tries it in an actual game pipeline, I'd be especially interested in where the representation helps and where it gets in the way. Bugs and ugly failure cases are especially  useful.
```



document fetched 2026-11-18 00:26 · canonical https://reddit.com/r/gamedev/comments/1xynux1/i_built_a_free_opensource_tool_for_generating
