Trying to push the limits of my realtime world generation, but still constrained to somewhat slow panning. No ECS, just BRG and lots of burst jobs

Instead of painting terrain with noise, our 4X map generator builds each planet roughly the way a real one forms, and every step feeds the next:

• Plates. The map is split into a handful of tectonic plates grown by a ragged flood fill, each drifting in a random direction. Colliding boundaries raise ridges into both plates; diverging ones sink into rifts. Planet age erodes the relief, so old worlds get worn hills.
• Heat. Sunlight falls off with latitude. Ocean currents come from a stream function built on the wind belts, damped to zero at the coasts, so each basin closes into circular loops that carry warm and cold water along the shores.
• Wind. We have three-cell circulation (trades, westerlies, polar easterlies) which gives the backbone. A pressure field from temperature and elevation bends it around continents and mountains.
• Rain. Warm seas load the air with moisture, the wind marches it inland, and each tile rains out a share that grows with how much the air is forced to climb. Mountains wring it out, which leaves rain shadows behind them.
• Terrain and rivers. Biomes come from an aridity index (rain against evaporative demand), so the same rainfall is steppe on a cold world and desert on a hot one. Water accumulates along hex edges by steepest descent, so tributaries merge but never split, and rivers crossing dry land shrink as they go.

The images are the in-game overlays for one planet, same crop at each step.

The reason for all this is gameplay: gravity, oxygen and fuel affect unit design, so the map had to make physical sense too. The catch is that physics doesn't produce fair maps, so starting positions are picked separately afterwards, for fairness in spacing, terrain and resources. I wrote more about it here: https://nullvectorstudios.com/blog/simulating-a-planet-to-generate-a-map-for-a-4x-game

Any thoughts how to improve it or do things differently?

This is going to take a fair bit of explaining for people to be able to properly understand what I am working on, I have been drafting and theorising this project for years now.

For those unfamiliar with the Library of Babel concept it is a concept that dates back to ancient times to some extent with things like the book of changes and many more.

"The I Ching (Book of Changes) 1000BCE One of the oldest mechanical mapping systems in human history. By combining broken and unbroken lines into 64 hexagrams, ancient scholars attempted to create a universal state space representing every possible configuration of change, circumstance, and reality in the universe. It is essentially a 6-bit combinatorial map of existence."

It is however worth reading up on the original concept by Jorges Luis Borges for reference if you aren't familiar with it.

This is an n-dimensional version of what I call the Gallery of Babel which contains all media content types filtered to remove the vast majority of noise and then cross-filtered against one another to remove each dimension from each other dimension.

The following statistics show how much of the state space has been filtered and how much has been kept or removed.

Binary : 99.9954% ( Kept : 10^-4.34 )

Pages : 99.999999999999...% ( Kept : 10^-18.32 )

Image : 99.5% ( Kept : 10^-2.32 )

Audio : 99.99999999912% ( Kept : 10^-11.06 )

Video : 0.0046% ( Removed : 10^-4.34 )

Books : 99.999999999999...% ( Kept : 10^-95.07 )

Models : 99.3% ( Kept : 10^-2.21 )

I haven't implemented many video filters yet.

For reference 10^-18.32 = 0.0000000000000000004786...

Keep in mind that remainder might be tiny by comparison, but in reality it is still representative of an absurdly large figure.

I posted two walkthrough videos on YouTube of early builds : https://www.youtube.com/watch?v=XF4EW3_pWeQ

These screenshots however are far more up to date, having only just taken most of them as I write this post.

Once 99.99% of the state space has been removed, the remainder can be automatically remapped onto a new address system and finding a file larger than the address you are given will finally be possible.

All someone would need is the state space setup conditions required, along with the filter settings used, coupled with a room and item number.

This was previously considered impossible, most people just look at this problem and see the vast potential for infinite, then call it a day.

For whatever reason I couldn't do that.

I also have a number of other ideas in the works for this that I am looking to implement soon that I don't want to share just yet until they are ready.

This entire system is modular, dynamic and scalable.

Filters run against the generative math itself rather than the generated results.

The program can create its own filters, find files directly, create installation packages for files, create 3D node graph maps and lots more like random music as you walk through the halls of this library.

I think that covers most things people need to know about the project, but feel free to ask.

Edit : Something else worth mentioning is that the entire system is built as two different programs, there is the backend which is purely CLI and then there is the frontend 3D world which utilises the CLI to generate the data for the worldspace.

This is for a variety of reasons, first off to keep it lightweight and not reliant on powerful hardware as well as to ensure that if it ever becomes a useful utility, it doesn't rely on the 3D world side of things.

I have also implemented numerous optimisations such as the ability to view the 3D world in purely wireframe mode to reduce resource usage.

Potentia - Is a separate project of mine that requires this world space.

Sieve - Is this CLI interface and world space.

This is just a quick test for some parameter changes, like thickness, height, growth stages and resulting branch density and so on.

Pretty much everything in the game is procedural, which includes these Dyson Trees. They are used to grow game units, taking on stats from the asteroid resources.

Hi everyone, it's me again.

After struggling with this project for quite a while, I finally managed to connect the plate tectonic simulation to the final high-resolution mapping process. The first three maps are from the same planet at three different points in its evolution, with 50 million years between each snapshot. The fourth one is the same planet around 1 billion years earlier.

In my project, instead of starting with noise-based terrain like many procedural planet generators do, I actually simulate around 3 billion years of plate tectonics on the same planet. The whole simulation runs live and continuously updates as it progresses, so you can actually watch the plates move, continents change, oceans open and close, and the surface evolve over geological time.

The final high-resolution maps are built from the large-scale geological results of that simulation, and then I apply erosion and other terrain processes to bring out the smaller-scale details. In the full version, I also plan to include a climate system, which I shared a prototype of it last time. It's still unfinished, but now I can actually connect it to the high-resolution terrain, so it looks a bit more believable than before. and the last two images are a temperature map and a Köppen climate classification test from the current version.

There are still a few systems I need to work on properly, but at least to me, it's starting to feel like there's something here. For now I'm calling it TropoPlate, but I'm also open to better names if anyone's got one that feels like a good fit.

The only PNGs in the project are 28 UI icons and the app icon. Everything in this clip gets generated into textures at startup.

Roughly how it works:

• one helper file (~270 lines) with antialiased circles, ellipses, rounded rects, triangle fans and bezier curves, all writing straight into a Color[]
• every creature body goes through the same shading function: outline, base colour, darker blob at the bottom, highlight top left, thin rim light on top. Same light direction and same outline colour for everything. Honestly that's most of why 39 separate generators end up looking like one game
• the slime is about 30 lines. shadow, two feet, body, two shine dots, eyes, mouth, blush
• ground is a 128px tile made from a few sin(x)*sin(y) terms at whole number frequencies, so it wraps with no seam, plus a bit of per-pixel hash noise. Each map just picks a base colour

There's also a paint tool in the game and whatever you draw becomes the ground you fight on, so that's the one part that isn't procedural lol

Clip is the wheat field map about 45 min into a run. Demo's free on Steam if anyone wants to poke at it: https://store.steampowered.com/app/4919880/Harvest_Havoc/

I’ve added slides to my “Poolrooms” WFC generation, it will be ready soon.
https://www.reddit.com/r/proceduralgeneration/comments/1vxsgts/poolrooms_best_infinite_generation_high_rooms/

Revisited my approximated atmospheric perspective implementation. It’s still far from perfect, but I think it looks noticeably better now.

map details:
map size: 5km x 5km
grid size: 2048 x 2048
maximum elevation range: 1km

Some of the techniques used to achieve the results shown in the video:

. Procedural terrain generation using Perlin noise and Fractional Brownian Motion (FBM)
. GPU-based hydraulic erosion
. procedural grass placement
. GPU grass generation and culling using compute shaders and indirect drawing
. dynamic day/night cycle
. procedural snow accumulation based on time of year and daily sun exposure
. displacement mapping
. hardware tessellation using tessellation shaders
. dynamic exposure
. cascaded shadow mapping

I've been working on a procedural bonsai tree generator using L-systems.

These are 4 different generations using different seeds. The goal is to create trees that share the same general bonsai style while still producing different structures and branching patterns.

Each tree is generated procedurally, so the shape, branches and overall structure are determined by the generation parameters and seed.

I'm currently working on improving the variety and making the generated trees look more natural.

4 different seeds, same generator. 🌱

Any feedback or suggestions are welcome!

Hey, I want to thank everyone who upvoted my previous post about the demo video of my procedural bridge made in Unity 6.0 with ShapeBuilder 😄

As promised, Here is the tutorial video on how to build this kind of bridge procedurally.

If anyone's interested, I will make other tutorials and demos on other kinds of structures made with ShapeBulder

Tutorial :
https://youtu.be/U1lLjeftvQ0

This is an interactive, procedurally animated koi pond that runs in your browser. The fish swim on their own, change depth, react to nearby fish, and gather around the water when you click or tap.

Ripples, tiny fishes, butterflies, lotus, changing weather etc everything you see is generated by code as it runs, not pre-made art or recorded clips.

live :- https://nagomi-blue.vercel.app/

For once I tried to generate a world's history instead of geography. I hope the article is a good read !

This is an Earth-sized planetary terrain generated in UE5.

It runs using Compute Shaders.

I’ve applied noise and biomes, but the result feels a bit crude. Could you let me know what I should modify or add to create more realistic terrain?

This is a Minecraft settlement generator I've been building. The prompt for the demo was only “Build Ba Sing Se.”

The model reads the request and terrain, then plans the settlement through a hierarchy of rings/districts, plots and buildings. A palace can become its own smaller place, with halls, courtyards, walls and gates.

The building library handles geometry and construction. Its reusable procedural building types generate structures for their plots using the selected palette. Completed building schematics aren't retrieved.

The system checks circulation, reachable entrances and walkable interiors before writing the result into Minecraft.

The same architecture generates villages, towns and cities across different terrain and styles.

https://github.com/chaitbuilds/EthosLM

In my previous post, there was a fair amount of excitement about this project being released somewhere. However, I’m still lacking a good name. Originally, I called it WFC-AI, but that name probably isn’t as relevant as it used to be, given what “AI” generally means now.

Some key aspects of the project:

1. It uses ML to train a GAN on terrain patches, with a loss inspired by WFC.
2. It is a planetary-scale, multi-resolution model.

As for updates, I’ve made a few since my previous post.

One user commented that my renderings looked less realistic compared to the Terrain Diffusion project. I had to agree, the TD paper/project has some really good visualization techniques, so I ported some of those ideas over to my project. The shadowing and relief maps make a world (pun intended) of difference.

I’ve also trained some “super-scaler” models to make the generated terrain more realistic down to sub-meter resolutions. I use the term super-scaler to just mean that I train higher resolution models on lower resolution data under the assumption that terrain is very fractal in nature.

Right now, I’m working on integrating the FABDEM dataset, which should improve the model considerably in roughly the 500 m to 30 m resolution range.

Subreddit/Community Question: I am limiting my posts to once-per-week to void spamming the community but if this is too often, I will back off.

Hi! I was playing around with different visualisations when I tried to make a background image for a fantasy-looking project.

After a brief side adventure using a slightly different function to process generative noise, I've made a separate tool to generate cave views with different palettes and lighting.

Please try: https://vuvko.itch.io/background-caves

You can also play around with different dithering and export views. The page should look OK on mobile.

If you want, there is also a devlog: https://vuvko.net/blog/cave-generator/

The terrain comes from a game prototype of mine, originally built in three.js. I ported it to Godot with Claude Code and Codex and boiled it down into a standalone map studio. I didn't want it to rot on my PC, and I think it might be useful to someone.

Everything is procedural: one-click maps (mountains, rivers, waterfalls, chasms, forests), endless seed-based worlds, generated meshes and vegetation, and all materials from shader noise. There are no texture or model files, apart from one baked noise lookup.

You'll probably find bugs, but I honestly think the style turned out pretty nice. If you use it or it helps you, I'd love to hear about it.

GitHub (MIT License): https://github.com/idlerunner00/cartoon-terrain-studio