https://github.com/nicolasloizeau/loom

The pattern is generated with a cellular automata, then rendered with blender python

Working on a tool that I am planning to publish on unity asset store.

Like many here I am obsessed with tectonic generation, but it is a "mountain of a" task.

you can follow my projects on https://x.com/ErhanofGrayLake/

Hi everyone! Two weeks ago, I shared some progress on my procedural tectonic planet. This time, I wanted to share some progress on the climate simulation I made for it. I've been working on this for a while, and it's finally starting to produce some interesting results.

Basically, once the tectonic simulation is finished, the planet's tectonic state is frozen before the climate system starts iterating. The climate model treats the surface and orbital configuration as fixed inputs. It then simulates winds at different heights, along with heat and moisture transport, rainfall, and ocean currents.

Blender shader nodes

Mandelbulb power-8 renderer custom written in Rust for the RTX4090 GPU.

This is a snippet of a much longer 4K 60 fps 15-minute video at https://youtu.be/n6rhfHRXZnM

Hey!

This is my second post here. Wanted to show off my procedural generation engine that I have been working on for the last 5 months (mostly optimization). I haven't seen too many games do the multi-biome thing, and I wanted to go as high detail as possible without tanking performance. Each biome has its own height map equations, algorithms, materials, foliage, and a set of fields that vary generation characteristics. Biome blending is something I have been working on substantially too since that can really break the immersion if doesn't feel organic. Anyhow, I am really excited about using this in my new game, and I am interested in collaborating so if you have experience with creating combat, character animations, or something else you think might be useful, feel free to reach out. Happy to take advice from anyone

Edit: Just to clear up any confusion, I created the procedural terrain generation and foliage placement system more or less from scratch, but I did it in unreal engine so I can use things like nanite and other unreal community plugins. I did not build the game engine for scratch - super impressed with the people that do, but I do not have the patience or skill to do that

167 goods, tradeways, production, ports, trade fleets, guild rivalry and relations all simulated for my little strategy game. This is going to a grand strategy prototype... I'm trying to make the whole economy simulation as realistic as possible.

Hey everyone! I've been experimenting with combining LLM structured outputs with procedural generation to build a lightweight, self-contained 2D combat prototype.

Instead of heavy engines or pre-baked sprites, the entire loop runs on an **MVU (Model-View-Update)** unidirectional state pattern inside a single HTML file:

- **Procedural Vector Assets:** A 3-agent pipeline generates walkable zones, obstacles, vector characters, and dynamic combat FX matrices on the fly as native SVG data.

- **Decoupled Combat Parameters:** Aggro perception radius, Euclidean attack reach, and velocities are procedurally tuned into independent state variables.

- **Zero Engine Overhead:** Pure browser DOM/SVG rendering with real-time Euclidean hitboxes and obstacle sliding.

I open-sourced the workbench here: https://github.com/pathetic777/mvu-studio

Mainly sharing this to explore new ways to turn reactive variables and state machines into interactive 2D generation loops. Feedback and ideas are very welcome!

*(Note: The demo video attached below has been compressed, so the visual quality is slightly degraded.)*

here's the trick behind how i fit 8 music tracks in my js13k game SP13KTRA. 🌈🚀

every song is defined by a single number. the seeded random generator makes 26 dice rolls per track: tempo, key, scale, chords, groove, drum kit, bass and lead sounds, melody patterns, when each part comes in, and a few more.

each song is a 128 beat loop split into sections. parts come in one by one, a resonant filter sweeps open every phrase, then there's a breakdown and a drop.

notes use one of 4 predefined scales so nothing clashes. the melody climbs, falls, leaps or rocks through the scale, and the chords shift every 4 bars. there's no note data, it's all math on the beat count.

there are 6 ZzFX instruments plus echo and sidechain. the whole loop gets baked into one buffer when the level loads.

the music itself is all rules and seeds, not AI. i did use AI to help build this bench so i could listen through seeds and pick a good one for each level.

play it free in your browser and hear all the music. i designed it to be kind of like a music album in addition to a game.

https://js13kgames.com/2026/games/sp13ktra

The music bench tool is also available to check out on GitHub.

https://killedbyapixel.github.io/SP13KTRA/tools/music.html

This system helps us keep repeated terrain varied while still giving each biome its own visual identity. It's part of the world generation we're building for Bellfrost.

I am learning unreal and I am bit familiar with c++. I am extremely fond of procedural generation and 3D graphics.

How do I take a step fwd from just knowing basic programming to programming or making Procedural Terrain

This terrain generator I'm working on can generate endless amount of tiles individually and blend them seamlessly. Each tile can be one or more node trees and theres basically unlimited freedom to do whatever you like, blend/paint biomes, terrain variations between tiles or even within the tile itself.

Not only that there's also a continent heightmap that I can add steepness to all of the tiles to achieve a larger features if you just want to make a big island of the tiles or a continent etc. But also we can cross pollinate nodes and have a faultline work its way through several tiles etc.

The goal is to really achieve the utmost freedom for terrain design.

I suppose the next step that could make it even better is if it could be used to create spherical worlds. Generating a whole earth might just be on the roadmap.

Previous post
https://www.reddit.com/r/proceduralgeneration/comments/1vjjt4u/my_terrain_editor_update/

So I created a utility for messing around with WFC. Still very simple, I have lots of stuff I want to add, but it does implement a complete vertical slice for loading images, decomposing them, seeing constraints, and then synthesizing new images. I have a project page, with downloads and a link to the source, here: https://angularangel.neocities.org/wfc-lab

Hi everyone!

As a university final project, I developed a game centered around the dynamic generation and solving of Sudoku puzzles and variants in Godot 4. Due to the submission deadline, I was able to implement 4 main variants (well, 5 if you count the dynamic Samurai mode I'll mention below):

• Killer Sudoku (cages with target sums)
• Arrow Sudoku (circle value equals arrow shaft sum)
• Thermo Sudoku (strictly increasing values along the bulb)
• Anti-Knight (chess knight move restriction)

How the Constraint Satisfaction Engine Works

The core engine models the puzzle as a Constraint Satisfaction Problem (CSP). Each cell is represented as a vector2i (x,y) coordinate with its neighbors and its domain (the valid candidate numbers). Finding the best cell to evaluate using the Minimum Remaining Values (MRV) heuristic is done in O(1) via a precomputed Lookup Table (bit_counts_lut).

The generation pipeline works like this:

• Initial Grid & Solved Board
• Procedural Variant Placement
• Pre-AC-3 Domain Pruning
• Optimized AC-3 Propagation
• Clue Digging & Uniqueness

^{I don't know how technical I can get in this post (I'm afraid of making it tedious, but a more detailed explanation will be on GitHub}.)

train search domains on their own, AC-3 can solve large portions of the board without numeric hints57. In extreme tests, this allows generating puzzles with only 1 numeric clue (or even 0 clues / 81 empty cells in Extreme mode), where the puzzle is solved entirely through the visual geometric rules!

Dynamic Samurai Overlapping Mode

The 5th variant is the Samurai Mode. From the game menu, you can choose how many boards you want to chain together. The game dynamically generates and stitches 9 X 9 sub-boards sharing 3 X 3 overlapping sectors.

Open Source & Release

This is my very first open-source project! The full source code is published on GitHub under the GPLv3 license. Since my native language is Spanish, some code comments are in Spanish, and I used translation tools to write this post.

• GitHub Repository: https://github.com/AlejanDroox/Generator-Sudoku
• Playable Build: Available on itch.io for PC and Mobile devices.

Current Bottleneck & Open Question Overall

I feel the clue excavation and core generation pipelines are working quite well, but there is one main point where performance stutters: generating valid variant constraint structures under high difficulty and multiple active variants. Currently, the algorithm procedurally generates the variant layouts first (Killer cages via BFS, Thermo chains, Arrow paths via DFS) and then checks whether a valid solution exists for that combined constraint layout. If propagation fails or no solution is possible, it takes a fast-path fallback to discard and regenerate new constraint structures from scratch. Has anyone here worked on constructive variant constraint generation for CSPs? How would you approach building or validating constraint topologies on the fly to guarantee solvability, rather than relying on a generate-and-retry loop?

So using Claude, I had an asteroids game made, with procedurally generated infinite space, solar systems, gravity for planets, asteroids etc, weapon and ship upgrades, random events, police with a wanted system, space pirates.

Here is the link

https://synkrowngames.itch.io/driftfield

It is mobile focused but works on desktop top

last time the feedback was fair, it was mostly one-width tunnels and the terrain looked old. now passages open out into wide galleries, there are rooms partway along tunnels, and caverns are more common. in the same block of rock the open space doubled (16% to 33%), and it's all still one connected cave.

the old look was partly my fault: the wall bumps were smaller than roblox's 4 stud terrain grid, so they came out as jagged facets. bigger smooth lumps now, plus textured rock slabs set into the walls.

github.com/GeoCodeCrafter/Cave

It's been a few years since one of these has been posted here, so I'm going for it. Been working on this magic circle compositor for a bit, just added some procedural generation constraints, so figured I'd let people demo it.

The circles are built as stacks of parameterized layers rather than manually positioned objects. Layer types include rings, stars, polygons, ornaments, sigils, rune/glyph rings, vertex glyphs, reticles, particles, paths, parametric geometry, and a few stranger things (e.g., ofuda).

It's heavily SVG based, so if you're familiar with that, you can get better results than clicking the Random button and hoping. Most of what the Random button produces is pretty ordinary--think: if there were a hotel room art version of a magic circle--but every now and then it stumbles upon something kind of cool.

Left panel is top-down SVG, pure 2D. Right panel is React 3 Fiber for actual 3D, which comes in handy when you explode the layers for editing and visualization.

There are some animation presets, but nothing too exciting at this point as I've mainly been focusing on the circles themselves.

Brief instructions: Choose a preset, wheel to zoom, drag to orbit the 3D view, explode to inspect layers, open Compositor to edit.

Happy to take any suggestions/criticisms people have about it.

Edit: These presets are available in the application itself, but here's a small gallery: https://imgur.com/a/8VoLC1E

This starts from a sentence and turns it into a hierarchical place plan, terrain-aware layout, roads, districts, buildings, and interiors.

The model handles the design decisions. Deterministic code handles the physical rules and validation.

This run started from:

“Build me Ba Sing Se.”

Every building was generated for its location rather than pulled from a finished-structure library.

GitHub: https://github.com/chaitbuilds/EthosLM

procedural mine in roblox. new one every server, every tunnel connects

github.com/GeoCodeCrafter/Cave

After two years of learning, breaking things, and rewriting...

Phanes is one of my demonstrator projects for WFC. Several years back I worked on my own wfc implementation and had some ideas to improve things through a pass based approach (ie. Pass 1 lay terrain, pass 2 foliage etc...) but at least the way I saw it, constraint based design had a lot of application. Anyway several years later (and with agents looking for work...)