I used a Voronoi diagram as a strategy game board — here is how the generation pipeline looks and the design tradeoffs I found

https://redd.it/1u48s79
@proceduralgeneration

Anchors

https://redd.it/1u4acqa
@proceduralgeneration

Procedural city buildings generated from OpenStreetMap footprints

https://preview.redd.it/kl3b2btdmy6h1.png?width=1913&format=png&auto=webp&s=1f0915ff4a295f6f62db265ffe661e73412ca223

https://preview.redd.it/1vkxnatdmy6h1.png?width=1913&format=png&auto=webp&s=1530ce3f66f7efc0048681d27d5a9b9a1bc7220f

https://preview.redd.it/ff9ll9tdmy6h1.png?width=1913&format=png&auto=webp&s=378bb11a7f00b047e45b04b83f57b251415ec935

https://preview.redd.it/e63qf9tdmy6h1.png?width=1913&format=png&auto=webp&s=17b4a48d5e376207f36983b2e069bf55a105e773

https://preview.redd.it/kzrxm9tdmy6h1.png?width=1913&format=png&auto=webp&s=d70c107450cdeb2b4a2b30ad0bab223acf6978a1

https://preview.redd.it/vrun4atdmy6h1.png?width=1913&format=png&auto=webp&s=26f092df1fc418c0e5637c84a77dfbf219a2a3cf

https://preview.redd.it/xw4vz9tdmy6h1.png?width=1913&format=png&auto=webp&s=f06512890201a6863a91a7dc314420a32e91ae5d

Been working on generating 3D buildings from real OpenStreetMap footprints. Each one gets its shape, floors, windows, balconies, roof and chimneys from the footprint and tags — all algorithmic, no hand-placed models. Open data, Python, exports to Godot. Just wanted to share where it's at. Cities in pictures: Saint Etienne, France 42000, Grenoble, France 38000.

https://redd.it/1u4eq58
@proceduralgeneration

Procedural Isometric Worlds

https://redd.it/1u4kwme
@proceduralgeneration

Procedural classical architecture add-on for Blender — every element auto-fits.

https://redd.it/1u4okm3
@proceduralgeneration

Final project for computer graphics class

https://redd.it/1u4t1ev
@proceduralgeneration

I turned a website from 2010 into a Procedural Art Generator CLI
https://www.reddit.com/gallery/1u53eh8

https://redd.it/1u53hn8
@proceduralgeneration

Started working on some fluid simulations after being inspired by Coding Adventures

https://redd.it/1u5ap83
@proceduralgeneration

Removed by Reddit

Removed by Reddit on account of violating the [content policy. ]

https://redd.it/1u5glrb
@proceduralgeneration

Procedurally Generated levels in my game

https://redd.it/1u5h49m
@proceduralgeneration

Cute universe simulation sandbox early access

https://redd.it/1u5ijt1
@proceduralgeneration

WorldLoop Turns Any Structure Into Playable Terrain
https://youtu.be/LeOkVhurRGw?is=hIQLhDr_d3d0vFig

https://redd.it/1u5iaz0
@proceduralgeneration

Project Rimheim (Working title)
/r/BaseBuildingGames/comments/1u5nia1/project_rimheim_working_title/

https://redd.it/1u5oqu3
@proceduralgeneration

Procedural Wulingyuan

https://redd.it/1u5uut4
@proceduralgeneration

A square rotating around a single vertex, recorded step-by-step
https://youtube.com/shorts/CPXI3ZM6vQw

https://redd.it/1u5vl69
@proceduralgeneration

Added spirograph to my free app

https://redd.it/1u5tiqf
@proceduralgeneration

Why I built a deterministic, data-driven engine that compiles Natural Language into bit-identical geometry

Most generative graphics tools today rely on probabilistic AI models. They are creative, but they are messy. You can’t recreate a scene exactly, and the outputs are often unpredictable.

I wanted the opposite: **Total, bit-identical determinism.**

I’ve spent the last months building **GAP+** (Geometric Architecture Parametrics), a system where natural language inputs compile to verifiable geometry through a strictly deterministic pipeline. No AI, no dependencies, no floating-point drift.

# The Architecture: "Objects are Data, not Code"

I moved away from hardcoded Rust strings. The pipeline is now:

1. **Natural Language Input:** `geotool nl "a stone tower"`
2. **Thin Loader:** Parses modifiers and selects a template.
3. **GAP+ Template:** A parametric `.gap` file (pure data).
4. **Compiler:** Expands `include`, `repeat`, and `let` declarations.
5. **Geokern Engine:** Executes the operations to output a **Merkle Hash** that proves the scene's geometry.

# Why this is different (The "World-Class" Checklist)

* **Cross-Platform Determinism:** By using a golden-root test matrix (Linux, Windows, macOS), every scene hash is validated. If the macOS output differs by a single bit from the Linux output, the CI fails.
* **No-Recompile Workflow:** I can add a complex object (like an obelisk) by adding one `.gap` data file and one TSV registry line. The engine doesn't even know what an "obelisk" is—it just executes the parameters.
* **Zero-Warning Policy:** The codebase enforces strict `clippy` lints and standard formatting via CI. If it doesn't build perfectly, it doesn't get merged.

# The Proof

Here is a physically based render of a gold sphere generated by this pipeline:

`sphere a0 2 48` `pbr a0 0.90 0.55 0.30 1.0 0.18 0.5`

# Why this matters

This isn't just about rendering spheres. It’s about building a **Foundation for Procedural Worlds** where you can mathematically prove the state of your environment across any hardware.

I've just open-sourced the framework, and I'm looking for feedback on the architecture—specifically on how to handle compositional grammar (e.g., "a vase on a table") within a purely deterministic system.

You can check out the source, the golden-root test suite, and the engine internals here:


[https://github.com/MerlijnW70/gap](https://github.com/MerlijnW70/gap)

https://preview.redd.it/rzkf9qkqvb7h1.png?width=1280&format=png&auto=webp&s=c092900458c44c0a849d736a031dcbea7c367c0c




https://redd.it/1u5zczk
@proceduralgeneration