So I've been looking into generating believable villages in my game. I've been writing a couple of articles about it, the process and the different stages.

I found a few website that were generating villages that looked pretty cool but they didnt show the process or tech behind and i have found it difficult to find documentation in general about the subject (at least from my research) so was wondering if anyone here would know a good resource for it?

Here is the last article i wrote in case you are interested and a few screenshots of what it looks like in game right now

In this weeks update to my engine, I have added Heat simulation and some related survival mechanics. Walking around in the cold, especially during snow, causes the player to cool down.

The heat simulation accurately warms indoor and enclosed spaces. Standing near heat sources also provides some additional warmth, enabling interesting interactions with the world, storms and biomes.

Along side temperature, there is also a basic hunger mechanic. These mechanics work together to determine health, which impacts player stats.

I spend my whole weekend on creating procedual generated trees for my game. Still not entirely finished but i must say i am quite proud

Python (Pillow + NumPy)

I built a web tool called Stoamandl (Austrian dialect for "little stone man"—the stone cairns used to mark trail paths in the Alps).

It stacks hand-drawn vector rocks based on a seed and socket-snapping constraints, generates unique titles for each stack, and exports directly to clean SVGs.

• Try it out: https://stoamandl.zeitport.com/
• Deep dive on how it works: https://stoamandl.zeitport.com/about

Would love to hear your thoughts or ideas on how to improve it!

needed better audio for my game. ended up spending a bit too long on this lol. currently runs at 5ms out of the 20ms fixed update budget.

every pipe and junction is easily editable, the engine itself is slightly more hard coded, but its pretty quick to add new cylinders or change the parameters of it.

I am building an open-world video game for cars and driving using real geographical data from real streets to real buildings.

I created Zervan generative engine that is able to get buildinggenerate scale and information and generate a relative facade with proper architecture for that building (based on age, shape and regional architecture).

Categories are: Residential, Economic, Industrial, and Special (Military, Library, banks etc).
Every postal code and street code aligns with the buildings from the real world and their function as well. However, for copyright reasons, I am avoiding mentioning the exact name of the businesses.,

It is all Python + Godot. Where Python generates and manages all the information and everything, creating a concerete of a map, and Godot for loading that map for rendering, physics, and the game side of the work.

I have a FOSS program where I am modelling solar systems in a reasonably accurate way within a browser. I am a "keen amateur" when it comes to astronomy/astrophysics and only know so much; so was looking to see if there is "variety I am missing".

What's the aim?
100% scientifically accurate is NOT the aim as this is ultimately a tool to support Sci-Fi RPGs and NOT do serious science - that said - if someone LEARNS something about science - GREAT! So scientific plausibility rather than accuracy is my aim. Although I have to say the differences are pretty small as I progress. I have known shortcuts like the assumption of polar magnetic fields and I am NOT doing full atmosphere levels & dynamics. A user may load up 20 solar systems at once; so there is a very practical limit to what a browser can do in a reasonable time-frame.

i.e. It has enough to be interesting and educate, just not properly simulate.

The images are not meant to be photo-realistic - but diagrammatically useful. If you want "photos" when I can just churn out a Space Engine export to load up and "take pics out the window of your ship". So my aim is "good enough" to be useful - e.g. seeing an red/green aurora means I know there is oxygen without looking at the details.

How does it work?
Under the hood everything is procedural generation. Users can use it to generate solar systems based off some simple parameters or just "roll their own" manually - the system forces the player down certain routes to try and keep everything "physically reasonable" but if they wanna do something scientifically inaccurate "but cool" for their plot they can; but this will warn them its not right. So I guide rather than force for accuracy.

Generally everything just works off mass, composition, orbital profile, distances from star(s)/other bodies, liquid and atmosphere composition (if any) & system age. (generated procedurally, imported from Space Engine/Universe Sandbox or meddled with manually - I don't care the source of the basic data - it is a useful abstraction point).

With those basic inputs it runs a whole series of physics models as the user adjust sliders and squirts out a series of tags. e.g.:Titan's physics turns out an evolved set of planetary parameters as well as a load of tags: Tidally locked: Locked to its planet, Inert atmosphere, Asphyxiant, Greenhouse Icy shell: water, Standing liquid: methane, Cloud deck: blue, No magnetosphere, Geologically dead, Age: ancient, Irradiation: moderate, Ices: carbon-dioxide+water, Alien-habitable, Water ice

Why tags - well they are simple, can be surfaced to the user directly and can hold some simple data (e.g. ring intensity). They also become an easy abstraction point to the later code - like life chances and the renderer.

From the base data and the tags I build a 2D and a 3D representation of the planet (3D lets me slide clouds, BH lensing, etc... but the 2D is more practical here)

Here is a practical example of a recent change: building a planetary activity ladder to determine planetary resurfacing over time for surface aging features; Irradiation bleaching, , cratering, tidally-locked cratering profiles, cracking, geysers, crustal rifts, tholin darkening, etc.

So why am I here?
Well I see a lot of very clever folks here (many with some serious science backgrounds) doing similar modelling of more complex things and I was wondering whether there are any key things I am missing. Some planetary features relevant to RPGs where there is some solid physics that is practical to model on a reasonably large scale on a browser to give even more interesting planet types?

What I do have that is not shown in the picture that does get modeled & drawn; a wider variety of stellar remnants (Neuron stars, magnetars, white dwarfs, etc) , rings and belts. There is also a whole constructs model that can show things but that is not the focus here - just looking at the natural side of things.

e.g.: one thing I model is "atmo stripping" over time but I don't draw that as I am not sure how to... Would a whole planet get a comet like tail? Exotic precipitation worthwhile? I think I have "the major stuff" which is why I am here - so try and work out what else I could add,

Not here to push my prog (so no links or anything) - but happy to share anything I have done as it is all FOSS and has a Github if you wanna poke deeper.

Made in Blender

I built an iOS game with procedural generated fishpets that you can trade and breed with other fish to get unique creatures

https://apps.apple.com/br/app/fishpet-a-quiet-reef/id6791711788

I just posted my first Devlog on how I made procedurally generated creatures for my game!

This is built on Particle Lenia, an artificial-life model from Google researchers.

Each particle descends an energy field created by its neighbors, and an entire species is defined by just six parameters. I added cross-species senses—hunters are attracted to prey fields, prey avoid hunter fields—plus food, walls, and goals, and it turned into a strange little ecosystem garden.

Nothing is scripted or animated. The layered membranes, the chase behavior, and the way colonies merge and split all emerge from the underlying math.

Play (free, in-browser, ~70 KB):
https://leonbzt.itch.io/particular

Particle Lenia:
https://google-research.github.io/self-organising-systems/particle-lenia/

This is built on Particle Lenia, an artificial-life model from Google researchers.

Each particle descends an energy field created by its neighbors, and an entire species is defined by just six parameters. I added cross-species senses—hunters are attracted to prey fields, prey avoid hunter fields—plus food, walls, and goals, and it turned into a strange little ecosystem garden.

Nothing is scripted or animated. The layered membranes, the chase behavior, and the way colonies merge and split all emerge from the underlying math.

Play (free, in-browser, ~70 KB):
https://leonbzt.itch.io/particular

Particle Lenia:
https://google-research.github.io/self-organising-systems/particle-lenia/

Felt like sharing a bit more about my experience with this versatile API, maybe it helps someone out there find the right solution!

For now there are 196 distinct base voice profiles aka instrument preconfigurations, evenly distributed to their intended channel strips. Orchestrator channel for 32, 64, 96, 128 bar preplanning and assignment, channels like drums and hats + snares or leads and support communicate and plan on shorter intervals of 4 to 16 bars. Effect setup, tunable instrument parameters, rhythm selection and evolution, distribution and balance of instruments and intended emotional ambiance setting are derived from random seeds.

Might be a bit overkill for minesweeper, I'm not too sure where I'm going with this yet...xD On the other hand, as a user you can turn off the lead and drum channels, turn down the BPM and end up with just a long mysterious ambient layer, hums and faint choirs...maybe some light noise, melodic arps... Typical space exploration scifi stuff. the question is more, does any sane user want to bother with all these settings? :D

Maybe its just a case study and a lightweight audio engine to export to a more fitting project in the end.

Either way, web audio API is truly a potent interface and LLMs make accessing and manipulating its nodes a lot more intuitive for less experienced folk. You should still have a basic understanding of digital audio production and signal processing as well as general music composition going into this as even 5.6 Sol often struggled to relate frequency and oscillation signatures to instrument names and thus the correct orchestration channels and you will have to do a lot of esoteric "dancing my name"-ish debugging sessions...but in the end, this 1 oscillator node provides infinite possibilities! :)

https://developer.mozilla.org/en-US/docs/Web/API/Web_Audio_API

2D spaceship generation inspiration:

https://github.com/ggalancs/SpaceshipGenerator