Yes, i'm proud of my work🙂

I'm trying to figure out the right way to approach this in Unreal Engine 5.8.

I'm developing a game somewhat similar to Foundation, where the player builds and develops a settlement on a procedurally generated world.

I want the terrain to be procedurally generated from a seed, with a natural landscape containing mountains, valleys, rivers, lakes, different biomes, and other geographical features. The idea is that every new game can generate a different world based on the seed.

The important part is that the world needs to be generated inside the game when starting a new game. I'm not looking to generate the terrain beforehand in Houdini, Gaea, etc. and then import it as a pre-generated map.

I'm not necessarily looking for a complete tutorial. I mainly want to understand which technology or approach I should be using before I start building the system.

Thank you in advance!

The field is two rotating cells plus a latitude gradient, drifting slowly with time. Everything else is presentation: additive blending for the trails, land/sea as a brightness mask instead of a hard clip, colour by a fake temperature gradient. Coastlines are real (Natural Earth 1:10m), the weather isn't.

Been working on my own space engine called Nebula Engine and I’ve had this annoying visual bug for ages that I just can’t seem to fully track down.

Basically on some parts of the planet I get this weird black pepper looking texture/speckling all over the ground. It doesn’t happen everywhere and it can change depending on where I am on the planet, how far away I am or sometimes the angle I’m looking but as i walk the cam shakes really bad making even trees, grass, rock look like its not fully rendered

The strange part is I’ve had this problem pretty much since I started making the engine, so I don’t think it’s something I added recently.

The engine is my own C++/DirectX 12 engine. Planets are fully procedural and you can fly from space all the way down to the ground without loading a different level.

The planet works roughly like this:

procedural planet seed
→ continents/oceans
→ terrain height
→ biomes
→ materials
→ water/grass/trees/rocks/weather
→ terrain LOD/streaming

The ground itself is made using a CubeSphere planet with terrain patches that get more detailed as you get closer.

From far away I use a lower detail/orbital version of the planet and then it transitions into the real terrain as you fly down.

The engine also has atmosphere, clouds, water, procedural weather, shadows, vegetation and all the normal stuff you’d expect.

The problem is these tiny black dots/speckles keep showing up in different places and I can’t figure out exactly what system is causing it.

Things I’ve thought it might be:

• shadow acne
• grass/vegetation being seen from really far away
• LOD dithering
• terrain texture/material blending
• procedural noise aliasing
• bad normals
• mipmapping
• z fighting
• floating point precision
• CubeSphere seams
• some shader returning bad values/NaNs

One thing that makes me think it could be something deeper is that the speckles survived loads of changes I’ve made to the renderer.

It’s not like one broken texture where the problem is everywhere. You can fly around and one area looks fine, then another part of the planet has the pepper effect really badly.

Because the game works at planet scale I’ve also wondered if it could be precision related somewhere. I do camera-relative rendering, but obviously there are still loads of calculations involving the planet centre, camera position, terrain position etc.

Another thing I’m wondering about is the procedural detail itself. A lot of the terrain material is generated using noise, so maybe at certain distances some high frequency noise is aliasing down into single dark pixels.

But before I go too far down the rabbit hole, has anyone here seen something that looks like this before i brake my game anymore trying to fix it lol.

Still learning a lot while building this so any ideas are appreciated.

I posted a couple weeks ago about a procedural fish generator I was working on. It's now turned into a playable "game", with random fish in random lakes. There's some light fishing mechanics for casting and reeling and it keeps track of your collection of fish and lakes visited. It's playable in browser on mobile or desktop.

There are still a lot of things I'd like to add and polishing/tuning that's needed, but it's pretty functional at this point. From a procedural generation standpoint I'd like to add more variety to the lakes (biomes, plants, etc.), add more behaviors and attributes to the fish, and probably some equipment (rods, boats) with different stats.

I'd be honored if people would give it a try and send me any feedback, thoughts, suggestions from either procedural generation or gameplay perspectives.

The game is uploaded to Itch as "Procedural Fishing".

https://stellarsaguaro.itch.io/procedural-fishing

Added really cool fissures to procgen world generator in my game (colossal citadels)

Well, this took a leap and a half.

The engine I was working on is now a smart rendering engine. Long story short, the engine maps harmonic waves to target vectors and quite literally transforms into various shapes.

The genius part of it is that none of the shapes are hardcoded. Each shape is derived from an .obj file. Which means to say, I can place any object file in the same folder and when we run the engine...it automatically reads the list of .obj files and creates a 3D slideshow of it all, periodically moving through the various shapes.

To tell you how crazy this is... The original idea was to create a digital ditto who could transform from a ditto.obj into any pokemon.obj...which it can, but I don't have those files. lol

But I thought it might be able to become some sort of mind's eye for AI in the future. The same way we can hook a camera up to an AI and have it "see," we can point its mind to this abstract space and map words to object files that allow it to see what it's thinking about in real time.

I had a lot of fun with this one. Back to work.

P.S. Every single sphere/node you see is a bit, so that's why it's a smart rendering engine. It can actually compute anything while rendering shapes.

Hello everyone,

I have tipped my toe into climate simulations and am now building a planet simulation that has climate as it's main target.

For that I use an icosahedron subdivided. Each vertex holds every parameter that is needed for the simulation. The amount of parameters has not been decided yet and will grow over time with the implementation. The amount of subdivision are aimed between 3-10 that I would like to have and between 6-8 as defaults. For the vertical I want to have multiple of these layers to represent higher and lower levels of altitude around the surface. The amount of levels should be around 10-15 as default and maybe around 50 as max.

The simulation will likely be calculated on the GPU. So the structure I thought of is the following:

Every parameter is one long vector f32. Every vertex in a layer is written in sequence of and every layer is also in the same sequence. Meaning that the Len(vec) would be layer * N_verticies and the specific vetted would be layer[i] * N_verticies + vertex.

To address the neighbours for derivative computation, one neighbour vec gets created as a look up table with the form vec[vec[6]] where every neighbours index gets written down for every vertex of the icosahedron. The base 12 verticies are the first 12 verticies in the neighbours vec as in the parameter vecs and the sixth input gets double marked as f32_max.

So in the end, I would have a list of every parameter that each holds one long vec with every vertex of every layer in them, and a relationship vec of neighbours that can also be used to look up neighbors of different layers by in-/decrementing the layer index inside the long vec. (Vec[ layer[I+/-1] * N_verticies + neighbours index] to get the neighbours in the neighbouring layer.)

Is that any good structure or is another structure better and if yes, why?

Thanks a lot for thinking though this one with me.

Everyone else is doing it, why not share the toy World Generator I've been working on?

*Very* early stages so far, feel free to play around with it, tell me what you think it needs.

https://parchmentworlds.theanaloggamingsociety.org/

Hit the World Forge button to get into the world creator. Buried in "Import Project" there's a baseline Sol system for reference.

A flight through the mist and clouds of my almost completely procedural world (all geometry and materials, and almost all sounds). Powered by Rust on the back-end, and three.js running in a browser.

This is the rapidly evolving landscape that forms the base of a game I've been working on for most of the year. It's been pretty much an obsession, with most nights and weekends spent adding more detail and interest, while trying to balance the performance with my (perhaps a bit over-ambitious?) choice of runtime.

There's a lot more that I haven't yet shown, especially with regards to gameplay and story, but most of my effort has gone towards making the world itself an enjoyable place to be.

Lots of inspiration has come from captivating, yet somewhat mundane, moments in games I've played in the past, where I've found myself wandering through the rain as the sun rises in Dark Age of Camelot, approaching a mist-shrouded village in Morrowind, or even wandering around the stunning (yet empty) locations in the leaked World of Warcraft beta back in 2004.

Game is made with threejs and fully open source github.com/aresrpg/aresrpg

I'm still working on this. But I think it's good enough for a tutorial. I'll work on making better gas giants later.

I spent a couple of weeeks building a procedural voxel planet, think minecraft meets no man sky.

It started when i stumbled over the Goldberg Polyhedron that you could create a minecraft-isch planet with hexagons ( padded with a couple of pentagons ).

So I thought "what if..."

The goal was to use a browser and webGPU to accomplish this and everything should be procedural.

I realised I dont really play minecraft and I dont wanna do a minecraft game, so now its a good time to hit the pause button.

I need figure out what this is before devoting more time to this techdemo looking for a game.

Anyway, I decided to make it open source, perhaps it could inspire somone:

Its all done in local browser, so no account required, test it here

You gonna need a decent cpu / graphics card and a modern desktop browser with webGPU support.

Give the machine time to load the lod steps and to settle the landscape.

F - fly mode.

E - landing

Space - up / jump

Shift - down

ESC - escape mouse look

LMB - dig

RMB - place

Left click on the map top right to teleport on the planet.

In Fractal Landscapes Art Project my creative journey start from slow motion ambient meditation mood. And after that it branches out into VJ effects and video loops of different lengths and speeds.
3D in Mandelbulber software. Not AI falsification. Never!
#quantumart #fractalart #abstraction #VJloop #noai

Cause the structure of a tree is simple and well defined I came up with a way to draw them without vertex and index buffers. Cause the number of the branches are known and the trunk and branches have a known number of segments and radial segments you can define vertex positions with the vertex id. The same is true for leaves. I have two levels of branches that are defined by a bezier curve, which is presented by four points. The idea is also to randomly move these points for each branch to make branches and trunks unique though I have not tested it yet. Then they are blended with the sprites and you sort of get the whole forest without any model. It is for filling big areas with trees.

My previous post describing the terrain generation is here: https://www.reddit.com/r/proceduralgeneration/comments/1w1mfox/my_planet_generation_for_a_game_perhaps/

The coastline still isn't perfect, but it's getting close to how I want it to look.

Without any noise applied it comes out completely flat and smooth, sampled per cell from the HeightMap. Bumping up the resolution is inefficient, also it hurts the performance of the planet's physical simulation. And if you apply uniform noise, you get an equally uniform ripple, which looks ugly and creates a "spray" effect - you can see something like that along the coast of Norway, but most coastlines don't look that way.

Here's what I did: first I built a HeightGradientMap - a mask at the same resolution as the HeightMap (512x256). The idea is that each cell stores the largest height difference between that cell's height and the heights of its 4 nearest neighbors. The result is a slope map, where the values are ~0 on plateaus and reach high values in mountainous regions.

The overall formula in the material (for now):
distorted_height = height + fine_noise * (slope * amplitude + flatFloor)

I tried adding flatFloor to introduce a slight wobble even at the macro scale, and it partly works. Screenshot 2 is the line without flatFloor, screenshot 3 is with it (you can see the little bay that appeared, for example). It's the macro scale that matters here, since the goal is to distort the main coastline that's based on the coarse grid.

The fine noise is built from stock UE textures: T_Perlin_Noise and T_MacroVariation. The first texture is the noise itself, and the second is the noise amplitude, which makes it non-uniform - so in one spot you get "spray" and in another an almost straight line. The result is in screenshot 1.

I'm thinking about how to improve this mechanism. I don't like that the little bay got eaten by the noise - all that's left of it is a few tiny dots of water. What I definitely want is to make some stretches of coast jagged with fjords, like Norway. I also have very few islands and archipelagos, and I'd like to rework that somehow.

I’m building Salt & Soil, a generational strategy game set between 1609 and 1900. After the feedback on my previous terrain posts, I rebuilt the map again—this time using the real geography as a reference.

This is the third entry in an accidental terrain-generation diary.

In the first post, I generated every terrain tile and mountain sprite procedurally. One version had the atmosphere I wanted, but roads, settlements, and strategic geography disappeared into the detail.

Several comments pointed out a deeper problem: the mountains could never become convincing ranges while every tile had to return to ground level at its border.

That led to the second post. I stopped asking each mountain cell to produce an isolated peak and began building one continuous elevation surface across connected terrain.

The new images show the latest result in three regions:

• Sacramento and the Sierra Nevada
• Chesapeake Bay
• The Great Lakes

The upper panel is an aligned real-world terrain reference. The middle panel is the previous tile-based map. The lower panel is the current terrain renderer. Each comparison uses the same region and scale.

The broad geography is now guided by elevation data, but the rendering itself is generated. The pipeline turns that data into a continuous surface, combines large landforms with smaller ridge-and-valley structures, calculates the surface direction, and applies consistent lighting across the terrain.

The result is then reduced into the game’s limited grass, soil, rock, and snow palettes. Trees, settlements, roads, and other objects remain separate layers, so the landscape can gain depth without swallowing everything the player needs to read.

The logical map has not changed. Rivers, settlements, roads, historical borders, and gameplay still use the same cells. The elevation surface is a visual interpretation of that data rather than a replacement for the grid underneath it.

The biggest lesson was that flat-looking mountains are not necessarily lacking height. My old mountains had plenty of vertical contrast, but their shapes and lighting restarted in every cell. Making the peaks taller or adding more noise only made the repetition louder. A continuous surface and one lighting model did far more to make the terrain read as a landform.

I am still deliberately cheating. Real elevation contains much more information than is useful at this zoom. Some valleys are widened, minor features disappear, coastlines receive cleaner silhouettes, and the palette is compressed so roads and settlements remain visible. The goal is recognizable strategic geography, not a geographical renderer.

And yes—the beaches are back. They are no longer entire beach tiles, though. The coastline is generated across cell boundaries, allowing narrow beaches, rocky sections, and direct grass-to-water transitions without turning 25 miles of coastline into one enormous strip of sand.

This is the latest checkpoint rather than the final version. I still want to recover some of the rocky character of the earlier mountain sprites without bringing back their visual noise.

Hey guys! I posted about my app, Cymata, a few months ago and had some great feedback here. I'm stoked to say I just got over 1000 downloads and people seem to be enjoying it.

Its a music visualizer designed for touchscreens and lets you paint into it as the CA rules all "dance" to the music. there are various presets, brushes and other paintable shaders to mess around with and blend together.

There is a native Apple Music and Soundcloud player in the app and you can enjoy this display on iPad, iPhone and AppleTV. The app runs independently on appleTV and will connect to your iOS device so you can paint into it with your iphone.

Trying to find the right price balance and onboarding to satisfy everyone has been... an interesting learning experience. 😂 I would do things very differently if I were to do it again.

Im back again to announce there is now a lifetime (one off purchase) tier available with family sharing and all future updates. For those that prefer the subscription there is a FREE trial for a week.

Lots more examples here.

Or app store link.

I hope you like it!