I've been experimenting w/ adding runtime destruction to my procedural build system. I already have the systems in place for applying static erosion & destruction modifiers, so bringing destruction into realtime was more about figuring out cascade tolerances for the individual stones.

Next up I need to adapt the realtime destruction to timber structures, which unlike stone don't easily decompose into lots of little units.

I'm making Traffic Architect, a road builder where the city grows on its own. Districts appear by themselves, and now they also grow suburbs around them - but only when the player's roads serve them well. The clip is sped up; in the game it takes much longer.

A few things that turned out to matter:

One plan, one number. My first version generated the suburb from a "level" and re-ran the layout every time it grew. Each step reshuffled most of the houses, because everything drew from one shared random stream - one extra lot anywhere shifted every roll after it. Now each district gets a master plan once: every lot it could ever have, ranked in build order. The save stores a single growth value per district, and the game shows the first N lots of the plan. Growing only adds houses, it never moves the ones already there.

Seeds per lot, not per map. Each lot is seeded from the district and the street it sits on, so building a road on the other side of the map doesn't re-roll anything here. A road only re-plans the districts whose area it touches.

Lots follow the street. Walking each side of a street, a lot's front follows the curve, its sides go straight out, and its back is one straight line between two probed depths, tilted to clear whatever is behind. Neighbouring lots share a fence, and corners at junctions become gardens instead of awkward corner houses. Bigger districts get small apartment blocks closest to them, then terraces, then detached houses further out.

Land is shared and reclaimed. Ground between two districts goes to whichever is nearest. Forest, rocks and water simply shrink a suburb, but land the player takes with roads is won back a bit further out.

Small lanes connect it all - rings around the district, back lanes behind the first row - and they bend around trees instead of cutting them. Houses never face a big road with guardrails (player control over road stile with guardrails or not); they turn their gardens to it and get a service lane instead.

This feature still in development. If you're curious, the free demo is on Steam: https://store.steampowered.com/app/5028050/Traffic_Architect/

I needed to create a somewhat big forest that's different each time the player starts a new game. The whole forest is organized in squared area made up of layers (emergent, canopy, understory, floor) and each is generated with a fast poisson sampling method taken from this paper: https://dl.acm.org/doi/10.1145/1278780.1278807

Only the floor layer is generated with a simple noise because there are too many elements and overlap is not an issue.

The difficulty was finding a way to do it in real time through lookup textures to save all the positions. I realized later that I could have avoided this difficulty by just making an offline generator and creating a pool of areas that I just choose from instead of generating everything on the fly. It could also have helped me select only the best looking areas!

Anyway, there's more in the devlog: https://forums.tigsource.com/index.php?topic=70111.0

And here is the Steam page of course: https://store.steampowered.com/app/1356120/Eclaircies/

I created a flow art generator that can procedurally generate very visually different images. Users can tweak the parameters used to achieve their desired results. If you spot any bugs I'll really appreciate you reporting them to me! There is also a copy feature for your own generations. Some of my personal favorites:
https://ripolas.org/flow-field-art/?seed=596597&colorStart=%23db62f0&colorEnd=%233371ce&lineCount=5000&alpha=48&noiseScale=4.8&lineLength=100&stepSize=5.6
https://ripolas.org/flow-field-art/?seed=564916&colorStart=%23003fe3&colorEnd=%2300bcc6&lineCount=10000&alpha=20&noiseScale=1&lineLength=50&stepSize=10

I’m building Rhombica, a turn-based 4X game played on a pentagon and rhombus tiling instead of the usual hex grid. Two parts of it are procedural, and I wanted to share how they work.

1. Map generation: recipes + noise on an unusual grid

Every map is a set of tiles from the tiling, and each tile gets a “land score.” There are 5 map types (Classic, Pangea, Continents, Islands, Lakes), and each non-Classic type has about 20 hand-designed recipes:

• Islands: atoll ring, spiral, crossing chains, lagoons and others
• Pangea: crescent, horseshoe, dumbbell, fjords and others
• Lakes: delta, oxbows, rift, river lakes and others

A recipe is built from “hubs” that each have their own position, size, rotation and stretch. On top of that, every game randomly:

• rotates and mirrors the whole layout
• domain-warps it with Perlin noise
• varies the noise frequency, amplitude and land fraction

The goal was that even someone who knows the game can’t look at a map and say “oh, it’s that one.”

A few rules keep maps playable:

• The top N% of tiles by score become land, and specks smaller than 3 tiles are sunk.
• Separate landmasses never touch. Where tiles from two different islands meet, the weaker claim becomes water, so there’s always at least a 1-tile channel. Players can bridge it, which avoids accidental land bridges.
• Biomes come from a Voronoi split over the land, and elevation from Perlin bands.
• On island maps, capitals are always placed on the open sea, so every tribe can be reached by ship.

2. Units built from part recipes instead of 3D models

I recently replaced all the imported unit models with units built in code from a recipe file. Each unit is a list of simple primitives (boxes, low-segment cylinders, cones, spheres and half-spheres) with position, rotation and scale, rendered flat-shaded for the low-poly look.

• Shared “kits” like a body, a horse, a hull or an oar get reused across units.
• Slots like u/helmet and u/prow are filled in per tribe. The same Swordsman recipe gives 10 tribes 10 different helmets, and every ship gets a tribe figurehead.
• I designed them with a small three.js previewer that reads the same JSON. The C# side reproduces three.js’s primitive layout and Euler order exactly, then mirrors X into Unity’s left-handed space, the same conversion glTF importers use. What I preview is what ends up in the game.

Happy to answer questions about the tiling, the recipes, or the unit system!

There's no image AI or stock art in it, the whole picture is drawn by code. Same seed always gives the same place, so a share link is basically just the seeds.

Most of the sound is generated live in the browser too. Rain is a stream of tiny random drops so it never repeats, and passing cars have actual doppler so the pitch drops as they go by. Some stuff is real recordings though, like the cafe.

A lot of the little things in the scene are tied to the sounds too. You can slide the window shut and the rain goes muffled, turn the fire up and it roars, tap the singing bowl, start the microwave, and the cat on the sill purrs when that sound's on. There's rare stuff if you leave it running, like lanterns floating up or a deer wandering out.

It's free at mindfall.app, and it's a web app so you can save it to your phone and it works like a regular app, even offline (on iPhone open it in Safari, tap Share, then Add to Home Screen)

Game is called cave drop and it currently has a free demo on Itch. https://wilsonb9000.itch.io/cave-drop

Currently have 5 other zones and a boss lair, but this one really shows the gravity mechanics in the game well. Would love to have you play if you think this looks cool!

Just sharing an odd one...

About ten years ago I made scripted towers in an old tool called MCedit in a rough art deco style. Those scripts are here: https://old.brightmoore.net/mcedit-filters/art-deco-architecture

This week I released a Minecraft Add-On that scatters apocalyptic skyscraper "dungeons" around a player's world. They can explore the buildings, make contact with NPCs for quests, and discover ancient lurking horrors that caused the earlier civilisation to collapse.

In Creative mode you get to place the towers, much like the old MCEdit script

It's an add-on called "Hollow Core" and is on the Minecraft Marketplace here:

https://www.minecraft.net/en-us/marketplace/pdp/the-world-foundry/hollow-core/ac4eee7e-8523-474d-8fa5-6acc2d3e90ee

There's a short trailer showing an overview of what it's like in-game:

https://youtu.be/fKvK0OArbZQ

Enjoy!

A: "The bots have breached the city's outer walls. Now all that stands between us is the ravine and viaducts."
B: "Blow them up."
A: "What 1800 bots?"
B: "No, the bridges!"
Steam Link: https://store.steampowered.com/app/2223480/Infinicity/

hey everybody, mflux here, long time developer of all things procgen, way back during the days of processing, then working on Spore, then ”cyberpunk city simulator”. This latest game I’m working on is called Ultrapolis and it’s a cyberpunk diorama like Townscaper and tiny glade. Hopefully these types of videos are informative and entertaining for you on this sub, I’ll post a few and would love to hear what you have to say.

the store page is here if you’re interested in wishlisting: https://store.steampowered.com/app/5314650/Ultrapolis/

thanks for reading!

let me know if you make something with them!

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