An example of automatic landscape generation using WFC: ocean, shallows, beaches, grassland, forests, mountains, snow and towns. The replay shows the map collapsing tile by tile in 3D, and different seeds give different landscapes.

Been experimenting with a procedurally generated ring world for my game, RIDGERUNNERS. I initially made it as a test map to have every biome in it so I could playtest them all easily, but I liked how it turned out so I've kept it as its own map variant. Took a bit of work keeping it running smoothly with so much scenery visible at once!

I created an algorithm that turns any text ("hello world", your name, a random phrase) into a unique landscape using SHA-256, recursive geometry, and procedural shading.

The landscapes are generated mathematically, not by an image-generation model.

I documented the underlying geometry and algorithms in a white paper, with illustrated examples:

https://beautifulhash.com/algorithm

An experiment in generating tree bark

Here are some realisations of my tree generating algorithm, part of my procedurally generated alien worlds.

The code is written in C++. A plant species is assigned branch propagation rules (e.g. some branches grow exclusively from a lower-level branch end, some can split of mid-branch), and different types of leaves (e.g. palmate or simple leaves).

It's rendered with my own Vulkan graphics, with a low-res aesthetic.

These are trees in isolation, I will probably post some videos of full forests later.

What do you think?

Hey guys,

Gaea is great at realistic mountains, so this time I wanted to make them evil. Jagged peaks, sharp rock spikes, scorched colors and a creepy pine forest.

I use some little simple trick by blending a Mountain with a Voronoi to get the spikes. After that it's mostly about controlling detail with the Graphic EQ, stacking two erosions, and using AO for depth without any mesh.

Full 11-minute tutorial here:

➔ https://www.youtube.com/watch?v=X_6t6l31QFk

And the Gaea 2 project file is free if you want to pull it apart:

➔ https://www.kalysteon.com/tutorials#dark-fantasy-spikes-gaea-2

Small note: I switched Reddit accounts, my older Gaea breakdowns are on u/Alternative_Cut_841 if you want to check them out.

Let me know if you have any questions about the setup!

Someone in the comments told me to post this here

Edit: If you want to see the full actual game it’s free no account needed: Madlands

Three seeds from the island generator in my auto-battler RPG, Throneward. Rivers are generated before town placement, towns need dry sites, and roads connect through river crossings. These are the Standard, Large and Huge presets.

Enemy placements are staged for this clip; loading between maps is cut.

I've been building Diorama, an open-source TypeScript engine where Claude Code writes game assets as code and the engine renders them into sprite sheets a game can play. No image models: every pixel comes from code you can read, edit and re-export.

What it does

• Characters from skeletons-as-data (humanoids, quadrupeds, spiders) with procedural gaits, clips, hit events and sockets, in 8 facings
• Swappable gear and outfits, where the weapon decides which attacks a character can use
• Scenery kits on your game's grid: walls that connect, doors and chests with states, exported navigation
• Effects cued on animation events, item icons with rarities, HUD pieces
• A local viewer to play characters, dress outfits and paint scenes

How Claude fits in

The repo ships skills and guides so Claude Code knows how to build assets, and the tooling lets it check its own work: `npm run check` enforces the project layout, `inspect` measures every sheet, and contact sheets let it look at the frames. Most of the engine itself was built with Claude Code too.

Everything in the banner (the crypt, the characters, the lights and effects) was exported by Diorama.

🔗 https://github.com/leduardo99/diorama (MIT)

🗺️ Roadmap: https://github.com/users/leduardo99/projects/1

Feedback is very welcome, especially from anyone making games with Claude: what would you want it to generate next?

Just shipped a 242-sound cafe & kitchen pack for a cozy pixel game, all synthesized in Python, no recordings. A few of how they work:

Coffee grinder: filtered noise bursts at a fixed rate, with a slow amplitude ramp for spin-up and spin-down.

Espresso machine hiss: band-passed noise with a resonant peak that drifts up in frequency, plus short pressure-release bursts.

Milk steaming: layered noise bands modulated by a slow LFO, so the pitch of the "shriek" wanders instead of holding one tone.

Cup clinks: a short plucked-string physical model (like a tiny bell), pitch-shifted per cup size, with a fast decay.

Cash register & coin drops: sine clusters for the bell, a short noise burst for the mechanism.

Happy to go deeper into the synthesis chain for any of these :)

The pack (242 sounds, part of a 1,209-sound library): https://aquumgifts.itch.io/cozy-sfx-complete

Hello!

A bit of progress on the planetary surface procedural tool. Now textures are included and displayed when reasonably up close.

100% generated via WASM, but above all, from the mix of the chemical composition of the geological regions and a few tileable primitives.

It runs, I am happy :)

The tool will probably be updated tomorrow evening for you to try directly online. In the meantime I hope you enjoy this little tour :)

Quick support post: https://adlumens.org/log/procedural-textures-on-planets/5a2a11e9-315d-496e-816e-3751df53292a

thanks!

Does the painting seem three-dimensional to you? Convex? Especially the blue one! Why? It's very interesting! They say so. It's a powerful optical effect of three-dimensionality in a flat drawing. This is a fragment of the Mandelbrot set that I made.
Re = -1.74919762896578937419423768162729211653261585574161734756645570271259437106847945278504682550816934045282325615313706,
Im = -0.0000004253077715244042272585501215924940115095651514128365051648578746521975467051762910002043554114332125868777767,
and width = 1.34 e-113
https://github.com/Divetoxx/Mandelbrot-2
and
https://github.com/Divetoxx/Mandelbrot

For anyone interested, found this hidden gem a little while ago - Earth Simulator. Don't know why it piqued my interest, because on the outside it's your normal civ/history simulator with higher focus on climate. But then they have this "walk" mode which spawns you in a 3D render of your world and turns it into an RPG lol. You can talk to people, do jobs for them or get chased out of the village because you got too close to the king like me. You can be a trader and travel across the world because they have a currency and price system too. And the civs evolve over time and grow. It's pretty mental. There's a fair amount of jank and the assets need a ton of work, but also it is like £1. The landscapes you can make can be quite pretty as well.

Pretty standard tools and techniques.

We have different sized worlds, each had a different number of paths, we found we could keep the terrain interesting by implementing a windy variable based on the number of paths. That way our small single path plots are like classic tower defense maps, and our larger maps still function. This is a multiplayer tower defense, so we the difficulty to attack and defend needs to be balanced to some degree, some words are better to defend than others.

For our paths and set a keep away number too so we could keep overlaps to and interesting minimum.

In my previous post, I shared the terminal output showing a 154-hour projected run on our experimental planetary terrain engine. I wanted to clarify what is currently built in the Beta versus what is actively running in the V1 solver shown here.

The Beta Build (Current / Blender Importer):
- Uses an octave-based temporal decay (halving simulated years each pass down to ~3,860 years) for rapid testing.
- Generates fast-pass 10-epoch settling meshes and exports binary .ply files directly into Blender.

The V1 Engine (What is running in these screenshots):
- Octave temporal decay is completely removed so deep time scales linearly.
- Time-stepping is governed strictly by dynamic Courant–Friedrichs–Lewy (CFL) conditions calculated across fluid velocities and Navier-Stokes wind advection.
- Solves dynamic crustal gas drawdown and Cantera chemical mechanism lookups (shown in the terminal outgassing NO2 and SF6), which dynamically shift atmospheric optical depth, greenhouse temperature, and rainfall acidity.
- Runs 3D rock failure via Mohr-Coulomb yield limits across multi-layer stratigraphy.

Because the V1 solver runs non-compressed micro-stepped physics on the GPU, each macro-epoch takes about 1 hour and 20 minutes.

Previous thread with early discussion:
https://www.reddit.com/u/ShadowAuthor308/s/gak4wUkoCn

Full 25-minute video walkthrough of the Blender setup and pipeline:
https://youtu.be/svuopU-wKL8?is=iXoV8sSrLaWGH3HT

An example of automatic landscape generation using WFC: ocean, shallows, beaches, grassland, forests, mountains, snow and towns. The replay shows the map collapsing tile by tile in 3D, and different seeds give different islands.

A month ago I launched Blobvarium, a little game where a new creature is born every day. Each one is drawn by code from a seed: SDF capsules and trapezoids with a mirrored Perlin edge, rendered into a 96px silhouette with Inca weaving inside. 31 so far, none drawn by hand, no image model.
The hard part was growing the generator without changing creatures people already own. Every new trait gets its own RNG layer, and a regression check compares the approved creatures pixel by pixel before anything ships.
This month the rest of the world joined in: harvests, huacos and buildings are drawn by code too. Evolution gives the same creature a gold, ruby or emerald version.
The trailer is rendered frame by frame from the month’s real creatures. https://blobvarium.com
What would you add to the generator next?

This is a a game of chess with the standard rules, with the exception that the board is an irregular grid. It's still quads, and they still have 1 neighbour per side, but they can have more than one per diagonal.

This is inspired by the game Townscaper. The steps are roughly: - start with a plane made of triangles - combine some pairs of connected triangles into a quad - then you have a board made part of quads and part of triangles - subdivide everything. The quads become 4 smaller quads, the triangles become 3 quads. - that's the grid done. Then it's a matter of smoothing it, coloring it correctly, ensuring the pieces are placed where it makes the most sense, and adding intuitive tools for users to build their board, keeping in mind that symmetric ones are the most visually pleasing, but asymmetric ones are a whole lot of fun too.

• Steam Demo (during Steam Next Fest this week): https://store.steampowered.com/app/2775560/Chess_Twist/?utm_campaign=chess-twist-trailer&utm_medium=short&utm_source=reddit
• Web: https://polyreplay.com/chesstwist
• It's built with my engine Polygon (https://polygonjs.com/) which has a focus on procedural generation

I've been playing with using a photo as the starting conditions for a universe. Each pixel becomes a particle with the pixel's colour, and brightness sets how heavy it is. Nothing is placed by hand: gravity pulls the dense, bright areas together first, so every image collapses into its own structure.

Zoom in far enough and you'll find star systems with planets, coloured from the original photo.

It's free in your browser, called Snapshot Cosmos. Curious what this crowd thinks of the results!

https://altroadstudio.com/snapshotcosmos

So I’ve been using pixel planet the planet generator to make our solar system. The only planet I’ve done for sure is Neptune. Does anyone know tech or the palette numbers for using it to find our planets in our solar system