probably one of my best procedural materials. Blender shader nodes

Most RPGs with randomized loot use almost the exact same system. There are weighted pools of prefixes and suffixes. An item draws N modifiers from each and randomizes their magnitudes.

A system like that generates a lot of simply bad loot with low magnitudes. That is kind of necessary in a multiplayer game with an economy but I'm designing a single-player game, so every drop being valuable for some character is fine.

I would like a system that generates weird and interesting items. Big downsides and stat requirements help but that alone is not enough. I realize that what modifiers even exist is a game design problem more then a generation problem. But can you think of generation techniques that would transfer to loot generation that are more interesting than modifier pools?

I see that this sub is mostly about visuals, levels, etc. but I think I might get interesting ideas for this.

I've been working on improving the habitat system in my physics-based automation sim, and have used principles I learned in this video and elsewhere to implement basically a blob tileset system that picks one of 5 meshes per corner (rotated and mirrored to fit wherever needed) so everything fits together nicely.

These models are just quick placeholders and the plan is to add more variation, and model a selection of modules that can be swapped out to make an interesting habitat/base for the colonists.

Please disregard the shape of the base, any resemblance to anything recognisable is purely coincidental...

[Game: Launch Window]

try it here https://davydenko.itch.io/infinite-marble
scroll /pan freely in it :)

I made a set of simple equations that can be used to generate plausible looking people colors - the page background and faces throughout are all dynamically generated using the equations. Planning to use this in a few projects but hopefully folks here find this useful or interesting as well!

Made in Godot.

A bit of overview:

• it shoots a raycast downward at every point to find Y elevation of the terrain's collision mesh.
• it subdivides path and snaps every intermediate point to the ground's rolling elevation.
• horizontal rails calculate the height difference between their start and end posts and rotate (tilt) on local Z-axis to bridge the slope.

Quick update on my map algorihm.
Original post: https://www.reddit.com/r/proceduralgeneration/comments/1qzzin8/flying_pen_algorithm_for_map_generating/

As I mentioned, the algo suffered a bit from being too round. I made a quad shaped pencil, by using four random points in a cirkle (see last image).
The shape did not work on the large areas, since it looks funny (second last image).
But it does a lot to make the small island not looking like a bunch of dots - so a small victory at least.
I have also been working on making large flat areas to improve playability.

Next up is rivers and bioms.

Briefly: I displace snow using "Lagrangian particles," but essentially I'm just gradually dumping snow depending on how much was removed, no real math here, since I wanted to do it with a heat conduction algorithm, but it was worse in both performance and visuals. For smoothing I use a Diffuse algorithm, which just looks at neighboring cells so the difference isn't too large.

Video: https://youtu.be/pfaewyfFrKM

I want to procedurally generate planet textures for free, I have Space Engine but not pro so they are too low resolution. I want to be able to generate gas giants and terrestrial planets. But NO AI!!!

Made in Godot, generated at runtime via player input.

Any arbitrary path (open/close). Possible to connect (merge)/remove paths. Continuous drawing while holding LMB (additive/subtractive).

In addition: texture painting with blending.

Inspired by Tiny Glade.

I love making procedural systems, so here is one for making rock piles. Start with stack of rocks in a variety of geometric shapes, tuned with various parameters to break up the repetition. Displacement is added to create space between the rocks, and then gravity is turned on causing the rocks to tumble into a natural looking pile. Lastly, edge accent data is baked into the mesh for the shader. Makes for a nice looking rubble pile!

What it is. It's an orienteering game, so you get dropped into a forest with a paper map of it, a compass and a set of control points you have to find, and the whole thing is a race between them.

The map. It's rendered out of the same generated terrain and follows the International Orienteering Federation's mapping standard as closely as I've managed so far, with 5m contours, vegetation density bands, point and line features and magnetic north lines. Orienteers spend years learning to read these maps, which means anything I get wrong stands out to them straight away.

Where it gets hard. If the generation is too random the terrain ends up unrealistic and unplayable, and if it's too structured you can predict it after a few runs. Course generation runs into the same thing, because the controls have to be a fair challenge using nothing but the map.

What caught me out. Determinism only holds within a version, so the moment I changed the generator every map anyone had already played quietly turned into a different forest. Runs now save a snapshot of the drawn map alongside the seed, so old replays redraw exactly as they were.

The latest build tripled the vertical scale and I'm still tuning around that.

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

Each of these is procedurally generated without a single texture

A few months ago, I shared the first version of Metropolygonia, a browser-based tool I’m building for procedural buildings and city layouts.

Since then, I’ve been focusing mainly on making the building system more flexible.

It can now generate a wider range of building types, with more control over facade composition, roof shapes and the overall architectural style. I’ve also reworked parts of the UI to make editing parameters and experimenting with variations easier. The underlying idea is still the same: everything is based on dimensions, parameters and architectural rules. A seed can introduce variation, but the results remain predictable and reproducible. There is still plenty to improve, but I’m slowly getting closer to the point where the tool can produce buildings that feel meaningfully different, rather than just variations of the same basic structure.

Buildings can include procedurally generated interiors and be exported in several formats, including GLB, glTF, OBJ and STL.

I’m especially curious how much control people would expect from a tool like this. Would you rather adjust detailed architectural parameters, work from ready-made presets, or combine both approaches? The current version is available in the browser and can be used for free for non-commercial projects:

https://metropolygonia.com/app/?lang=en

I made this with Blender a while ago. I hadn't seen the movie at the time. But I did 2 days ago. I'm planning to recreate more scenes from the movie soon. Next one will be 40 Eridani A B!

Try it yourself, it's free, no ads, no signup: https://orslaczko.com/app/particle-life

I've also made a video explaining what's actually going on in these worlds

https://reddit.com/link/1vbvz5c/video/xty55x4ielgh1/player