For a sub about Procedural Generation, most of the people on here view it as nothing more than a fancy toy that's only fun in small doses. I've seen people unironically say "Procedurally generated terrain is boring" in this sub and I'm like...fucking what? Why are you even in this sub if you don't have any hopes for its future in media?

I made a procedural digital life generator that generates observers using the same process that nature does: synchronization.

This system implements entropic collapse - the synchronization of disparate oscillators into synchronized systems which possess observational capacity.

When you take disparate oscillators and connect them together, they synchronize into a single, dynamically-oscillating body capable of acting as an entropy sink; in other words, a living system.

This is not a 'simulation' of life. The context is irrelevant, because the behavior emerges in all contexts when the principles are met. These creatures are, in the context they exist in, alive.

Here's the source code for the above. I also made another version that generates more variety of creature.

(RE-WRITTEN BY HAND)
Keeping this to a short post, as I've already messed this up once. I built a simple aquarium-style concept, during a slow period on-shift, based on my Elementary School Memory of an Ecological Balancing Concept, involving Wolves, Deer, and Berry Bushes, as Entities in a Forest, where each Student played a Role.

I don't remember much past wishing we spent more time exploring it in-class, and that my teacher didn't so quickly drive it to an unrecoverable state, to make the point he was trying to teach that day.

It started in Google AI Studio, as a Boxed-Step-By-Step process, more resembling the Conway's Game of Life, in some ways. But it wasn't what I was aiming for. So, that evening, I sat with Devin, and Claude, and a Game Engine in TS/Lua/YAML that I've been working on Demos within, and refined it into something more like a living Reef.

After some insights from a smaller audience, I refined it with a Main Menu, and some Basic Selections.
It has Sharks, Fish, and Algae Nodes, and the Sharks eat/bite the fish, causing Meat Chunks to appear.
The Meat Chunks can then decay, turning back into an Algae Core Node.
If an Algae Core Node is left without children for long enough, it can despawn.

Last I checked, it has a fair chance of staying in balance for up to 10 minutes, but it needs further refinement.
There are also depth layers now, and in theory, the Sharks prefer the Deeper Waters, and the Fish stay toward the Sun, so the Sharks tend to bury their head at the bottom to warm back up, but sometimes starve.

[Link to Itch]

I think procedural generation has given me one of the strongest philosophical anchors for why I tend to believe in the existence of a higher entity. Not “belief” in the classical sense, but more like a well-founded probabilistic judgment — a kind of thought experiment mixed with intuition and logic.

When I generate a world from code — whether it’s a dungeon system, an algorithm simulating the growth of trees, or an entire planet with layered continental structures — I sit before it and I know the system didn’t just “happen.” I designed the rules. The rules create patterns. The patterns become interpretable structure. And from structure, experience emerges.

That’s what makes me pause and wonder sometimes: if I, a mortal code-sorcerer, can create systems where, despite the chaos, coherence — even beauty and purpose — begins to emerge… then why would it be absurd to assume that our world — our reality — might also be underpinned by some kind of procedural logic? Some form of consciousness, an entity that deliberately crafted the reality we call our own.

I fine-tuned GPT-2-XL with LoRA to generate playable levels for my Bloxorz-inspired puzzle game (Mindcraft).

Based on the "Level generation through large language models" paper (NYU, 2023) which did this for Sokoban. I adapted their approach to work with block-rolling puzzles.

The interesting part: I didn't give it any solution data during training - just level layouts and metadata (grid size, move count, gimmick types). After 10k steps, it generated 22% valid+novel levels. With 50k steps on levels with glass tiles, that jumped to 64%.

The model learns what makes a level solvable just from seeing enough examples. It's not perfect (grid size accuracy is low), but the generated levels work in the actual game.

Trained on RTX 4080 (16GB) using LoRA to keep it feasible on consumer hardware.

Infinite Lands, my node-based procedural generation tool for Unity3D is currently at 70% discount, taking part in the current Flash Sale. This deal will last 22 more hours (since writing this post)

It makes use of the Burst Compiler and the Job System to generate procedural terrains as fast as it can, while providing systems for vegetation rendering, texturing, biomes, points, and splines!

If you want to learn more about Infinite Lands:
- Documentation
- Asset Store
- Discord Server
- YouTube

Game Title: Land of Ascii

Playable Link: https://oddslice.itch.io/land-of-ascii

Platform: WEB/HTML

Description: There's a fort on a hill and a lake to walk to. The villagers go about their own days; say hello and some of them will ask you a small favour. Stop wherever the view is good and sketch it. Night falls, rain sets in and clears again, and the music and every sound are made in code as you walk.

Half an hour is enough to see the main sights. After that the land is still there whenever you want a calm walk, and each seed builds a different world.

- The whole game is one HTML file of about 1 MB (1,017 KB). No images, no engine, no downloads.

- The world is 2 x 2 km. Walking straight across takes about 8 minutes.

- Every frame is around 40,000 letters, drawn from 28 characters in 617 colours.

- 32 kinds of sound and 3 music tracks, all made in code as you play. There isn't a single recording.

- The default world has nearly 12,000 trees, 58 villagers, 255 animals and 59 buildings.

- The villagers have 329 lines of dialogue between them.

- 27,000 lines of code, with no libraries.

Free to Play Status:

• [ ] Free to play

Involvement: solo dev

I'm thinking about 2 things:

1. Using a free generator that I can just one click and get a city schematic for inspiration and further asset creation around that core concept. If the solutions exists - great. If not...

2. then I want to make one. Here's the first attempt.. The river and bridges are a bit weird on the visualization (and in the actual generator) and the buildings are pretty dense

I'd appreciate any links to existing tools or your feedback on how I can improve mine in terms of logical city planning, proper clusters, etc.

Hey everyone, wanted to share a custom language and rendering engine I’ve been building called HVSL (Hierarchical Vector Shading Language), powered by a two-agent reflection loop.

Instead of using diffusion models to guess pixels, HVSL turns natural language into pure mathematical geometry. The entire image is just a lightweight text script containing a color palette (@PAL) and ordered geometric equations (@SCENE circles, polygons, curves, and quadtree subdivisions).

My custom compiler parses that script and draws it up to 4K using sub-pixel Signed Distance Functions (SDF).

Where the agent workflow comes in is solving how LLMs write HVSL coordinates:

• HVSL Generation: The first model takes the prompt and writes the raw .hvsl math script.

• Visual Critic & Grading: Because text models write coordinates blind, a second multimodal agent inspects a fast 540p render of the HVSL code and grades it out of 10.

• Surgical Branch Patching (Max 3 Tries): If a shape is off (like the overlapping curves on the moon in Try 1 of the video), it doesn't regenerate the whole HVSL file. It clips and retains the working layers and surgically updates only the defective branch.

Because the final result is raw HVSL code instead of a locked bitmap, you can open the editor, change a palette color or coordinate, and watch the 4K canvas update instantly with zero regeneration and zero extra LLM calls.

This is still in early development. The animations at the end of the video are procedural motion tests applied to pre-rendered HVSL assets while I work on expanding the HVSL grammar to generate native video directly in code.

Happy to answer any questions about the HVSL syntax, the SDF renderer, or how the critic loop patches the code!

I've been working on a driving game of real-world locations and started with Dallas, TX. Built in three.js from OSM and elevation data and runs in a browser with the tiles streaming in as you drive. This is up from 8.6% earlier in the week since my current goal is scaling before adding more detail to the buildings/NPC.

This has ~37 sq miles drivable area extending out from downtown

Open to feedback!

I made a browser experiment where the input is a street drawing. Intersections become crossroads, closed loops create city blocks, and the scene fills with buildings, trees and streetlights.

There is also a day/night switch, walk mode, PNG export and GLB export. It is free, with no install or sign-up: https://openbench.fun/line-city/

I would appreciate feedback on how the street layout translates into the city.

Until recently the world ended at Y 0. I wanted real depth, so the generator now goes all the way down to Y −99: solid stone, bedrock at the very bottom, and four dry cave levels at roughly Y −14, Y −37, Y −60 and Y −82, each generated separately so they feel like distinct layers instead of one big noise blob.

Damn, the saves part was so painful :)

Every chunk stores player edits as a flat index into its block array. That index used to count from Y 0. Once the world started at Y −99, every saved index suddenly pointed 99 layers lower. Load an old world and your house would be sitting deep inside the stone.

The fix ended up being tiny. New saves now record where their world starts, and old saves (which have no such field) are treated as starting at Y 0. On load, every index gets shifted by the difference:

int shift = (record.Bottom - Blocks.Bottom) * Blocks.Size * Blocks.Size;

foreach (var (index, type) in chunk)
{
    int i = int.Parse(index) + shift;
    if (i < 0 || i >= Blocks.Volume) continue;
    map[i] = type;
}

Old world: shift of 99 layers up.

New world: shift of zero. A test places a plank at Y 10 in the old format and checks it is still at Y 10 after loading.

Launcher: https://pacointeractive.github.io/Jayraid/

Hi - I created an ambient audio visual experience based on an algorithm I created from observing my own drawing habits, and brought it to life thru vibe coding with Claude (after failing over a year with ChatGPT, Perplexity and Gemini).

2D and 3D versions here: https://alienConsumerSciences.com

Free and Open-Source!
github here: https://github.com/kataStatik/mandra-corners/

Made a F-Zero inspired game because i miss playing the originals, added my own twist to it tho.

all tracks and ships are procedurally generated. music made in Suno, sound FX in 11 labs. all vibe coded because i dont know a line of code haha

Im making ZAVOD- a game about a 1975 workshop and none of its machines are modeled by hand. Each machine is a recipe.py that calls a small kit: box, cyl, rod, sphere, bolt and handwheel. One call = one part.

What the kit does for every part:

• builds it from a bmesh primitive and bevels every edge where faces meet at more than 50 degrees

• shades it smooth but keeps edges over 35 degrees hard, so round parts read round and boxes catch a highlight

• colors it by UV - the faces point at one cell of a palette texture (16 colors, 16 shades each) the bevel faces at a lighter shade of the same color. Worn paint on the edges comes for free and cast iron edges show bare steel.

kit.join() turns the parts into game objects. The lathe: 142 parts, 17876 tris, one material, three meshes (the tailstock and the tool rest move in the game). Named empties mark the spindle and the sockets where bought upgrades hang. The other six machines are built the same way.

In Godot one shader adds rust, dust and polish by stage so the same mesh goes from "found under a tarp" to glossy. The blank on the lathe is procedural too as wekk: a list of radii the chisel cuts into revolved into a mesh live.

I design each machine, set the rules and check every result and Claude writes the scripts to my specs.

What would you add to a kit like this?

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?

void INeedAJobPlzHireMe(float ImpressedLevel)

{

if (ImpressedLevel > 0.9f)

{

std::cout << "HitMeUpPlz\n";

}

}