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!

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

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

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?

https://youtu.be/tb87BA0JUR0?si=5gNlvCCuSIeZd-7T

UMBRAL: a dark, retro space survival game.

Fly from deep space to any planet’s surface with no loading screens. Land anywhere, step out, and survive.

Trade, mine between worlds, or steal what you need. Join or fight off factions in slow, deadly, tactical firefights, dog-fights Cross nebulas and generated star systems, then jump to stars no one has charted.

Hey all, this is the lightning from a Godot effect pack I've been working on. It's the usual midpoint displacement plus branches, pretty much what drilian's old "Lightning Bolts" post describes.

What I changed is how much the early levels bend. The offset already scales with segment length, and that alone halves it every level. On top of that I only let the first split bend about a third as much, then I ramp it up to full over the next few levels.

With plain halving the first split puts one big zigzag in the middle. To me that reads more like a lightning icon than lightning. Once I damped the coarse levels I got long straight-ish runs with lots of small kinks, and I think that looks a lot closer to the real thing (to my eye anyway).

The GIF is one seed going level by level, then the branches, then the actual bolt on that path with the leader slowed way down. I really like watching it fill in like that!

Not sure if a third is too timid though?

The general approach is to model history instead of use noise. So plate tectonics, evolution and spread of life and extinction events, atmospheric composition, meteor impacts, climate change, and so much more.

This is using Claude Opus 5.5 in my spare time, it's amazing what it's been able to produce (with a LOT of direction). I test by having a Sol system where the planets have the same rough starting conditions and making sure they end up looking like real pictures.

Of course the planets come out very different - no recognizable continents or anything - but they come out feeling right.

Still very WIP, but yes, you can seamlessly fly down from orbit and land in a place like this. It's all Newtonian physics so landing takes like 5-10 minutes, plenty of time to refine a large area around where you're going to land.

My procedural destruction experiments are shaping up into a little siege battler. I added timber destruction, which turns out to work pretty well when I amped up how much splintering the wood does. I was worried it wouldn't read that well since there are far less objects vs a stone tower. And of course a little rag doll yeet for the enemy cannoneer, I couldn't resist.

For testing the enemy is not a good shot here. Thinking of adding some archers with flaming arrows that target the player as well. Mostly having fun with a mature build/destruction system in place, just experimenting with different effects. Hard to see in the video, but the tower stones kick up a nice dirt mist when they land on the ground.

A few weeks ago I shared Blobvarium here: every creature is drawn by code from one seed, no image model, and one new one is born each day.

Since then it grew a small world. The town's buildings, the 41 crops you can grow and the old pottery your creatures dig up while exploring are all drawn by the same code that draws the creatures, so everything shares one pixel and one light.

The best part: about 20 people now come back every day to see the new one. That's tiny, but it's real, and it made my week.

https://blobvarium.com, free in the browser. What would you generate next?

Made a browser runner, and it got a bit out of hand.

There are no hand-made levels. The game listens to the song first: beats, onsets, how loud each bar is, whether it's a chill track or someone screaming over a bass. From that it picks the world, the weather and the tempo, then builds the course. Every jump, slide and kick lands on a beat.

The "level designer" is an evil AI cursor that runs ahead and drops obstacles on you in time with the music. Quiet verse, it's lazy. The drop hits, it panics.

Same song always gives the same level (the seed comes from the audio), so you can learn it. You can also throw your own songs in. Nothing gets uploaded, it all runs in the browser.

Curious what you'd add to the generator?

I use a breadth first search pathfinding algorithm to find a point closer to the player on the nav agent in this scene.. It uses a random chance to calculate for a random jump in the pathfinding discovery phase which is a cheap way of allowing the nav agent to find necessary and faster paths in complex procedural environments. It is much better than trying every possible jump opportunity.

Craig Reynolds' boids with text formations, depth effects, and predator/prey. Type any word and the birds form it, add hawks that hunt them. Everything runs in one index.html, no dependencies. Originally inspired by https://github.com/clainstone/cbirds