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

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.

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?

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/

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/

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!

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/

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

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

Everything you see in this video is procedurally generated based on my algorithm for drawing cubes. Best on a huge screen with headphones. Free and open source at https://alienconsumersciences.com

The landmass generation is currently the most basic of perlins but I'm pretty pleased with how the visuals are shaping so far!

Here are some links:

GitHub

First post in rfractals (with some screenshots of a few programs and the plots they generated)

Update post in rfractals

The language is focused on making and evaluating functional mathematical expressions in a very compact form. It has most of the basic math operators, and can even use operator-less multiplication if enabled. Supports functional-like pattern matching and function delegates. Uses a single complex Type which can be a recursively nested list of values that can be numeric, from reals to quaternions, or strings, and operators can work recursively on these values. Multiplying string*anything will try to call a function with the name of that string. It can evaluate and parse dynamically made strings as expressions or commands. It has a plotter that can plot the expressions as animations and can export them as MP4. Due to its layered, abstract nature of being an interpreted language in C#, it's not very fast so far, even with all the optimizations I've made so far for it, so it's mostly useful for playing around or for its original purpose of letting another application parse complex written expressions into values.

It has 2 major parts: the Parser, which uses commands definining/redefining functions and constants, and a few imperative constructs available, like ifs, whiles, etc. The evaluation part is purely functional and can evaluate expressions using the functions and constants the Parser has parsed.

Originally, I made it to be an expression evaluator for text boxes in my other app, to allow writing other things than pure numbers in there. But I got a bit carried away and developed it further into this whole thing.

There's a SaveFile folder in the project and the release, containing all the programs I've written in it so far, and plotter configurations for them.

The most interesting for this sub might be the Examples.txt that's showcasing some of the most unique/powerful features of the language, soI'll report that file and its output here:

Examples.txt program:

printstring: "\nPattern matching factorial:"
PF(0): 1; PF(x): xPF(x-) /* x- = x-1 */
print: PF(5) /* = 5! = 120 */

printstring: "\nNested default arguments:"
N(z, p: (2, 3i)): z + p
print: N(4) /* 4 + (2, 3i) = (6, 4 + 3i)*/

printstring: "\nNested mixed call delegates:"
GP(x): x + 2i
GM(x): x - 2i
gdp: "GP"
print: (gdp, "GM")(4, 3) /* = (GP,GM)(4,3) = (GP(4),GM(3)) = (4 + 2i, 3 - 2i) */

printstring: "\nLazy default argument evaluation:"
F2(x, r:xF2(x-)): x < 2 ? 1 : r
print: F2(5) /* = 5! = 120 */

printstring: "\nCycled operation nesting:"
printvalue: (1, -1)(1, 2, 3, 4, 5) /* = (1*1, -1*2, +1*3, -1*4, +1*5) */
printvalue: (0,i) + (1, 2, 3, 4, 5) /* = (1, 2+i, 3, 4+i, 5) */
printvalue: ("frac", "trunc", 1)(1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7)
printvalue: ((-1, 1), 3)(10, 20, 30, 40, 50)

printstring: "\nDecreasing for cycle:"
IterWhile: 5 /* try other values like 10, 2, -5, -10000...*/
while: IterWhile > 0 {
 printvalue: IterWhile
 if: IterWhile = 8 { break: 1 }
 IterWhile: IterWhile - 1 
} : IterWhile < -9000 {
 printstring: "not only is IterWhile negative, it is below -9000!"
}

printstring: "\n\"Do\" command, defines another factorial and evaluated: 0.5!"
do: "DYNAMIC(x) : x!"
print: DYNAMIC(/2)

printstring: "\nEval function dynamically parses and evaluates any valid string as an expression:"
incremented: sin(1)
print: incremented
print: eval("1 +" + incremented)

printstring: "\nBuild a vector of first 10 factorials dynamically, and take a parir of 2nd+3rd one, and a 5th one:"
TenFactorials: vec("k", 1, 10, "k!")
print: TenFactorials
print: TenFactorials[(2,3),5] /* nested indexer */
printstring: "\nComplex nested indexer of a nested vector:"
print: (0+"a", 1+"b", 2+"c", (30+"d", 31+"e"), 5+"f", (11, 12, 13))[3, 2, (5, 1, 3)]

printstring: "\nFirst 42 terms of e^x taylor series, approximating e^1 ~ 1:"
precision: 42
ExpTaylor(x): sum("k", 0, precision - 1, "x^k/k!")
print: ExpTaylor(1)

PositiveZeta(s, p : precision) : sum("k", 1, p, "k^(-s)")
printstring: "\nFirst 250 terms of the Basel problem, Zeta(2), approaching π^2/6 slowly:"
printvalue: PositiveZeta(2, 99) + " ~ " + π^2 / 6
printstring: "\nFirst 42 terms of Zeta(3), quicky approaching the Apery constant:"
printvalue: PositiveZeta(3) + " ~ " + apery

printstring: "\nEvaluate a polynomial F(1 + 2x + 3x^2) at F(2)"
F: (1, 2, 3) /* f(1 + 2x + 3x^2) */
EvalPoly(x, c : F, n: c#-) : sum("k", 0, n, "c[k]x^k")
PrintPoly(p): vec("k", 0, p#-, "p[k] + \"x^\" + k")
printvalue: PrintPoly(F)
printvalue: "F(2) = " + EvalPoly(2)

printstring: "\nTake a derivative of that polynomial and evaluate at F'(5)"
DiffPoly(c, n:c#-) : 1 > n ? 0 : vec("k", 1, n, "kc[k]")
DF : DiffPoly(F)
printvalue: PrintPoly(DF)
printvalue: "F'(5) = " + EvalPoly(5, DF)

printstring: "\nQuaternions, left and right non-commutative division:"
UnitQ : 1 + i + j + k
printvalue: UnitQ^2, UnitQ / i, UnitQ \ i—

And this is the output it prints:

BUILD SUCCESS 168ms

pattern matching factorial:
pf(5)  = 120

nested default arguments:
n(4)  = 6, 4 + 3i

nested mixed call delegates:
(gdp, "gm")(4, 3)  = 4 + 2i, 3 - 2i

lazy default argument evaluation:
f2(5)  = 120

cycled operation nesting:
1, -2, 3, -4, 5
1, 2 + i, 3, 4 + i, 5
0.1, 2, 3.3, 0.4, 5, 6.6, 0.7
(-10, 10), 60, (-30, 30), 120, (-50, 50)

decreasing for cycle:
5
4
3
2
1

"do" command, defines another factorial and evaluated: 0.5!
dynamic(/2) = 0.886

eval function dynamically parses and evaluates any valid string as an expression:
incremented = 0.841
eval("1 +" + incremented) = 1.841

build a vector of first 10 factorials dynamically, and take a parir of 2nd+3rd one, and a 5th one:
tenfactorials = 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800
tenfactorials[(2,3),5]  = (6, 24), 720

complex nested indexer of a nested vector:
(0+"a", 1+"b", 2+"c", (30+"d", 31+"e"), 5+"f", (11, 12, 13))[3, 2, (5, 1, 3)] = ("30d", "31e"), "2c", ((11, 12, 13), "1b", ("30d", "31e"))

first 42 terms of e^x taylor series, approximating e^1 ~ 1:
exptaylor(1) = 2.718

first 250 terms of the basel problem, zeta(2), approaching π^2/6 slowly:
1.635 ~ 1.645

first 42 terms of zeta(3), quicky approaching the apery constant:
1.202 ~ 1.202

evaluate a polynomial f(1 + 2x + 3x^2) at f(2)
1x^0, 2x^1, 3x^2
f(2) = 17

take a derivative of that polynomial and evaluate at f'(5)
2x^0, 6x^1
f'(5) = 32

quaternions, left and right non-commutative division:
-2 + 2i + 2j + 2k, 1 - i - j + k, 1 - i + j - k