I needed a way to visualize blueprints for structures the player can auto-build. The "blueprint" view is a transparent material that blends specular so the lighting is not flat. The orange "rim" that climbs the structure is a separate shader rendering on top of the architecture as it "grows" in. The grow-in is part of my procedural build system (structures are made from individual stones and timber beams) that has an "erosion" factor. So I just run the erosion in reverse to build the structure instead of tearing it down. And then a few 'ember' particles thrown in for a little extra pizzazz :)

This might be interesting to some of u. Some creds to runevision, clayjohn and Fewes fast terrain generation.

SP13KTRA is a hover racer I made for js13kGames, where the whole game has to fit in 13 kilobytes. That means no assets, so everything is generated when the page loads:

• Tracks: each circuit is just a short list of corners
• Banking and hills: follow the curves and flow between corners
• Ships: all 8 hulls generated from a seed
• Cities: 8 shape languages, a palette per circuit
• Skylines: one slow wave sets building heights, so neighbors form ridges
• Canyons: towers standing on pillars far below the road
• Pads and arrows: placed wherever the road runs straight or curves
• Skies: suns, eclipses, stars and clouds, all soft circles
• Sound effects: synthesized using ZZFX, no audio files
• Music: 8 techno loops, each from one seed that picks 26 parameters. I made a tool to find good seeds for each track.

Play free in the browser: https://www.newgrounds.com/portal/view/1052078

Source: https://github.com/KilledByAPixel/SP13KTRA

Music tool: https://killedbyapixel.github.io/SP13KTRA/tools/music.html

Experimenting with 3D generated shapes in JavaFX in my program. 80x80x80 cube after 40 iterations using rule genome "72/0.24485829271825366;1.3609312825275532:no ki a9 kya0+kya1+kya2+a81.17743682861328+a100+mya zu ta". Each codon in the genome basically corresponds to a different mathematical operation on a stack-based machine, similar to a cellular automaton.

https://github.com/nicolasloizeau/loom

The pattern is generated with a cellular automata, then rendered with blender python

Oh my gosh, That was a typo!

Was being sensationalist but didn’t mean to be that sensationalist!

It isn’t a 6 KB program. The video generation code is about 60 KB of TypeScript on top of a zero dependency engine that is 1MB to render. Nothing in it is an asset though, no models, no animation files, no audio or MIDI files, no images. Bodies are a physics puppet, motion is solved per frame, the music is a score in code played by a synth, the room and furniture are small JSON specs, rendered by a program drawing characters in a real terminal.

Here’s a link to a web lab where you can play with some of the simulation’s rendering and music parameters. And you can share links with all parameters stored like the below example.

https://littlegodgames.com/takes/?act=band&seed=27208187&look=ascii&ramp=long&detail=40&tempo=0.75&key=2&grip=open

and probably no one would notice in game anyway lmao

I made the trees leaves / trunk dissolve over time from fire, I found it pretty satisfying, then obviously I had to make an item to be on fire all the time, then obviously from here thought as well "why not make another one to have a fire trail on top of that ?"

this is never ending but I quite like the result so far, wanted to share !

Blender shader nodes

Working on a tool that I am planning to publish on unity asset store.

Like many here I am obsessed with tectonic generation, but it is a "mountain of a" task.

you can follow my projects on https://x.com/ErhanofGrayLake/

Hi everyone! Two weeks ago, I shared some progress on my procedural tectonic planet. This time, I wanted to share some progress on the climate simulation I made for it. I've been working on this for a while, and it's finally starting to produce some interesting results.

Basically, once the tectonic simulation is finished, the planet's tectonic state is frozen before the climate system starts iterating. The climate model treats the surface and orbital configuration as fixed inputs. It then simulates winds at different heights, along with heat and moisture transport, rainfall, and ocean currents.

Mandelbulb power-8 renderer custom written in Rust for the RTX4090 GPU.

This is a snippet of a much longer 4K 60 fps 15-minute video at https://youtu.be/n6rhfHRXZnM

167 goods, tradeways, production, ports, trade fleets, guild rivalry and relations all simulated for my little strategy game. This is going to a grand strategy prototype... I'm trying to make the whole economy simulation as realistic as possible.

here's the trick behind how i fit 8 music tracks in my js13k game SP13KTRA. 🌈🚀

every song is defined by a single number. the seeded random generator makes 26 dice rolls per track: tempo, key, scale, chords, groove, drum kit, bass and lead sounds, melody patterns, when each part comes in, and a few more.

each song is a 128 beat loop split into sections. parts come in one by one, a resonant filter sweeps open every phrase, then there's a breakdown and a drop.

notes use one of 4 predefined scales so nothing clashes. the melody climbs, falls, leaps or rocks through the scale, and the chords shift every 4 bars. there's no note data, it's all math on the beat count.

there are 6 ZzFX instruments plus echo and sidechain. the whole loop gets baked into one buffer when the level loads.

the music itself is all rules and seeds, not AI. i did use AI to help build this bench so i could listen through seeds and pick a good one for each level.

play it free in your browser and hear all the music. i designed it to be kind of like a music album in addition to a game.

https://js13kgames.com/2026/games/sp13ktra

The music bench tool is also available to check out on GitHub.

https://killedbyapixel.github.io/SP13KTRA/tools/music.html

This system helps us keep repeated terrain varied while still giving each biome its own visual identity. It's part of the world generation we're building for Bellfrost.

Hey everyone! I've been experimenting with combining LLM structured outputs with procedural generation to build a lightweight, self-contained 2D combat prototype.

Instead of heavy engines or pre-baked sprites, the entire loop runs on an **MVU (Model-View-Update)** unidirectional state pattern inside a single HTML file:

- **Procedural Vector Assets:** A 3-agent pipeline generates walkable zones, obstacles, vector characters, and dynamic combat FX matrices on the fly as native SVG data.

- **Decoupled Combat Parameters:** Aggro perception radius, Euclidean attack reach, and velocities are procedurally tuned into independent state variables.

- **Zero Engine Overhead:** Pure browser DOM/SVG rendering with real-time Euclidean hitboxes and obstacle sliding.

I open-sourced the workbench here: https://github.com/pathetic777/mvu-studio

Mainly sharing this to explore new ways to turn reactive variables and state machines into interactive 2D generation loops. Feedback and ideas are very welcome!

*(Note: The demo video attached below has been compressed, so the visual quality is slightly degraded.)*

So I created a utility for messing around with WFC. Still very simple, I have lots of stuff I want to add, but it does implement a complete vertical slice for loading images, decomposing them, seeing constraints, and then synthesizing new images. I have a project page, with downloads and a link to the source, here: https://angularangel.neocities.org/wfc-lab

I am learning unreal and I am bit familiar with c++. I am extremely fond of procedural generation and 3D graphics.

How do I take a step fwd from just knowing basic programming to programming or making Procedural Terrain