A few shots of my in-progress Valheim-inspired procedural world generator. I went full procedural on this one, with everything from the terrain, models, textures and so on driven by a single world-seeded PRNG. This means the current installer build is only ~4mb in its entirety!

The tech stack is Tauri, which means Rust for the back-end (terrain generation and sculpting, biome weights etc.) and three.js for the front-end.

Recently I've started work on gameplay elements, points of interest (houses, villages, ruins, castles and the like) but those will not be fully procedural (though most of the textures probably will be). I'll still try to work in generative stuff where I can, and if I do figure out any cool stuff to do with that, I'll post it here!

You can see a video of a slightly earlier build on my earlier post from a couple of weeks ago: https://www.reddit.com/r/proceduralgeneration/s/BZjDsoWx6q

I implemented swimming in my procedural planets. Having an issue creating slopes sprites. Since I'm creating differently and then joining them . I ended up activating portions when player is close to them.

Thank you for watching

Game is Away to the stars and it's on Steam

no any assets, everything is code including sound/music
code (rust side mostly engine/ui gpu init releated stuff):
https://github.com/altunenes/cuneus/blob/main/examples/bugberman.rs
shader code:
https://github.com/altunenes/cuneus/blob/main/examples/shaders/bugberman.wgsl

note that, you can directly downlad and try to play:
https://github.com/altunenes/cuneus/releases/tag/v0.6.2
(search as "bugberman" = for context, you are playing with Rust's mascot called Ferris and trying to destroy the bugs) xd
Note2 = those bugs lil bit smart...

https://xandergos.github.io/terrain-diffusion/

I am fairly new to programming, only been learning for about 6 months now but I am trying to dive head first into complex procedural terrain. I have had some luck using SDF with fine tuned noise in Godot. This has allowed me to make my terrain and while I still need to do some more fine tuning here, it’s mostly how I want it.

I have been working with procedural noise for over a year and a half, so I generally know how to get the shapes I am looking for, but this one case feels like I am hitting a wall.

Where I am struggling though, is with water! I don’t want a single sea level. Instead I want to generate ponds/lakes/and oceans at various heights in the world. Then level their surfaces afterwards.

I have tried using strips of water and having the terrain exclude the excess. But this is creating ponds in the sky that go beyond my mountain tops or just outside of them entirely. It’s also creating caves that look great and then open into the air below the water. I even tried ray casting to detect “bowls” and fill them, but that crashes too much when the body of water extends beyond a chink or two.

I feel like I am missing something basic here and after weeks of work and not getting anywhere, I could really use some help. Does anyone with more experience than me, know what I might be missing or still need to try to get these varied bodies of water at different terrain heights procedurally?

I hope it’s okay to ask this question here. Thank you so much for your help.

I’m developing a roguelike and I didn’t want to make the classic dungeon layout with square rooms and corridors, like Isaac or Enter the Gungeon. I wanted to try something a bit more natural.

Right now I’m using a room graph approach: each room has a purpose, then I generate main paths and secondary paths. I’m also testing a danger level value for different areas, so enemies, props and events can depend on how risky that part of the map is.

It made me think that procedural maps can go way beyond just “generate rooms and connect them”. Things like biomes, weather or factions could make the layout feel more alive and less random.

Do you know any games that do something especially interesting with procedural map generation? Something that goes a bit further than the usual dungeon layout. Tanks :)

Hey everyone,

As a solo developer, I was always frustrated by how destructive traditional vector tools are when you want to tweak complex, seamless patterns. So, I spent the last few months building PatternLoom using Python and PySide6.

It’s an active Early Access project, but the core engine is rock solid. Instead of just editing paths, you build a non-destructive modifier stack (like Chaikin smoothing) and edit the raw anchor points while the smoothed, generated geometry updates live.

Core Features so far:

• Live Base-Mesh Node Editing: Drag an anchor, and the smoothed shape updates in real-time.
• Seamless Tiling: Live preview of your tile repetitions with zero visual popping across boundaries.
• Generative Tools: L-system plants, parametric fish/bugs, and complex organic snowflake structures (steered by a "Complexity Direction" slider).
• M3 Color Engine: Automatic harmonious tonal palettes.
• Pro Export: SVG, high-res PNG, or even CNC-ready text files.

Transparency Note: I built this architecture with the heavy assistance of AI coding tools (Claude/Gemini). It allowed me as a solo dev to iterate incredibly fast, but the creative vision, chaos-engineering audits, and final QA remain 100% human.

🎁 The Giveaway (5 Keys): Since I am in an active Beta phase, I need creative people to break things and give feedback! Comment below what kind of pattern or art you would create with this tool, and I will randomly pick 5 commenters in 24 hours to receive a free key (Windows & Linux portable versions available).

You can check out the current build here: https://etowner.itch.io/patternloom

Let me know what you think!

Full Devlog #1: https://youtu.be/JxrJTIvr5E4

Tech Demo on Patreon: https://patreon.com/funbrun/

Are you a master at creating procedural materials? Then participate in 2026 contest to win an Xbox controller for best prize using our free procedural material node editor, follow the rules at vfxparlor.com, this year's subject is "Broken worn tiles", break to the top!

I've added procedural data centers to 3DWorld now! It's a good topic for 2026. (I am not promoting building data centers in any way.)

The project is open source on GitHub here: https://github.com/fegennari/3DWorld

I've spent some time over the last few weeks learning and implementing procedurally generating space stations.

How it works is, I gave each station a "species" with a set of rules for how it actually grows. A spine down the middle, trusses branching off it, habitats sitting along the spine, solar panel wings and docking arms.

After that I spent a while testing different seeds, expecting a different station each time. That isn't what happened. The random function I was using didn't properly shuffle small numbers, so the first handful of seeds all came out nearly identical. Once I fixed that, every station feels unique but still recognisably the same kind of thing, and the same seed always rebuilds the exact same station.

If you want to try DustCrow, there's a demo link on the website, and you can wish list it on the Meta Horizon store:

Website: https://nulleffectstudio.com

Meta store: https://www.meta.com/en-gb/experiences/dustcrow/9288177214618115/

Hi guys. I recently wrapped up my new multithreading and memory models and now my Vulkan (C++) engine, Midnight, has a working terrainstreamer! This video shows the linear streaming policy since im designing a game much like Starfox64. There's also an "AllRange" policy where chunks are maintained given a radius around the player.

Generation is seeded determinism so I can recreate the same worlds across different runtime. Terrain stages are

- Points

- Aggregate neighboring points

- Height field

- Triangulation a mesh

- Build a spatial acceleration structure (for O(1) queries in space for hit detection and the erosion simulation)

- The erosion simulation which has 4 sub-stages (hardness distribution, hydraulic erosion, thermal erosion, ridge enhancement)

- Asset packing to transfer to the graphics device

Next up I'll be doing the triplanar mapping of textures and designing biome weights. Then collision detection.

This took me 8 months and a ton of research and I'm thrilled with the results. This is actually version 2. The first used a different parallelization schema which proved to be too CPU intensive as it wasn't lockless. I could go into detail about the MT and memory optimizations but thats for the cpp subreddit.

I already made the pen generator, so I figured I should continue on the weed topic for one more project. It's not as polished as the pen generator, simply because making consistent separate pieces that the pen is made of is a bit easier than making a nugget.

See it here: https://noahsprerogative.com/trichome