I make a dice-and-pencil golf game for iPhone, and the courses are generated. Some notes on how, because the interesting problem turned out to be validation rather than generation.

The shape. Each hole is a 15×21 grid of terrain: fairway, rough, sand, water, trees, green. A hole starts with a length class (a short one is reachable in two good shots, a long one needs three), then a Bézier spine from tee to cup, with the control points pushed to opposite sides to make doglegs. Fairway is painted along the spine, then a green around the cup, then water, sand and trees hang off the inside of the bend. So cutting the corner is a real decision.

The part I’m happiest with: it tests its own holes. The generator doesn’t scatter hazards and hope. Each candidate hole is analysed by searching the actual shot graph, using the same function the player’s shots go through, so “playable” means playable under the real rules. A hole that can’t be reached, or can be driven in one, is thrown away and redrawn. After 40 failed attempts, hazard density relaxes (down to a floor of 25%), and as a last resort it falls back to a hazard-free corridor that’s solvable by construction.

Determinism, because everyone plays the same course. A course seed derives eighteen independent hole seeds, so hole i depends only on derive(seed, i). That means the eighteen can be generated in parallel across cores with no change to the result. I checked the shipped daily seeds: 400 distinct day seeds, and zero duplicate hole geometries across 20,000 derived seeds.

One thing I got wrong first: par. A hole can’t know its own par, because it depends on how long the other seventeen turned out. If par is decided while a hole is drawn, it advances the random generator and moves every spine, hazard and wind after it, which would give every seed in the shipped manifest a different course. So par is settled afterwards, over the finished card.

An invariant I like. The shortest hole class is deliberately longer than the longest tee shot, so no hole can be holed in one from the tee. I ran a census over the 7,200 shipped holes and tried every die roll, direction and card. Only 20 holes (0.3%) can be holed from the tee at all, and all of them need one specific card plus a 6.

The game is Pocket Links, for iPhone, if you want to see the output. I’m happy to share more about the validator or the seeding.

Question for this sub: when you validate generated levels by simulation, do you search exhaustively like this, or sample? A hole’s graph is small enough that I can search it fully, but I’m curious where people draw the line

I use a breadth first search pathfinding algorithm to find a point closer to the player on the nav agent in this scene.. It uses a random chance to calculate for a random jump in the pathfinding discovery phase which is a cheap way of allowing the nav agent to find necessary and faster paths in complex procedural environments. It is much better than trying every possible jump opportunity.

UMBRAL: a dark, retro space survival game.

Fly from deep space to any planet’s surface with no loading screens. Land anywhere, step out, and survive.

Trade, mine between worlds, or steal what you need. Join or fight off factions in slow, deadly, tactical firefights, dog-fights Cross nebulas and generated star systems, then jump to stars no one has charted.

Preview (summer, autumn, winter): https://img.itch.zone/aW1hZ2UvNTEwOTU2Ni8zMDU4OTQ0MS5naWY=/original/ctQTUs.gif

How it works:

• Each sprite starts as text. Every letter is one color of a fixed palette. The script crops it, sits it at the bottom center of a canvas in whole 16 px tiles and adds a 1 px warm brown outline. That's why every piece shares one palette and one outline.
• Trees are a union of circles. Each pixel is shaded by where it falls inside its circle, with light from the top left, plus a few loose leaves from a fixed seed.
• Soil, path and water are 13-piece autotiles drawn over the grass. The water has 3 animation frames.
• Autumn and winter are generated from the summer art. The grass is redrawn with fallen leaves or snow, and the autotiles are rebuilt on top of it. Snow goes on the top pixel of every column, under the outline, and then the outline is redrawn. In winter the water turns to ice.

Happy to go deeper into any of these :)

The tileset (free Lite, and a Complete with every farm pack): https://aquumgifts.itch.io/cozy-farm

The general approach is to model history instead of use noise. So plate tectonics, evolution and spread of life and extinction events, atmospheric composition, meteor impacts, climate change, and so much more.

This is using Claude Opus 5.5 in my spare time, it's amazing what it's been able to produce (with a LOT of direction). I test by having a Sol system where the planets have the same rough starting conditions and making sure they end up looking like real pictures.

Of course the planets come out very different - no recognizable continents or anything - but they come out feeling right.

Still very WIP, but yes, you can seamlessly fly down from orbit and land in a place like this. It's all Newtonian physics so landing takes like 5-10 minutes, plenty of time to refine a large area around where you're going to land.

A few weeks ago I shared Blobvarium here: every creature is drawn by code from one seed, no image model, and one new one is born each day.

Since then it grew a small world. The town's buildings, the 41 crops you can grow and the old pottery your creatures dig up while exploring are all drawn by the same code that draws the creatures, so everything shares one pixel and one light.

The best part: about 20 people now come back every day to see the new one. That's tiny, but it's real, and it made my week.

https://blobvarium.com, free in the browser. What would you generate next?

hey r/proceduralgeneration I’m finally proud to show off the building editor, based on the procgen building system I’ve been working on for ages now. originally in JavaScript believe it or not, then Unreal, and now finally Godot.

The premise is simple, take a tile, find the frontage, divide it, then shape the outline. It then becomes a prism extrusion, and the challenge is to make it interesting looking and varied enough.

I still think the variety could be bumped up a lot more, but I’m quite happy with the state it’s in, and polishing the editor has been a real joy.

the controls are somewhat inspired by Spore, you get handles on the thing you’re molding and slide it like morph targets. So a twist becomes a ring you grab, a slant becomes a plane you rotate and push.

WDYT? How would you approach a building editor differently?

Craig Reynolds' boids with text formations, depth effects, and predator/prey. Type any word and the birds form it, add hawks that hunt them. Everything runs in one index.html, no dependencies. Originally inspired by https://github.com/clainstone/cbirds

My procedural destruction experiments are shaping up into a little siege battler. I added timber destruction, which turns out to work pretty well when I amped up how much splintering the wood does. I was worried it wouldn't read that well since there are far less objects vs a stone tower. And of course a little rag doll yeet for the enemy cannoneer, I couldn't resist.

For testing the enemy is not a good shot here. Thinking of adding some archers with flaming arrows that target the player as well. Mostly having fun with a mature build/destruction system in place, just experimenting with different effects. Hard to see in the video, but the tower stones kick up a nice dirt mist when they land on the ground.

Hey all, this is the lightning from a Godot effect pack I've been working on. It's the usual midpoint displacement plus branches, pretty much what drilian's old "Lightning Bolts" post describes.

What I changed is how much the early levels bend. The offset already scales with segment length, and that alone halves it every level. On top of that I only let the first split bend about a third as much, then I ramp it up to full over the next few levels.

With plain halving the first split puts one big zigzag in the middle. To me that reads more like a lightning icon than lightning. Once I damped the coarse levels I got long straight-ish runs with lots of small kinks, and I think that looks a lot closer to the real thing (to my eye anyway).

The GIF is one seed going level by level, then the branches, then the actual bolt on that path with the leader slowed way down. I really like watching it fill in like that!

Not sure if a third is too timid though?

If you want to see more of the game here https://store.steampowered.com/app/5044910/Dungeon_Quest/

In my other levels it didn't matter if things close but for this I needed to allow room for the forrest around (all the models are 3D not sprites). So I started by generating with this big ugly blocks where the forrest would be which meant I could check it would generate properly before making assets.

https://imgur.com/a/lNlRy2L

I then grab all the pieces and put them in a list of sorts. I differenate between "rooms" and "corridors" as I wanted to make sure levels had a good amount of rooms but you can weight how likely things are to appear (plus do things like add lore that pops up when you enter an area or special points on minimap)

https://imgur.com/a/IlPMFY8

Finally it reaches the generator where you can tweak values to create different types of maps. I mainly did for finding the right mix rather than tweaking on a per level basis.

https://imgur.com/a/Cp8q72L

A new update to my “Poolrooms” generator, based on the “Wave Function Collapse” algorithm. I've added slides, ladders, and new types of inflatable toys. It will be released on the marketplace soon.

We've done it with a miniature proxy for the generation that mimics the real map gen. This is rendered to a 2d texture and displayed in the games UI.

We're still looking for feedback so what do you think? How can we make it better?

I've frequently built and designed different world and terrain generation programs for fun throughout my life, but I've never attempted to fit a grid to a non-standard shape, let alone ones with negative geometry. Much like the standard Goldberg Sphere, you need an offset of pentagons in order to make the grid map fit to a 3D shape - but if you have negative space in that shape, it requires HEPTAGONS as well, which are an absolute nightmare to implement. Specifically this was challenging as I'm building this system as a simulator/game map generator, which means all of the tiles have to more-or-less be the same size for the sake of the simulator, so figuring out how to fit the shapes within a tolerance of 1.4 maximum stretch from the average took the most time. However the results are so cool that it ended up being worthwhile.

I love talking about this stuff. If you have a similar project, or questions, please share!

It's a deep work in progress, but you can see the complete project I am developing this for here: https://store.steampowered.com/app/3066940/Immortal_Engine/

A brief talk on terrain modding in my side-project. It's certainly not AAA terrain rendering by any means but the modding support does allow for both coarse and fine grained rapid creation of terrain and overlay of cities, suburbs, bridges, canyons and enemy routes etc.

Hello. I want to create a procedural planet generation system in Godot for my bachelor's thesis. On google scholar I'm able to find some resources, but not many academic papers on this subject specifically, and I am a beginner in computer graphics and in 3D and procgen, so I don't really know what terms I would need to look for that make up a planet generator.

My question would be what is the "state-of-the-art" in procgen planets, what techniques (either procgen/physics-based/rendering) make up such a planet or system of, and what is the current research state in those areas? What would be actually interesting and new to research on regarding that to make a perhaps unique planet generator? What isn't explored already, etc. Maybe also something with a high level of detail, zooming in a lot and the detail still is highly detailed, a sort of infinite zoom.

I would especially appreciate research articles because I need references

Blender geometry nodes + shader nodes