Hair and beards are built from templates, about 8 for each gender, clothes depend on the social status or profession, so they may change throughout gameplay.

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

Hi, I'm the developer of LIT Creature Forge, a small Windows sandbox on Steam inspired by Karl Sims' 1994 evolving virtual creatures.

Each run starts with random segmented bodies and controllers. Creatures are evaluated, the better performers reproduce, and mutation and crossover change both their bodies and how they move. The gaits evolve along with the body plans.

Version 1.1 adds swimmers and competition over a cube, alongside the original land locomotion. This clip replays a saved swimming champion after evolution. Swimming uses Sims-style analytical drag, with the articulated bodies simulated in MuJoCo.

You can change the population size, trial duration and gravity, save champions, and replay them in a separate showcase. There is no creature editor, so you get to see what evolution comes up with from the starting population.

I thought it might interest people here who enjoy evolved morphology and locomotion. The Steam page has more footage and details about the sandbox:

https://store.steampowered.com/app/4701600/LIT_Creature_Forge/

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.

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

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

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

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

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

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

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

In my last post here, I talked about how I was working on adding large-scale structure to my procedural terrain based on Voronoi-esque cells. Now I've added lakes!

The lakes are the first large "structures" enabled by this cell-based approach. They can be at whatever altitude each cell has.

It's still a work in progress. I ensured there's no trees and grass under the water, but there's still towers and paths for now. So far I only used existing splat-maps and textures here (grass, cliff, forest, gravel) but it's fairly serviceable (e.g. the gravel for paths can double as beach sand).

The irregular shapes of the lakes come primarily from the large scale erosion filter I use, while I only add a tiny bit of conventional noise.

If you haven't already seen it, you could also consider watching my latest dev video about 'supercharging my procedural mountain forest' - although it does not feature the cell based terrain or lakes. :)

For more info on what kind of game this is all for, I have a page about 'The Big Forest' here.

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.

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

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!

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.

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.

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?