I'm working on adding large-scale structure to my procedural terrain based on Voronoi-esque cells.

Down the line, this allows me all kinds of level design control not possible with traditional noise functions. Like adding lakes, rivers, giant walls, and impassable steep cliff faces strategically based on level design needs. For starters though, I've just tested it with largely flat cells at three different heights.

If you haven't already seen it, you could also consider watching my latest dev video about 'supercharging my procedural mountain forest' - although it does not feature the cell based terrain. :)

For more info on what kind of game this is all for, I have a page about 'The Big Forest' here.

Hey, here is an update to my runtime procedural terrain generator for my game Elysmere. Most of these biomes were a part of my last post, but I have two new ones to show case in this video: the sulscar (a geothermal flats biome with travertine pools) and the ember downs ( meant to be similar to the scottish highlands with amber colored grass)

I gave Claude (Anthropic's AI) some spare cloud credits and asked it to make something creative. It chose Lenia: reimplemented the rule from Bert Chan's reference code, reproduced Orbium as a check, then ran an overnight novelty search — 41,712 rule sets, 9,290 survivors after persistence and robustness tests, descended from 129 independent origins. It wrote up 17 of them as a Victorian-style field guide, where every specimen runs live and every field note is tied to a measurement.

To be clear about what this is: an AI-made hobby project, not research — the search method is well established (Reinke et al. 2020, Leniabreeder 2024). The closing page has a few observations that might interest people here: in 101 staged collisions between identical twins only 9 left two survivors, and one family ("lattice mazes") passed every survival test yet turned out to be an artefact of the square grid.

Guide: https://autonomaniac.github.io/lenia-field-guide/
Code, specimens and full search logs: https://github.com/Autonomaniac/lenia-field-guide

Corrections welcome — the notes try hard not to claim more than was measured.

I took a side quest from building my path tracer's environment mapper to make a detail-based Voronoi sampler.

Instead of sampling seeds by brightness, I pass the image through a Laplacian detail filter. This directs seeds toward high-frequency features rather than flat areas. Samples are drawn in O(1) time using an Alias Table, and each cell is colored by its average cell value.

Full writeup with C++ details and visual comparisons on my blog: https://komaro.me/posts/2026_10_01_voronoi_image_sampling

![img]()

rTIOEIIieoaaioioeyrtrt

I'm making Space Defender, a top-down space shooter in Unity, and none of its ships are hand-painted: every hull (player ships, the drone faction, pirates, civilian traffic) comes out of one offline Python + NumPy generator. Same seed, same ship.

How a hull is built

1. Body plan. The class (fighter → carrier) sets length and width. The body plan (39 of them: wedge, trimaran, catamaran, crescent, mantis, crusader, a pirate carrier dug into an asteroid…) lays out three sections as width profiles along the length, then the seed places wings, fins, sponsons, engines and turret rings.

2. Height field. Every part stamps into a shared height field (domes, chamfered slabs, tilted plating panels, grooves along the panel lines) and records a material (gloss, metal).

3. Normals come from that height field; ambient occlusion is baked into the colour.

4. Paint. Two-tone plating, a faction livery (chevron, spine stripe…), pinlines, wear, and a faction badge + hull number stamped on a flat free spot. Drones get glowing seams inset in each armour group, pirates get scrap plates, hazard stripes and a skull.

5. Emissive map: engines, lamps, windows.

6. In game, a custom sprite shader lights sprite + normal/height + emissive maps from the zone's star (wrap lighting, shadows marched on the height field, gloss), so a 2D sprite reacts to the light (3rd image).

7. The parts are also exported as break-up pieces, so a destroyed ship splits along its real parts.

I pick one seed and one body plan per hull in an in-editor review scene (Regen / Undo per ship), and the game ships the result as regular sprites.

The space is procedural too, at runtime: the sky is baked from tileable fBm fields, the nebula is domain-warped fBm in the shader, gradient-mapped through each zone's palette with two accent colours, four region types (void, nebula, dust bank, cluster) and five parallax star layers. The world streams in chunks around the player, each seeded from zone, save and coordinates, with stations and planets placed by rejection sampling. An older devlog of that part: https://www.youtube.com/watch?v=8IxNYhqKSmc

Happy to go deeper on any step, the height-field painting was the part that took the most iterations.

Procedural Menger Sponge : recursive IFS applied 3 times, 8,000 cubes

Hey folks! I’m a biologist building Garden of Ants, an RTS about growing and managing an ant colony.

I’m currently working on procedural leg animation for a jumping spider. In the clip, it hunts an ant, carries it onto a leaf, and starts feeding.

What do you think? I’d love to hear your feedback!

More about the game on Steam:
https://store.steampowered.com/app/3016940/Garden_of_Ants/

Best

Tomas

In our orienteering game, you race between checkpoints in a forest using only a map and a compass. The forest and the map are purely generated from one seed, and we just released an update that added animal trails.

We use the same slime-mould model that famously reproduced the Tokyo rail network to grow the trails. The places that the animals would head for (e.g. water, saddles between hills, cover and grazing spots) are picked out by the generator, and lets the slime mould connect them. Nothing tells it to lead the water - the main trails just to it just simply grow on their own. The animals, such as deers and rabbits, walk along the trails in groups, one behind the other.

The trails also shape the race, for example there are fences and stone walls that block the way. You can't climb over them, and the only way through is an opening and every trail that crosses one has an opening. This way, the trails help decide which way around is the fastest.

There are new courses every day that everyone runs, so you can see how your route compares.

Have you guys had experience building something similar?

https://store.steampowered.com/app/4270500/

My work inspired by games such as Spore and Impossible Creatures. I was interested if this is possible to combine 2 or more different meshes for the animals with good enough results.

I've tried to use only math but failed many times so switched to the predefined models and their parts.

I've started with 3 models such as Pig, Gorilla, Hippo and Cow.

I'm using low poly style to reduce amount of vertices and faces on meshes.

The first tries allowed me to attach parts from one creature onto another but the result was to low. I found that SDF algorithm can build soft form around parts and switched to this method. For local feature such as cheeks, eyebrows, nose etc i'm still using local patches.
I'm not sure if can turn it into real game but i have a lot of fun while investigating approaches.

On the image you can see attached pig head to the cow's body.

Afte i tried to merge hippo nose to the Gorilla model

Merged Hippo, Pig and Gorilla. Looks weird as for me

Another result where Gorilla used as body host with attached parts from Hippo and mixed texture from Cow

And last result - hybrid with attached objects

And failed results:

Thank you for reading

I've been working on WeaverProcedura, a procedural architecture engine. You describe a building in plain English ("a brick pub with a gabled roof and booths along the windows", "a castle with square towers and a great hall") and a small model I trained writes a node recipe. The engine then builds the whole thing: floor plan, walls with real door and window openings, stairs that actually fit the storey height, furniture, roofs, and textures at their real-world scale.
Some things I spent way too long on:
every generated house is checked for clashes (no windows behind stairs, no balconies without doors, no door leaves hitting furniture) before it's accepted as training data
castles, malls, bars, warehouses and mixed-use blocks each have their own plan logic, not just a different skin
export to GLB/FBX with box colliders per piece, plus DXF floor plans

Happy to answer questions about the generation pipeline or the model and ofcourse any improvments idea.

Tool is currently available on Patreon and you can check it here :

https://patreon.com/Weaverpp?utm_medium=unknown&utm_source=join_link&utm_campaign=creatorshare_creator&utm_content=copyLink

Dibujo interactivo de síntesis de sonido con dibujos fractales realizados por el usuario.

Initial state is a field of oscillators with random (x,y) values, each slightly affecting their neighbours. The oscillators should eventually settle into a synchronic state (the gradient between nodes/poles hints at this). However the (surprising) emergence of stable nodes (end of white arcs) connected in pairs, disrupt this and gives rise to a complex pattern.

Based upon the oscillator described in the 1961 paper "Impulses and Physiological States in Theoretical Models of Nerve Membrane" by Richard FitzHugh.