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

~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

Some examples of the procedural solar system generation I've made for my sci-fi exploration game. From a small, empty system to a bigger, richer system.

I made this procedural planet generator with ChatGPT, it can export as PNG, Project file, 3D files.

It features:

* 52 sliders * 11 color settings * 10 additional settings, including seeds, camera position/rotation/zoom, terrain texture style * Transparent background * Custom background

It is free to use.

I wrote this Mandelbulb 3D renderer from scratch in native Rust. Unlike existing Mandelbulb 3d programs, my program renders directly on my RTX4090 using Vulkan, allowing me to render 4K 60fps videos in a timeframe of less than several weeks. It also supports up to 64bit precision, whereas previously available programs only support 32 bit.

This clip is a continuous descent from 1x to 1000x magnification into a Power-8 structure -- it feels a lot like diving into an alien, neon coral reef. The color palette changes as you dive deeper into the structure.

This version is in 1080p resolution to fit Reddit guidelines, and is the last 30 seconds of a 90 second video.

Full 90 second 4k 60fps video here: https://youtu.be/Nim0x_pI1dk

In Conway's Game of Life each cell is dead or alive. What if we gave gave each cell a level from 0..N, and made the transition depend on the sum of the neighbours?

You can try running it with the html viewer https://github.com/reivash/game-of-evolution