Hey everyone! I'm Kyle, the solo developer behind OakTree Games, and in the second episode of my devlog series for my factory game, Cosmic Scale, I talk through how its galaxy grows out of one seed. I learned procedural generation by building this, so I'd love to hear from people who know it far better than I do.

The seed is a 32-bit number, so there are 4,294,967,296 of them, and if you started one new game every second it would take you about 136 years to see them all. From that one number the game works out the whole galaxy: every star branches off into one, two, or three more systems, so a system's address is really just the list of turns it takes to get there from home, a lot like your GPS telling you to take the second right, then the first left. A system only gets generated once it shows up on your map or you jump there, and each galaxy has room for over 2.3 quintillion of those addresses, so there's always somewhere further out to explore.

Down on the planets, the land is a perfectly smooth sphere on purpose. A five-octave Perlin field, each octave twice the frequency at half the amplitude, decides where the lakes and oceans dip and where the rocky ground shows up, and a separate, broader four-octave field sets the moisture. Biomes all come off one climate table, with temperature from latitude and moisture from that second field, and every planet type gets its own slice of that table, kind of like setting its own thermostat.

The save never writes any of that down. It keeps only what you've changed, like your buildings, your inventory, your research and where you're standing, and everything else grows right back from the seed when you load in. The seed itself is four bytes, and in one of my saves I had traveled five star systems out from home and it was still only about 25 KB.

For anyone who has built something like this, how did you decide on a branching rule that still feels like a galaxy when you're standing inside it? And if anything in the video comes across as unclear or rough around the edges, please tell me.

It's here! Segment Display is now available for Blender. A fully procedural Geometry Nodes add-on for creating segment-style displays (7-seg, 16-seg) right from the N-panel.

🔗 Get it and explore everything at orionnovemberstudio.com

I’m gradually building the game of my dreams—a "screensaver-style" game designed for a third monitor. It features logistics, trade, and light simulation, all set within a procedurally generated world—with absolutely no fast travel. The game world is a ring of civilization, spanning a radius of roughly 8,000 kilometers, which gradually fades out toward the edges. It integrates Open-Meteo data and a simulation system for day/night cycles, designed to mirror the actual weather and time of day outside your own window. It’s a very slow-paced game.

The game features a basic economy that I am gradually balancing, a fleet of rovers that is slowly expanding, various stations and resource-extraction outposts, and a range of different missions. So far, about 30% of what I’ve planned has been implemented. The game runs in a browser and currently has a size of approximately 2.7 megabytes; I expect the final version won’t exceed 10 MB. It’s designed with a retro aesthetic—partly as an attempt to create the kind of game I’ve always dreamed of, and partly as an experiment in realizing a vast space using minimal resources.

Since this game is being developed for personal use, there is no detailed documentation for it at the moment. That said, you can play it without any major issues—aside from the typical quirks one might encounter in a game that is still deep in the development phase.

subr: https://www.reddit.com/r/Xanatuya/

the game itself: xanatuya.space

Next step after the dividing cells: each amoeba is a bubble of the same foam rule. Its skin pulls taut and it keeps its area. On top of that its edge reaches out:

- By smell: food gives off a smell that spreads and fades. The edge bulges where the smell is stronger than its own average, so a pseudopod reaches towards food and the back pulls in. In blind mode it wanders at random and only finds food by touching it.

- Eat, grow, divide, starve: what it eats becomes area. Living burns that area away. At twice its size it divides, and starved to a third it dies.

Try it: https://geotyper.github.io/taut/amoeba.html

The game is about exploring the infinite, endless procedural world of stars, planets, galaxies. The game does not include real planets or real stars or galaxies. Real names can be observed at the home location and names like "Andromeda" or "Milky Way" and the whole solar system. Tho it is possible they will not be in soon updates.

Link: https://astro.ableproman.hu/

The game is inspired by Space Engine, that is only on Steam and is not free. I made this game for people who want open world real scaled worlds to explore and visit throughout the universe for free without downloads.

Graphics are all made with three.js and looks incredible. I am updating until it works perfectly.

It works on desktop and mobile too.

I am ready for any review or feedback of the game!!

(The images are from the actual game from browser!)

I made this using Blender nodes. You can watch my YT tutorial if you want to make something like that.🙂

Not that I have built it yet, but any function of space simulation, it is very math involved, especially in higher dimensions. A major discovery though, for obscuring, you only need object A is in front or behind object B, not exactness needed. Also needed is where pixels go, but with the correct rotations, set one function set to another and you have where one pixel goes, repeat for all pixels. The obscuring can use either the integral form over a finite arbitrary number or just derivatives of the original function or both, in many cases just Euclidean distance could work, but not all. The distance function is an integral of a square root of a sum of squares, so avoiding that is awesome. Good luck everyone. X E.

Every city is uniquely generated from a random seed, based on the QR code requested. Tons of sliders to control the generation rules!

I'm making ground impact effects in Godot, and I draw the crack in polar coordinates in the fragment shader. I take each pixel's angle and radius and measure the distance to the nearest of ten arms. That's the usual polar trick, nothing new. But since it's a distance field, more arms cost basically nothing.

My first arms only bent with one smooth octave of value noise. They looked like tentacles!

Real cracks are mostly straight with kinks. So now each arm gets the slow bend plus a weaker, faster one on top, and I scale the bend up with the radius so the arms leave the center almost straight.

If every arm reaches the rim it's a sea star. I let each one stop somewhere between 62% and 100% of the radius, and one branch peels off part way out.

I also stand the rock shards on that function with the same seed. That way I never get a shard sitting next to a crack.

I ported the function to numpy for the picture. Does anyone have a trick to make the branches look less glued on?

Managed to get through a full map playthrough on the Steam Machine now most bugs and glitches have been resolved (C++/OpenGL/GLSL). Final polishing before release (+ a few more candidate maps to clean up and include). It won't sell but I'll continue working on it anyway.

I'm the creator of Cbirds, a 2D/3D bird flock simulator that runs in the terminal, written in C99 and inspired by Craig Reynolds' Boids algorithm. The video is the 3D mode running in Ghostty on macOS.

I started working on the 2D version in September 2025, mostly out of curiosity. I wanted to see whether it was possible to build a real time simulation inside a terminal using the Kitty graphics protocol.

The idea came from two places: antirez's amazing C64 terminal emulator (https://github.com/antirez/c64-kitty), and a lecture from the Foundations of AI course at Politecnico di Milano, where Professor Pier Luca Lanzi was discussing multi agent systems.

I really dislike relying on third party libraries, so I decided to implement everything from scratch in C99. I did get quite a bit of help from coding agents along the way. One interesting thing I ended up building was a custom GIF encoder, which allowed the agents to visually inspect the simulation and check whether their changes were working as intended.

The original 2D simulation is conceptually quite simple, based on the three classic rules from Craig Reynolds' work: alignment, cohesion, and separation.

In 3D each bird only listens to its nearest neighbours, seven by default as real starlings do, instead of everyone within a radius. A pull toward a roost keeps the flock in view, and a slow drift in the air over the roost does the rest: the bands, the splits and the folds in the video all come out of those rules.

From there, the project gradually grew to include:

- A full 3D simulation and renderer, running entirely in the terminal
- Real time tuning of simulation parameters
- The ability to pipe text into Cbirds and watch it fly around (e.g. `cat file.txt | cbirds`)
- Multiple flocks with different colors, with runtime controls to make them merge or avoid each other
- Hawks that chase the birds
- Different rendering techniques, ranging from PNG images displayed through the Kitty graphics protocol to Braille characters
- IPC support that lets birds fly between different terminal windows

What started as a small experiment has turned into a much bigger project than I originally expected.

Some of you may have seen the browser port posted here last week (https://nicobrenner.github.io/flock/). This is the terminal program it started from.

Source: https://github.com/clainstone/cbirds
Command in the video: `cbirds --render kitty --3d --color prism`
Install: `brew install clainstone/tap/cbirds` (also MacPorts, apt and Nix, see the README)

Spent about 4 years chipping away at this track generator. First in Unity then ported to Godot 3.6. It also supports intersections and simple highway interchanges. I enjoy sitting back and seeing what it comes up with.

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've been working on Planet 0 Drive, a relaxing, low-poly 3D driving game built with Svelte, Three.js, and peer-to-peer multiplayer.

It's an endless driving experience where you can cruise around at your own pace, explore the world, discover interesting spots, chase new records, or compete and coordinate with friends.

On the technical side, the game features:

• Three.js for 3D rendering, procedural world, and weather
• Peer-to-peer multiplayer with optimized network updates and movement interpolation
• Spatial audio and performance optimizations for smooth gameplay
• Version-compatible rooms to keep multiplayer sessions in sync

Planet Zero Drive started with the idea of a relaxing drive through a landscape that keeps unfolding. It also gave me a place to experiment: how much world could I generate, how far could I render it, and what would it take to keep driving (fairly) smooth on a phone?

Play: https://planet0drive.vercel.app/

Blog https://zackwebster.com/blog/building-planet-zero-drive

Nothing groundbreaking here but I've recently used AI to put my old C++ hydraulic erosion code onto CUDA, which sped it up from 10 minutes per planet to 10 seconds. And doing that I can finally tweak in almost realtime to find nice settings. Anyway here's one planet that although unrealistic looks IMO very cool

Hello Again, came back with another quick video showing the settlement growing and adapting to the games terrain

Here’s a showcase of everything procedural in Out of Pixkrieg, my RTS extraction prototype!

Virtually everything in the game relies on procedural generation. Terrain, units, animals, structures, and items. This system merges two previous projects of mine: a 2.5D terrain generator and a pixel creature generator.

Want to see how these graphics look in a live game?

Try out the running prototype at https://pixkrieg.com/.

I'd love to hear your thoughts!

A tech test for Florasynth: various trees grown by simulation, with a frame captured each year to build a timelapse. The first tree is pruned partway through and grows back.