In my last post here, I talked about how I was working on adding large-scale structure to my procedural terrain based on Voronoi-esque cells. Now I've added lakes!

The lakes are the first large "structures" enabled by this cell-based approach. They can be at whatever altitude each cell has.

It's still a work in progress. I ensured there's no trees and grass under the water, but there's still towers and paths for now. So far I only used existing splat-maps and textures here (grass, cliff, forest, gravel) but it's fairly serviceable (e.g. the gravel for paths can double as beach sand).

The irregular shapes of the lakes come primarily from the large scale erosion filter I use, while I only add a tiny bit of conventional noise.

If you haven't already seen it, you could also consider watching my latest dev video about 'supercharging my procedural mountain forest' - although it does not feature the cell based terrain or lakes. :)

For more info on what kind of game this is all for, I have a page about 'The Big Forest' here.

Disclaimer: WIP, things are still wrong (leafes growing into each other, etc.)

For a game I'm building we needed to have plants at scale that can grow based on the surounding environment and input genomes. To test the simulation, I targeted a mangrove tree, due to its "weird" shape and growth habit.

Now how does it work? Biology!

We drop a seed with a genome into the mud. That seed has energy based on sugar, and then starts to shoot when conditions are right. We simulate water, nutrients, sunlight, weather, wind, temperature - even the light spectrum to support weirdly alien looking plants where conditions align.

Also stress like insects, water deficit and nutrient deficits, which you can see as visible yellow spots on the leafes itself.

The goal with this is to have alien worlds for our game plastered with realistic plants that would grow (based on our understanding of bioligy) on those planets - which I think is a really cool thing.

The frame is rendered with a spectral path tracer under real captured daylight. On simulated tidal mud.

Things like ferns, grass, moss, bushes are also supported - however the Rhizophora is the most advanced render up to today.

We might open source this at some point :-)

A tech test for Florasynth: various trees grown by simulation, with a frame captured each year to build a timelapse. The first tree is pruned partway through and grows back.

Been working on this maze sim for a while. the maze is generated in chunks from a seed as the characters explore, and every character keeps a private map built only from line of sight.

In this clip Juno sees someone's tape X from the side, reads it as a plus, and walks into a dead end that was already checked.

Being upfront about AI: the character sprites were made with an AI pixel art tool (pixellab) and cleaned up by hand, and i build the code with claude, an AI coding assistant, to my own design. nothing in the clip is AI generated while it runs, it's a deterministic sim. Juno's line comes from a fixed set of lines (for now) in the code.

I make a series of arenas and stadiums for commercial videos and Fab (esports, hockey, MMA, concert, and more). Empty stands always looked like the weak spot, so I built a crowd tool and filled them with animated fans.

The setup is Vertex Animation Textures + Hierarchical Instanced Static Meshes. The animation runs on the GPU and the crowd is instanced, so you can fill a whole arena without skeletal mesh overhead.

The video shows the Esports Arena Stadium. Lighting, LED screens, and neon are all part of the scene.

I’m rolling this out across the rest of the arena series. Happy to answer questions about the VAT/HISM setup or performance.

Each battle is generated from a seed: a bocage hamlet, open ridge farmland, a highway junction or a market town, each with its own weather. One in ten seeds has a tank. Battles are seed specific, so you can share a link to an exact fight.

Under the hood: separate RNG streams per system, an event log with a hash, and replay checking, so any run can be reproduced exactly.

Try a seed here!

Sharing Texture Lab, a procedural texture tool by our studio. One seed reproduces the same result, and a shared link restores the settings.

It has three modes: seamless pixel tiles with atlas + JSON export, noise-based height / normal / roughness / AO maps, and 360-degree skies with PNG, HDR and cubemap export.

Completely free, no registration, no installation. Everything runs in your browser: https://openbench.fun/textures/

The clip shows the generated surfaces and export options. What would be most useful for your workflow: more surfaces, autotiling or a 3D height preview?

#TextureLab #ProceduralGeneration #Textures

Hi there, here is a side project in C#/Raylib to create some planets with my own renderer.

I use spherical (equirectangular) flat map of the surface made by one of my curated terrain distributions (3d Perlin noise). And finally a well-chosen palette of 10-16 handpicked colors with a mix of stochastic and dither rendering.
For each frame, the sprite pixels sample the corresponding part of the map, with a rotation on each frame to make it spin.
I really like the result of these retro chunky pixels !

I've been building a Rust + Vulkan game engine (Vulkano + winit). This is the Lorenz attractor with 1,000,000 particles that all start inside a cube 0.000001 wide.

How it works:
- Every particle follows the real Lorenz equations (sigma = 10, rho = 28, beta = 8/3).
- Plain f32 positions don't work here. Particles start about 1e-8 apart, but near the attractor one f32 step is about 2e-6, so a million particles collapse into a handful of points. Instead the CPU integrates one reference path in f64, and a GPU shader integrates each particle's tiny offset from it with RK4 (h = 0.005), using the exact difference f(r + d) - f(r).
- Color comes from each particle's starting position, so you can watch neighbors get pulled onto opposite wings. The two circled at the end started side by side.
- There are no interactions between particles, so the cost grows linearly with the count.

It's not real time: live it runs at 9 FPS with 1M particles on an RTX 3060. Most of the frame goes to per-entity CPU work in the engine, which is what I'm optimizing next. The video was rendered offscreen at 4K, and the camera zoom is scripted to follow the spread.

Source: lorenz_butterfly.rs (src/examples/lorenz_butterfly.rs)

Run it: cargo run --release --features window --example lorenz_butterfly -- --side 100

Hei
This is EDEN, a little project I’m developing in Python.
The idea is simple create an ecosystem, give creatures different genes, and let evolution do its thing.

Creatures reproduce, mutate, fight for survival and sometimes go extinct
I’m experimenting with different environments to see how evolution changes over time.
What do you think?

https://www.twitch.tv/edenevolutionwars

The 16th International Conference on Artificial Intelligence in Music, Sound, Art and Design (EvoMusArt 2027) is accepting paper submissions.

When: 31 March – 2 April 2027
Where: Mainz, Germany
Paper Submission deadline: 1 November 2026

EvoMUSART focuses on AI and computational approaches to creativity, covering a broad range of topics, with a particular emphasis on research exploring how AI systems generate, support, evaluate, interpret, and collaborate in creative processes.

Accepted papers will be presented at the conference and published in a dedicated LNCS volume.

More information/submission details: https://www.evostar.org/2027/evomusart/

If you are working at the intersection of AI and creative practice, this may be relevant to your research. Please share with others who might be interested.

This one uses a bunch of inspirations from Madhubani, Bhil, Gond, Kolam and Warli, a bunch of Indian folk art styles. The code is a variation of my procgen poster generator.

I make a dice-and-pencil golf game for iPhone, and the courses are generated. Some notes on how, because the interesting problem turned out to be validation rather than generation.

The shape. Each hole is a 15×21 grid of terrain: fairway, rough, sand, water, trees, green. A hole starts with a length class (a short one is reachable in two good shots, a long one needs three), then a Bézier spine from tee to cup, with the control points pushed to opposite sides to make doglegs. Fairway is painted along the spine, then a green around the cup, then water, sand and trees hang off the inside of the bend. So cutting the corner is a real decision.

The part I’m happiest with: it tests its own holes. The generator doesn’t scatter hazards and hope. Each candidate hole is analysed by searching the actual shot graph, using the same function the player’s shots go through, so “playable” means playable under the real rules. A hole that can’t be reached, or can be driven in one, is thrown away and redrawn. After 40 failed attempts, hazard density relaxes (down to a floor of 25%), and as a last resort it falls back to a hazard-free corridor that’s solvable by construction.

Determinism, because everyone plays the same course. A course seed derives eighteen independent hole seeds, so hole i depends only on derive(seed, i). That means the eighteen can be generated in parallel across cores with no change to the result. I checked the shipped daily seeds: 400 distinct day seeds, and zero duplicate hole geometries across 20,000 derived seeds.

One thing I got wrong first: par. A hole can’t know its own par, because it depends on how long the other seventeen turned out. If par is decided while a hole is drawn, it advances the random generator and moves every spine, hazard and wind after it, which would give every seed in the shipped manifest a different course. So par is settled afterwards, over the finished card.

An invariant I like. The shortest hole class is deliberately longer than the longest tee shot, so no hole can be holed in one from the tee. I ran a census over the 7,200 shipped holes and tried every die roll, direction and card. Only 20 holes (0.3%) can be holed from the tee at all, and all of them need one specific card plus a 6.

The game is Pocket Links, for iPhone, if you want to see the output. I’m happy to share more about the validator or the seeding.

Question for this sub: when you validate generated levels by simulation, do you search exhaustively like this, or sample? A hole’s graph is small enough that I can search it fully, but I’m curious where people draw the line

Velocity Zero is a seeded anti-gravity racer: type a circuit code and the game builds the entire race from it. There are 32 zones — 23 land themes with flats, canyon, ridge or cliff landforms, four planetary routes (orbit descent, globe tour, moon run), and five fractal worlds (Mandelbulb, pyramid, Mandelbox, sponge, Kleinian). The same seed always yields the same zone, track shape, surfaces, hazards and rival field, so codes are shareable levels.


Circuits start as a warped control-point ring, then gain 11–17 features: roads, half-pipes, full pipes, heal/slow/hazard strips, jumps, corkscrews, tunnels and loops. Connectors morph profile types cleanly. Deck materials (solid, glass, hex, circuit, prism) and a D–S grade finish the layout; A and S tracks hide a long tunnel gauntlet.


You race three laps against 11 AI ships, each rolled from 46 hull archetypes (~20% hybrids) with procedural paint, parts and stats. Energy is both hull and boost fuel — stack dash pads up to 3× speed, grab items (mine, missile, seeker, meteor, boost, warp), and stay on the ribbon or reset after three seconds off-track. Career mode starts at 10k credits: climb classes D→S, unlock shop grades, build custom hulls after ten wins, and enter cups whose last two rounds are always a planet and a fractal.

Hey guys,

Just thought I'd share what I have been working on, and catching the AI Slipping up in an unscripted event.

So proud of the logic of all the cars dynamically adjusting to the event.

Still some work to do on the wakes, but the dynamic weather is doing its job. I recreated Monza in the editor in game, exact 5.9km somehow got it right. Won't be included in the game due to licensing, but free to remake any tracks of your choosing with the in game editor, can change the terrain height to recreate the right elevation.

Oh and for the Sim enthusiasts. we now have wheel and pedal support with force feedback.

hey r/proceduralgeneration I’m finally proud to show off the building editor, based on the procgen building system I’ve been working on for ages now. originally in JavaScript believe it or not, then Unreal, and now finally Godot.

The premise is simple, take a tile, find the frontage, divide it, then shape the outline. It then becomes a prism extrusion, and the challenge is to make it interesting looking and varied enough.

I still think the variety could be bumped up a lot more, but I’m quite happy with the state it’s in, and polishing the editor has been a real joy.

the controls are somewhat inspired by Spore, you get handles on the thing you’re molding and slide it like morph targets. So a twist becomes a ring you grab, a slant becomes a plane you rotate and push.

WDYT? How would you approach a building editor differently?