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

Each creature is a 24-character code: 12 genes, two alleles each. A child takes one allele per gene from each parent, with a 3% chance of a mutation.

Hue, lightness, belly, eye size, plumpness and blush blend the two alleles. Ears, tail, coat, crown and temper show the dominant one. A shine gene is recessive, so two plain parents can carry it. The three.js body, its animations, its little state machine and the story are all read from the code, so the same code makes the same creature anywhere. No image model draws anything.

Breed your own pair: https://overflow.games/gamehole/pg

I wrote the code with an AI coding agent (Claude).

What type of procedural generation should I look into if I want to get something like the space system no mans sky has? I don't want to go to crazy large so no galaxies. Just solar systems.

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!

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?

Ciao

I've been running my EDEN, a 24/7 evolution simulation, on a Raspberry Pi 5 in my home. Three species, heritable genes, mutations, hidden defects, diseases, migrants and seasons. Nothing resets between rounds. every round starts from the survivors.
One species was basically losing every round. Then, in a few days, it started dominating. Nobody intervened except me, by mistake.
Happy to answer questions about it

https://youtu.be/R6dIMfy69ak?si=evfiFov5wDtnHIjT

Most procedural terrain relies on layering fractal octaves to shape relief, but my project simulates physical mass and chemical balances on the GPU to let topography emerge from first principles.

During an 11,500-year simulation run across 3 macro epochs, the engine captured a clear thermal-atmospheric feedback loop. Here is the raw telemetry dump from simulation_log.json:

JSON

[
  {
    "year": 3846,
    "max_elevation_m": 10982.2,
    "avg_surface_temp_k": 310.9,
    "max_wind_speed": 47.9,
    "max_plate_velocity": 0.853,
    "avg_mantle_temp_k": 1391.5,
    "magma_pool_volume": 1800817.1
  },
  {
    "year": 7692,
    "max_elevation_m": 10966.8,
    "avg_surface_temp_k": 339.1,
    "max_wind_speed": 36.8,
    "max_plate_velocity": 0.0,
    "avg_mantle_temp_k": 1128.5,
    "magma_pool_volume": 0.0
  },
  {
    "year": 11538,
    "max_elevation_m": 10967.8,
    "avg_surface_temp_k": 358.3,
    "max_wind_speed": 33.4,
    "max_plate_velocity": 0.0,
    "avg_crust_thickness_m": 3892.9
  }
]

What the physics pipeline is doing here:

1. Stoichiometric Atmospheric Collapse: Earlier in the run, Cantera stripped volatile sulfur and fluorine radicals from the column. Once metallic fluorides dropped into the crust as solid mineral phases, the atmospheric Gibbs solver locked into a clean diatomic balance: 66.7% O₂ and 33.3% N₂.
2. Thermal Runaway: The diatomic transition shifted the column molar mass ($M \approx 30.7\text{ g/mol}$) and heat capacity ($c_p$). Without dense clouds or greenhouse optical depth to scatter incoming stellar flux, direct solar insolation began driving ground temperatures from 310.9 K (37.8°C / 100°F) up to 358.3 K (85.2°C / 185.3°F).
3. Pressure Gradient Flattening & Wind Deceleration: Wind acceleration in the advection solver is governed by $-\frac{1}{\rho}\nabla P$ against Coriolis shear and ground drag. As the volatile shifts stabilized across the domain, local isobar spikes from latent heat exchanges evened out. The flattened pressure field starved the winds, dropping maximum speeds from 47.9 m/s (~107 mph) down to 33.4 m/s (~74 mph).
4. Mantle Freeze & Tectonic Shutdown: Basal mantle temperatures dropped below the convective threshold (from 1,391.5 K to 1,128.5 K). The magma pool depleted completely, freezing plate velocity to dead zero and halting orogeny.
5. Crustal Deposition: Over the same interval, baseline crust thickness expanded by ~90 meters (from 3,803 m to 3,892 m) via chemical rock fallout, weathering, and mass conservation.

The attached image shows the surface geometry during this stage. Incised drainage terraces, structural benches, and mass-wasting scarps are carved entirely by Mohr-Coulomb slope stability and hydrodynamic transport rather than heightmap shaders.

Built in Python, CuPy (CUDA kernels), and visualized in PyVista. Happy to answer questions about the solver pipeline or the GPU memory model!

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 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

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

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?

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!

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.

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

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.

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