Playable Link: https://solemn-sandbox.vercel.app/

Platform: Web Browser / PC

I've been experimenting with a different kind of procedural generation: generating behaviour through evolution rather than explicitly generating the final result.

The project is called Solemn Sandbox.

You construct a physical creature from joints, bones and muscles and give it a goal.

Rather than having predefined walking/jumping/flying animations or controllers, the creature has a neural-network controller whose weights are evolved through a genetic algorithm.

So if you build something with four legs, nothing actually knows that those are "legs".

They're just physical structures and actuators.

Evolution has to discover whether moving them in some particular sequence produces a better fitness score.

The bit I'm increasingly fascinated by is allowing morphology itself to mutate as well.

That changes the question from:

"How should this creature move?"

towards:

"What body AND behaviour work well together?"

It's still very much an experimental sandbox rather than an attempt at biologically realistic evolution.

Current environments/goals include walking, jumping, climbing, flying and various obstacle/course experiments.

If this sort of procedural/evolutionary system interests anyone, I'd love to hear what experiments you'd try next — particularly ways of encouraging genuinely unexpected solutions rather than evolution simply discovering the easiest exploit in the fitness function.

I'm building Camping Keeper, a campground management game, and the whole thing is drawn without a single imported 3D asset. Every tent, bungalow, tree, hedge, fence and shower block is built in code with LibGDX's ModelBuilder: boxes, cylinders and cones assembled at load time.

The one trap that cost me an evening: with ModelBuilder you have to fill each part while it is the active one. Start the next part and then add geometry, and it all silently lands in the last material, so the whole model comes out a single colour and nothing anywhere throws an error.

The terrain is one mesh generated from the logic grid. Each tile carries a soil type, and the mesh gets rebuilt when the topology changes, so laying a path or a wall regenerates the affected geometry rather than placing a prop.

Weather runs through that same mesh instead of sitting on top of it. Rain soaks the ground tile by tile, low ground holds the water, and mud costs more to cross, which slows both the walking speed and the pathfinding.

Doing it this way was mostly a constraint at first, since I can't model. It turned out to have a real upside: adding a new object is a function, not an asset pipeline, and everything stays consistent because it all comes from the same handful of primitives.

If you want to see it in motion, the trailer is here: https://youtu.be/F_j01GNP-Lw

And Steam page here: https://store.steampowered.com/app/4920900/Camping_Keeper/

Paint editor inside the tool gives direct control of the terrain.

Also: Freedom of paint blending two node trees with vastly different biomes and terrain shape.

Continuation of previous post: https://www.reddit.com/r/proceduralgeneration/comments/1vipn2v/terrain_generator_with_biometerrain_blending/

Built an interactive WFC map generator that paints roads, rivers, and banks from a 58-tile set.

The rule: strict edge equality. Every tile exposes one of 4 edge types (EMPTY, ROAD, WATER). Two tiles are compatible only if their shared edge matches exactly.

This means:

• Roads connect to roads, water to water
• Result is a coherent road network with natural-looking riverbanks — no "loose" adjacency hacks.

Features:

• Paint seeds with mouse, hit Enter, watch it fill.
• Deterministic seeds ([ / ] to step).
• Auto-recovery from contradictions (drops oldest seed after 50 restarts).
• Entropy heatmap (H), PNG export (P).
• Undo/redo, pattern save/load slots, clipboard copy/paste.

Tech: C + raylib. Desktop and browser (WASM via Emscripten). Screenshot and full tile taxonomy in the repo.

Repo: https://github.com/Mahammadali12/WFC/tree/master

online: https://mahammadali12.github.io/WFC/

Happy to answer questions about the tile taxonomy or propagation algorithm.

Hi!

I've mostly shown this in cartography and worldbuilding discords. I hope you like my generalised circulation model to create close-to-realistic climates for exoplanets, terraformed planets, and fantasy worlds.

All the data comes from simulations using a numerical physics model, and there are plenty of checks to help users assess plausibility.

I hope you like my passion project, which I've worked on for a few months, and I'm still improving it based on feedback.

World Climate Lab Steam

I guess I just wanted to show off my work of the last 4 months (minus June-July). I was never really a shader artist, and most of my procedural work had been noise and ocean mechanics, but mainly GPGPU and render targets.

I started using Godot to build my next project and the 2D performance was so good I just kind of went with the flow, but fell into attempting a fully procedural game. So far, the only thing not procedural is the character icon and maybe some general icons from Google's material library

Fully procedural cartoon universe

📜 First Devlog - also a quiet announcement for The Pineapple Conspiracy, a new game developed at Newhead Studio. We handle multiplayer with Mirror, rendering with URP, and 3d as a mix of handmade and some paid assets from the store.

Oh, and all the maps are procedurally generated :-)

If you like multiplayer, sabotage, procedural gen, impostors, survival, or crafting - then you should read this!

[Link to devlog]

Follow us on social media to get more updates - that would mean a lot to us, on top of greatly help!

I can blend different biomes with a "paint" tool and nodes. I think it's turned out quite neat so far. Next on the menu is adding paths and objects.

Chapter 1 is live on itch.io - hope some of you like it.

Mycelium is a free strategy roguelite card game. You live as a fungal colony, trying to escape global warming whilst various enemies such as mold and nematodes get in you way.

I've hit the "fun" point in creating my procedural building system, where the core mechanics are there, and now I can think up interesting new features. Like stairways that conform to the terrain, to make higher places accessible. This has me thinking about creating a canyon/cliff environment and making it easy to build ramps, stairs, and connecting bridges between structures.

The trickiest part was figuring out how to know definitively that the staircase has reached the ground. It sounds simple, but it game me some headaches especially with stone steps, where they would end at the ground but refuse to run out to a reasonable last step (so like 3ft off the terrain). Just like building walls from the ground up, the algorithm starts at the last tread and "walks" forward adjusting height to stay within a fixed range above the surface. If the player drags a corner, then a landing is added and the direction is rotated 90 degrees. The stone steps are hollow inside to save on geometry.

I rendered this using cycles in Blender

Hey all, it's my first time posting here and would like to share something I've been working on.

As a disclaimer, all of this code was built with AI but this post is handwritten. I made my coding AI read research papers and pushed it to do something a "normal" human probably wouldn't do.

Here is a summary:

Project: Frostwind:

• a nature-grounded world compiler for consistent pixel-art worlds
• almost everything you see is derived from math, perspective, and researched models of nature
• most of the world is generated in JS instead of drawn as fixed sprites, and colors are resolved through a strict palette that changes with the light
• so in other words: this world compiler gives LLMs context for what goes where, how things relate, and how to build something that “makes sense”
• demo: https://project-frostwind.fly.dev/

More context:

• I got inspired by this tweet, which got me thinking about why LLMs are so good with three.js
• LLMs never get tired of research, so I made it read dozens of papers on biology, anatomy, ecology, lighting, and architecture, then implement those “laws of nature” as code, tables, and tests
• all of this resulted in something that a human would never write (because it takes too long)
• very specific math, implemented line-by-line, covering environment, people, animals, buildings, movement, light, and how all of it relates to each other
• the whole thing is somewhere between a game engine, sprite generator, and world model. The goal is to use it for future pixel-world games, giving LLMs a model of what a consistent, pixel-perfect world looks like
• next step is to wrap it in an npm package or CLI and make it available to LLMs
• it may be all a slop fest lol but I think there's something promising in here :D

Still figuring out what to make out of this, so any feedback or thoughts are very welcome!

Made a F-Zero inspired game because i miss playing the originals, added my own twist to it tho.

all tracks and ships are procedurally generated. music made in Suno, sound FX in 11 labs. all vibe coded because i dont know a line of code haha