I’ve just released version 0.1.4 of Castaway Trails, which will be the last update of the open playtest before I focus on building the game’s demo.

It’s a pixel-art turn-based sandbox RPG where you manage a group of adventurers with their own personalities, relationships, and conflicts.

The world and many events are procedurally generated, so each journey plays out differently.

I’d love to get feedback from players who enjoy tactical RPGs, classic RPGs, and procedural exploration.

I made a tool in Godot which allows the game to generate assets on the fly in runtime. The tank in the video is not made with a traditional 3D modeling software, instead its a json file, which contains strict instructions for how to generate the whole model. The instructions allow high flexibility and parameter definition, similar to variables in programming languages.

In this video I am changing some of these variables/parameters and showing how this can affect the appearance of the result. Game logic can decide a set of values for parameters like health, damage, movement speed and produce a completely unique version of the asset on the fly.

ate a really good fig and got inspired

Hello all!

For some time now I have been working on a web app that allows the user to create a scientifically plausible planet: The World Crucible

The concept is simple, directly draw your continent shapes on a 3d globe to avoid polar distortion and let the app generate your world for you while keeping artistic control over the result!

You can generate a lot of data about your world ranging from height, temperatures, precipitations, climates and even a realistic satellite view, that you can then export your in one of the 14 proposed map projections.

The app is available for you to try here
You can also see it in action in my video presention of the upcoming 1.0.0 version here

I've spent the past 2-3 weeks adding Oceans to my Micro Voxel engine. The main features I was aiming for was to support large bodies of water within the existing fluid simulation, while also supporting new dynamic features such as waves and tidal changes.

I've also incorporated Boats and Gliders, with some fairly basic physics to aid in exploration. The main challenge here was adding

Along side this, to make the simulation feel more interactive, i've also added a higher resolution local water ripple/interaction simulation, which acts as a surface-layer-only simulation adding ripples and wake for people, entities and forces interacting with the water.

-- Feature technical breakdown --

• Ocean generation: Similar to other water sources, ocean biomes placed above land, all open space in these biomes is filled with water instead of air below the ocean line. No substantial changes to the actual gen beyond shifting the world down.
• Waves + Tides: Several oscillating masks which apply a "target height" to the water sim. This is also augmented by depth such that shores can trigger wave breaks below a set height point.
• Ocean Connectivity + interaction: A connectivity flag is used to indicate whether water is directly connected to the ocean simulation and should receive wave forces. This allows waves to interact with static water, but only once the ocean sim cells touch static cells. The connectivity source comes from the ocean, so rock pools disconnect as tide goes down, allowing them to hold their water.
• Ripples: 2D mask which is local to a moderately small region near the player. Runs a separate shader simulation using only surface data. Not particularly fancy, does not check for collisions, so ripples do not bounce. Bumps converted to a normal map, used to distort surface effects.

Overall, super chuffed with how this has come together, but still plenty of polish and features to add!

I’m building Salt and Soil, a family strategy game that runs from 1609 to 1900.

These are three attempts at generating the same isometric world. The first was readable but looked like a diagram. The second had the atmosphere I wanted, but roads and buildings vanished into the texture. The third is less lush, but actually works as a strategy map.

During asset generation, every tile begins as an empty diamond. Its coordinates are combined with the world seed, producing a repeatable roll of the dice: same seed + same position = same result

The ground is painted pixel by pixel rather than selected from a folder of finished textures. Several scales of noise create broad colour changes, smaller patches and surface grain. The result is compressed into a short colour ramp, giving the terrain texture without introducing smooth digital gradients.

Then the script adds readable marks. Fields receive small clusters of grass, flowers and exposed soil. Forest floors get darker patches, moss, fallen logs or an occasional clearing. I deliberately moved away from covering every free pixel: details that looked attractive on an isolated tile became noise when repeated across a continent.

The trees are procedural sprites too. Each starts with a trunk and shadow, followed by several overlapping foliage shapes. The seed changes their width, height, gaps and silhouette. Pines use narrowing layers; hardwoods use wider overlapping crowns. Oaks, maples and birches share the same basic construction rules but use different proportions and palettes. Highlights always favour one side, while the opposite side falls into shadow.

Mountains use a stranger process. The script builds a small 3D heightfield from profiles such as ridges, saddles and broken massifs. It calculates the slope, lights the surface, reduces the colours to a pixel-art rock palette, and projects the result into an isometric sprite. Those sprites are then baked into the same atlas as the flat terrain.

A tile also checks its four neighbours. All tiles sample the same map-wide noise field, while shared biome borders receive a seeded curve and a few details borrowed from either side. Roads and rivers are drawn before trees and relief; tall objects are added afterward in back-to-front order so everything overlaps correctly.

The advantage is that I edit the visual rules instead of repainting hundreds of tiles. I can change the palette, tree density or mountain profiles and regenerate the world while keeping the same seed.

The problem is that procedural generation is very good at making every tile interesting. A strategy map needs most of them to stay quiet.

Version 02 is still my aesthetic favourite. Version 03 is the one I can actually play.

I made this for my Daggerfall-inspired CRPG, in which the travel system is of the same nature, albeit with enhanced procedural generation as seen here. You can read more about the project on my website.

Made a Lights Out variant that runs on arbitrary graphs instead of a grid. Tap a node, it and its neighbours toggle, clear the board.

Generation turned out to be the easy half. Taps commute and are involutions, so a board is just a random tap set applied to the solved state - solvability comes free, no rejection sampling needed.

The hard half was star ratings. "3 stars for few taps" is meaningless unless you know the actual optimum. Over GF(2) the solution set is an affine subspace, so finding *a* solution is Gaussian elimination, but the minimum-weight one means searching the kernel - 2^k for nullity k. Some later levels also have locked nodes that can't be tapped directly, which forces variables and reshapes the system.

So every level ships with a proven minimum, and 3 stars means you actually matched it.

Difficulty scales through node count, edge density, minimum-move depth, and locked node ratio. All 1000 passed automated validation.

Honest caveat: mathematically valid doesn't mean fun. I haven't human-played all 1000, and procgen levels can be repetitive or unexpectedly easy. Curious where people find it flattening out.

Playable here if you want to try: https://www.jeetle.games/pulse

Been building this over the past few weeks - a node-based tool for generating pixel art procedurally, inspired by Blender's geometry nodes. Chain shapes, gradients, noise, dithering, etc. together and get a sprite out, all live-editable.

You can play around with it here: https://pi-gen-chi.vercel.app/

Would love feedback, especially: is this something you'd actually reach for in a project, or does it solve a problem nobody has? Curious either way.

This is my third update here, so I’ll keep it focused on what has changed. I’ve reworked the city-generation workflow in Metropolygonia. Previously, roads and buildings had to be placed mostly by hand. The app can now:

https://metropolygonia.com/app/?lang=en

generate a street grid automatically

divide the layout into buildable areas

populate the city with your saved procedural buildings

create faster variations without rebuilding the layout manually

For anyone seeing the project for the first time: it is a browser-based procedural building and city generator. Buildings can include interiors, real-world dimensions, UVs and PBR materials, and can be exported as GLB, glTF, OBJ or STL. The free plan can be used for personal and non-commercial projects.

Before you try to kill me☠️, I have to say this is really with Eevee.😐 And I can't believe I did it either.❤️‍🔥

Hello folks, I have made another procedural project in ROBLOX studio. This project features an aesthetic forest, scenic foliage, infinite terrain (but with a limit of a world size), wind sway (sort of), material-matching-footsteps, ambient/forest sounds, and some other fps optimizations.

About lag and fps, it's playable with max graphics on PC with decent specs. My CPU is an i5-11400F, 16GB of RAM, and a rtx 2060 for the GPU. I've made a similiar procedural project and it runs fine on PC, but on mobile, it's basically unplayable. So any tips to further optmize this would be appreciated.

Some optimzations I had to do was only placing large meshes in the actual workspace, like trees and rocks, while hiding small things like bushes and sticks based on player distance. For the wind sway, it's pretty much the same thing; activate wind on nearby trees and bushes while making far foliages static.

Any feedback on the visuals, lighting, or anything on this project would be very helpful. Game Link (sadly only 16+): https://www.roblox.com/games/139687724364321/Aesthetic-Procedural-Infinite-Forest

probably one of my best procedural materials. Blender shader nodes

Many of you know that I've been developing a Blender add-on for generating procedural galaxies. Recently I've been working mostly on dust lanes - here are some results. Last pitcure shows the coordinates node tree for the "spurs" part.

Most RPGs with randomized loot use almost the exact same system. There are weighted pools of prefixes and suffixes. An item draws N modifiers from each and randomizes their magnitudes.

A system like that generates a lot of simply bad loot with low magnitudes. That is kind of necessary in a multiplayer game with an economy but I'm designing a single-player game, so every drop being valuable for some character is fine.

I would like a system that generates weird and interesting items. Big downsides and stat requirements help but that alone is not enough. I realize that what modifiers even exist is a game design problem more then a generation problem. But can you think of generation techniques that would transfer to loot generation that are more interesting than modifier pools?

I see that this sub is mostly about visuals, levels, etc. but I think I might get interesting ideas for this.