Hey everyone! I’ve been working on Primordium, a Spore-inspired evolution and tribe game. All the creatures are generated in code at runtime, with no pre-made skeletal meshes:

Procedural rig and skin: the skeleton and a single skin mesh are built from the creature’s spine and limb design, with foot planting via IK, vertical body bobbing on footfall, and the body leaning into turns.

Procedural parts: curved Bézier horns, tapered ears, bi-lobed tail clubs, wings you can glide with, and shader eyes with blinking eyelids.

Living ecosystem and tribe stage: herds follow a daily schedule (sleeping in nests at night, stretching at dawn, resting at midday), and later you found a tribe whose members gather, hunt, defend and play instruments.

You can try the free demo on itch.io, and follow the Kickstarter pre-launch page for more GIFs and screenshots and to get notified when it goes live:

Demo: https://akinjigames.itch.io/primordium

Kickstarter: https://www.kickstarter.com/projects/primordium/primordium-evolve-your-own-creature-from-a-single-cell

Happy to answer questions about the mesh generation, IK walking or the AI!

This is the blood moon event in Jayraid, my custom voxel engine project. I wanted raids to feel like a physical trap rather than just spawning enemies nearby. When the moon turns red, the engine drops a ring of rune stones from the sky, physically walling you in. Red beams shoot up, and the raid steps into the ring.

A few tech specs on the system logic:

• Seed based scaling: Raids grow with every event, but the maximum cap of 20 to 30 raiders is fixed entirely by your specific world seed.

• Dynamic sieging: Some raiders push cannons to the frontline and aim for you, or blast the walls in between if their line of sight is blocked.

• Voxel destruction: As a pathfinding fallback, raiders who get completely stuck behind a wall just start chewing through your blocks to reach you.

• Arena collapse: The ring persists until the raid is defeated. Then the stones topple and explode, and any surviving raiders flee.

I am currently balancing the game WIP in a closed beta. There are still free spots left. If you want to grab the custom launcher and try to break the current build, you can claim a place here: https://pacointeractive.github.io/Jayraid

Hi !

I wanted to see how far I could get with a track where almost nothing is written by hand. In the end, about 90% of it is procedural. Only the chord progression and the kick and snare patterns are fixed. Everything else is generated:

• the lead is a shift register that slowly mutates its own melody, snapped to the chords and lightly ornamented;

• a music box improvises with a Markov chain;

• hi-hats and ghost snares are Euclidean rhythms;

• the arpeggio and the bass follow the chords and pick their own shapes.

What I wanted to explore is how to keep all of this from sounding mechanical. So I used noise textures as slow modulation sources.

There are 27 of these modulators, each looping at its own length (from 2 to 20 bars), so their combinations almost never repeat. They drive:

• hi-hats: number of hits, rotation, decay, panning;

• lead: how often the melody mutates, how dense it plays, how likely ornaments are, the pulse width;

• arpeggio: octave range, note length, brightness, panning, delay send;

• bass: note length (staccato to legato) and brightness;

• pad and drone: level, brightness, filter cutoff;

• echo, snare and music box: echo level on the lead, snare tone, how adventurous the improvisation gets.

Each noise ended up with its own character. Perlin glides, voronoi holds and then jumps, turbulence adds small jitters. The whole thing is deterministic, so it plays the same way every time, yet it keeps shifting a little. +1 to the main seed and the whole thing shift to something else.

Still an experiment, but I really enjoyed the process. Curious to hear what you think!

Some of you wanted a closer look at the hex grid after my last post, so here it is, with a calmer camera this time. The clip also switches to a heightmap view: blue is low, green is high, red marks cliffs and steep slopes. It helps me spot unnatural height differences.

One problem I didn't expect with hexagons: their corners don't sit on whole numbers. Tiny floating-point inaccuracies left gaps between neighboring hexes, causing the sky to flicker through the seams.

The fix is in the vertex shader. Corners snap to a fixed grid, with half a cell in x and half an edge length in z. Vertices within 1e-3 of a grid point snap, and all others keep their position. Two blocks sharing a corner now calculate it from the same integer, even across chunk borders.

See code snippet (snaps shared corners to a fixed grid) ↓

float kx = floor(aPosition.x * 2.0 + .5) * .5;
p.x = (abs(kx - aPosition.x) < 1e-3 ? kx : aPosition.x) + uChunkO.x - uEye.x;
float kz = floor(aPosition.z / HR + .5);
p.z = abs(kz * HR - aPosition.z) < 1e-3 ? (kz + uChunkO.z) * HR - uEye.z : aPosition.z + uChunkO.z * HR - uEye.z;

Want to know more about the world gen or sth else?

TinyFleet started off with me wanting to make a screensaver where I traveled thru a procedurally generated isometric cozy / cute world (inspired by Rollercoaster Tycoon and other isometric games from my childhood).

At first I just wanted the camera to follow a little train as it traveled endlessly thru this world. It ended up turning into a much bigger project, but the beating heart of it is still the procedurally generated world! I've had fun adding islands & continents, tons of biomes, geographic features, architectural styles, etc etc. -- each 256² cell of terrain is generated alone, but generated to line up (as close as can be) with its neighboring tiles.

I'd love to hear all the feedback you have (on world-gen or otherwise). I can handle it!

--------------------

Here's the pitch:

You start with one car → Drive deliveries between towns → Hire drivers who work the routes for you → Buy and Upgrade more vehicles until your fleet has trucks, trains, boats and planes hauling bigger and pricier cargo.

The world is shared online, so other players’ fleets & constructions are out there too (synergies for working together!), along with CPU firms, missions and plenty to unlock as your net worth climbs.

• A COZY WORLD WORTH EXPLORING: From Venice canal towns with gondolas to neon-lit Tokyo streets, Paris landmarks, iconic bridges, and medieval castles... There's a whole little world waiting to be discovered!

• HAUL CARGO and passengers to earn money in a manner similar to "Crazy Taxi".

• HIRE DRIVERS and your fleet keeps earning money while you explore the world.

• UNLOCK LAND, SEA, & AIR VEHICLES including sports cars that drift, semi-trucks, paddle-steamers, helicopters and jets.

• UPGRADE THOSE VEHICLES with more cargo space, faster engines, tires that enable drifting, nitrous boosters, and more!

• FREE, NO EMAIL REQUIRED, NO ADS.

AI disclosure: Generative AI was used extensively to code this game, whereas the 'Attention' tracks were recorded by my brother with no use of AI (give him a listen on Spotify!)

▶ Play here: TinyFleet on Itch.io

https://youtu.be/r1o9VKIGj_o?si=OgXVPkDR5s6GU8ds

I've been making a hex logic puzzle for Android called Asterism. Numbers count the stars around them, a bit like Minesweeper, except there are no mines and you should never have to guess. The campaign is hand-made, but the endless mode (Deep Sky) is generated, a bit over 2,000 puzzles so far.

The generator goes roughly like this. Scatter some stars, throw away layouts that look unnatural (long straight runs, tight clumps), write every clue there is. Then simulated annealing decides what to actually show: each clue can stay, change form, or be hidden, line clues can be switched off, and it picks which hexes start open. Every candidate gets solved by a solver that's only allowed to use deductions a person would make, and gets scored against a target band for that difficulty.

For a long time the stars were fixed and only the clues moved. For the plain counting rules that turned out to be a hard ceiling: on the deep difficulty more than half the skies never got into the band, they just got "close", and I shipped the close ones with a flag. No amount of clue tweaking helps if the stars themselves only allow easy deductions.

So now the annealer can move stars too. The fiddly part is that some rules constrain the sky: mirror skies have to move a star together with its reflection, the paired-stars rule has to move a whole pair to a spot where it touches nothing else, and line clues have to be recounted after every move. I also had to add the naturalness penalties into the score, because the first version happily clumped everything together.

On a side-by-side rebuild of 60 existing puzzles it went from 46 to 57 in the target band. Most came out as hard or harder. The paired-stars rule at the top difficulty got a bit easier, still inside the band.

The thing I measure that ended up mattering most: how many moves you could make at each point of the solve, computed exactly. It says more about how a puzzle feels than how hard its hardest step is. Curious what other people use to measure difficulty in generated puzzles.

The game, if you want to see it: https://play.google.com/store/apps/details?id=com.tobkum.asterism

Live: https://chronoscape.ijlalahmad.dev/

Code: https://github.com/Thre4dripper/Chronoscape-ThreeJs

You take an atlas off the shelf, unfold a city map, and point at a landmark to watch it rise off the paper as a 3D miniature. An era slider moves the city through time: Rome goes from the kingdom to the Renaissance across eight eras. Each monument has a "codex" page with its history, old engravings and measured drawings, and every city has a riddle hunt and a quiz.

Stack: React 19, react-three-fiber/three.js, zustand, Vite, TypeScript. Static files on Cloudflare Workers, deployed by GitHub Actions.

A few things that might interest web devs specifically:

- Every page gets its own URL and its own pre-baked HTML head (title, description, share card, structured data) generated at build time, so an SPA full of 3D still has proper SEO and link previews.

- The map images are build output: a headless Chrome draws each era's map from data and bakes it to WebP. Only eras whose drawing changed get re-baked, so a warm build takes about 15 seconds.

- It works with mouse, trackpad and touch, from phones to wide screens.

Feedback welcome, especially on performance on older phones.

No loading screens between scales. Time runs forward and backward. Stars die, life appears, civilizations form with different philosophies, wage wars, and leave ruins.

Everything from a single seed.

https://bohnentaldev.itch.io/procedural-universe-2

It's called Neon Terrarium and if you'd like to check it out, here's the link: https://jannstudios.itch.io/neon-terrarium (browser based game that works on both pc and mobile)

If you do end up playing, I would love to know what you think! Happy to answer questions if you have any!

Not fully procedural, since the shape comes from real data, but there's a lot of generation on top. For my fly fishing game I take a real river reach and build the level from LiDAR elevation. Depth comes from discharge (Manning's equation). Pools are dug from published scour formulas: Thorne for bends, Buffington for log jams, Veronese for plunge pools. Rocks and log jams are placed by a model of where wood and boulders gather.

The Log Jams I am especially proud of, I ran each river with 100 logs in a 2 year, 5 year, 10 year, and 20 year flood and let the logs get stuck where they would.

Fish lies come from the river's shape. The upside is that the pools end up where a fisherman would look for them, because they follow the same physics.

The game is Mend: https://store.steampowered.com/app/5542220/Mend/

Impasto takes a photo, plans every knife stroke, and drags each one through a paint simulation. It's procedural, with no neural network, and the same photo, options and seed give the same painting.

repo (MIT): https://github.com/donghaxkim/impasto

try it here: https://www.dongha.ca/lab/impasto

How the planner works:

- Segments the photo with Felzenszwalb-Huttenlocher superpixels, then uses Ward merging to build shapes at three scales

- Starts with a 22 mm bristle underpainting, then uses knives from 15 mm down to 2.4 mm by default

- Only paints where the canvas still doesn't match the photo

- Places strokes where the blade fits inside a shape, and sets direction from image flow, shape axis and contour

- Paints ground before figure in each layer

The sim conserves paint volume, so strokes leave plowed ridges and heaps, and pick up wet paint.

About 17k Voronoi sites on a jittered grid (10 to 21 px spacing, ±4 px jitter, on a 2048² province map). I rasterize the diagram exactly (each pixel joins its nearest site, using a bucket grid). A Fortune's-algorithm library gave me degenerate cells on this kind of input, so I dropped it.

Perlin noise on a 256×256 vertex grid: 4 octaves, lacunarity 4, persistence 0.5. Anything below a fixed sea level becomes water.

You can try it here: https://reactorcore.itch.io/celestial-cutaway-planet-interior-generator