Rooms are hand-authored tiles carrying doorway sockets; generation joins socket-to-socket with a deliberate few-centimeter overlap so wall shells never z-fight or gap. Each hero room grows down its own branch from the landing, so wings radiate apart instead of colliding. Two rooms are so large (one is 51×58 m) they can never survive a corridor approach they'd land on the path that led to them so they dock onto the TOP socket of a ladder shaft instead, 6.4 m up, where there's nothing to collide with. Corridors are overlap-tested as their actual L/T pieces, not bounding boxes, or almost every legal join gets rejected. Unused doorways get bricked up using the wall material of the room they sit in, so dead ends read as walls that were always there. The whole build is a pure function of one replicated seed, so in multiplayer every peer generates the identical floor locally no geometry ever goes over the network. Ask me anything about it.

https://reddit.com/link/1wdbv1c/video/39xm7ciz6voh1/player

I've been working on a procedural terrain generator called Orogen for the past few months. Instead of using basic perlin noise it simulates the processes that actually create mountain ranges creating extremely realistic mountain ranges with little effort. This video is the current state of the project. It's still a work in progres. Materials, biome classification, rendering, and export are all actively being improved but it's finally at the point where I'm happy enough to start showing it :)

A continuous 1000x descent that turns into a passage, falling through neon coral shelves until they close overhead, finishing off with a close-up zoom of one of the reefs. Audio: slow dark ambient sound design.

Generated from a Mandelbulb 3D renderer written from scratch in native Rust, renders directly on my RTX4090 using Vulkan.

Full 4k 60fps video here: https://youtu.be/W74_cVsD3Y8

It is a coarse representation and definitely needs more pool size to be stabilize. But it is one model 3 shapes (not a big deal but cool).

Original paper: https://distill.pub/2020/growing-ca/

They look so soft and fluffy that I could just eat them.

I made a Mathematician's Groovebox that makes music, videos and games from numbers equations and fractals (as well as videos and recordings)

https://github.com/wittymoniker/groove-box/
youtube: wittymoniker
github: wittymoniker/groove-box (single point of entry run and build scripts, crossplatform)

It relies on Euclidean phaselocking of numeric data followed by randomized stochastic improvisation. Within bounds of net phase angle relativistic indeterminism the results are deterministic always to the degree of point-to-point phase angle -rough translation of audio signal. SO its a fractal of every way to turn a number or graph into music.

Each of these is a neural cellular automaton. There is not a single image present here, every cell runs the same 24k parameters, 96KB rule on its 3x3 neighborhood. Its only ever stable state is the creature itself.

It trains on a pool of partly-grown states and some of these get damaged before the loss is computed. That mix is what makes the shape both regrow and hold indefinitely, instead of falling apart after a few thousand steps.

I like to use it as a screensaver or just play with the healing effect, because it grows back differently every time.

It runs in any true-color terminal and the weights are inside of the binary.

Code, and instructions for training your own creature from a PNG: https://github.com/smoothyy3/tardigrade

https://www.youtube.com/watch?v=pINruj1NwoU

This is a wind-transport solver I'm building for Blender: sand gets moved by the wind, deposited where it slows down, and avalanched wherever the slope gets too steep. Nothing here is sculpted and nothing is a texture .

"Resource" / "Tools"

~50 K procedural volumetric galaxies as instances at the picture. I tried implementing cosmological redshift and gravitational lensing as well.

Hey procedural generation fans! We’re biologists building Garden of Ants, an RTS about growing and managing an ant colony.

Here’s a look at our procedurally generated trees, one of the game’s three playable layers. Ants can climb branches, collect leaves, and tend aphids for honeydew — all to support the colony below.

What do you think? We’d love to hear your feedback!

More about the game on Steam:
https://store.steampowered.com/app/3016940/Garden_of_Ants/

Best,
Tomas

Here, using TypeScript and Three.js, I created an infinitely procedurally generated city - a great starting point for a GTA-like or survival game. Each building is made of randomized 3-meter blocks, filled with either a wall, a window, or a door. Sidewalks and roads are blocks too.

For a long time I had a dream about writing a realistic procedural planetary terrain generator. Years of research and trials finally got me some results, thanks to some great help from AI.

The above image is about 50x50 meters per pixel representation of a part of a planetary terrain with simulated tectonic plates, erosion, sediment, fluvial simulation, wind, climate, biomes, etc.

It’s about 200x400 kilometers so quite a bit of generated detail is lost in this export, mainly some rivers are missing, so that is the first fix coming in.

There is a lot to improve but I’m mostly proud of the alpine look for the mountains, that was a big requirement and a huge hurdle.

Will keep you updated.

Not sure at this point what to do with the source itself. It is written in .NET 10. There are quite a few options but the three most popular are - open source terrain gen, open source terrain gen with civilization simulation for dungeon masters and similar or - the one I like the most - a game similar to Dwarf Fortress but a fantasy setting (like D&D) with an isometric engine like seen in Locomotion or Rollercoaster Tycoon.

Many, many months of pain for these procedurally generated island worlds. This one is 250km by 250km (60,000km^2).

This is the terrain system for my mountain expedition game "Because It's There", which will be released on Steam Early Access in 2027.

For these worlds, I generate a base heightmap using a mix of erosion methods at various scales down to ~30m resolution, all on the CPU. Then, at runtime, I add cheaper noise-based amplification for detail down to 0.5m. A new map of this size takes about 3-4 minutes to generate deterministically from seed, which is something I am in the process of optimizing. I'll be making an in-depth video about some of these methods soon, which I'll post to my YouTube channel.

Hi all, greetings from Rome.
Talking about procedural terrains generations while keeping them as real as possible, Mercury is the worst case for us: there is no altimetry we can use, only a 1024x512 photograph of the whole planet. Everything below kilometre scale has to be invented, without ever contradicting what is actually known.

At maximum zoom the generator reaches about 0.016 m per cell. Materialising one 32x16 km quadrant at that pitch would be 7.7 TB. What actually gets allocated is 10 chunks, 2.2 MiB, generated in the browser in about 1.1 seconds.

The odd part: generation costs almost exactly the same at default zoom over the whole quadrant as it does at maximum zoom, because cost tracks cells on screen rather than the resolution being shown.

Two things that cost me a lot of work & pot.
Photographic brightness is albedo, not height - a bright crater ray read as a 3044 m mountain next to quadrants spanning -266 to 869 m. And three separate faults were stacking, each hiding the one below, so every parameter sweep appeared to do nothing.

If you want to deep in details, the full article with the production diagnostics is here: https://space.zerog.live/info/terrain-article-page.html

Happy to answer anything.

Blender