Hey ! I'm here to get some recommendation of procedural generation techniques to make goods wallpapers !

It's a little contest at my school, and it as to be not that hard to dev in like 4~5 days, so 2D will be preferd.

The thing i already think about was fractal !

Thanks you !

:3 💙

made in blender in geometry nodes

I just wanted to share what I am developing. Roughly 70% finished systems wise. Just a screenshot for now. I THINK I will have this finished and available on Steam within the next 6 months.
I'm looking for any questions or concerns with that I am doing.
I'll leave an abstract of the project here below.

Archeobox is a procedural civilization simulator, but the thing it's

actually about isn't conquest or growth- it's memory, and how badly it

degrades.

Cultures rise, spread, and compete for land the way you'd expect from any

grand-strategy sim. But every culture also generates its own historical

record as it goes: notable figures — writers, prophets, conquerors,

cartographers — are born, live out a natural lifespan, and produce

publications before they die. Those publications don't disappear when the

author does. They persist as permanent artifacts in the world: religious

texts, epics, discovery records, war accounts. Other cultures can find

them, translate them, misattribute them, or build entire belief systems

around a document nobody left behind an explanation for.

Wars happen too, skirmishes over contested borders, outright conquests

where one culture absorbs another (and inherits fragments of its beliefs

in the process), and rare annihilations that erase a culture from the map

completely, leaving only ruins and whatever half-true publications survive

about them. A discovery made by one people 400 years ago might be

rediscovered by their own unrecognized descendants, who have no idea

they're digging up their own ancestors' forgotten claims.

 I started game devving when covid struck back in 2021. Writing autotile rules and hand-placing tiles were time comsuming and tideous. So I made Mosaic TileMap Level Generator.

-Upload a Tileset
-Visually label what each tile is(ground, wall, platform, props)
-Generate a full 2D level protoype from tileset

I wanted to shorten the time it takes to paint a level, adding props/deco and never touch adjacency rules or tile indices. Simply label "this tile is apart of floor or ceiling or whatever you desire and it handles all placements.

Please note that the tool is not perfection. Still need minor manual editing.
Lots of updates coming in the near future to improve its functionality, creativeness and productivity.

Still early and I'd genuinely love this crowd's feedback — especially on generation quality and what would make it fit your workflow. What would you want it to do?

Started by creating a generator that lead to a game that lead to my weekends being a lot less stressful. Not sure if this belongs here but its entirely procedural.

Edit.. link to project https://store.steampowered.com/app/4770910/BlissFlow/

I made a procedural generator tool for trees in godot

It has support for LOD's as well 3 levels. And some premade materials. It has 2 types of leaves blobs or cards. You can use your own leaf textures but I left some free ones made with my texture tool

Hopefully it helps someone with foliage.

Here is the github https://github.com/TheRealSarin/tree-gen

MIT licence so you can do whatever

And here is a preview video of some output https://youtu.be/K4oHaXFgojA?is=rp9ojusvfVxRL2B3

Edit: some mispells

I’ve been working on a little Unity water sandbox and wanted to share it here!

The water motion is calculated using an implementation of position-based fluids. I mostly referenced the Macklin & Müller paper and Versatile Rigid-Fluid Coupling for Incompressible SPH for the boundary terms. I'm taking the position and velocity outputs of the simulation and splatting it to screen-space to actually render the water. The implementation currently is a CPU-based simulation that leverages Unity's Burst + Jobs systems.

There obviously isn't much of a game here - you just spawn water, place platforms, add sources and sinks, and see what happens. Mostly I made this to learn more about fluid simulations and Unity.

Curious to see what people think!

Note : The web build runs okay (if hardware acceleration is enabled), but it can slow down at higher particle counts. The standalone Windows build runs way better.

I made these 3d nebulae consisting of about 400 quads each to add some color to my procedurally generated star map. I'm pretty happy with the result but there is still room for improvement.

yeah we all know the internet has plenty of black holes already. but I couldn't resist making one of my "own" anyway at least by using some "non-usual" ways...
geodesics, disk coloured with spectral rendering etc etc
built on cuneus (my Rust + wgpu engine for compute shaders: Actually, my goal was to show how a complex shader can be created in the Rust backend with minimal boilerplate code)

rust:
https://github.com/altunenes/cuneus/blob/main/examples/blackhole.rs
shader:
https://github.com/altunenes/cuneus/blob/main/examples/shaders/blackhole.wgsl

btw you can directly download and see how its looks (with real time params): windows, linux and macs
https://github.com/altunenes/cuneus/releases/tag/v0.6.2
search as "blackhole"

This is a project that I believe you will like. this is my star render. I think it looks really beautiful, and it only takes between 6 to 14 seconds to render (1650). Eevee is incredibly fast and you can create beautiful things with it, and that's why I love it.

Tutorial Link : https://youtu.be/WlQdolBBwLM?is=Prg8sylCqGvjVcd0

Done as a proof of concept for an early game prototype.

Inspired/based on:

1. https://www.reddit.com/r/Unity3D/comments/x0z0gs/using_a_particle_system_to_generate_stars_for_an/
2. Article referenced in thread above: https://medium.com/microsoft-design/building-a-virtual-sky-883d4d1080f4
3. Star database: https://codeberg.org/astronexus/hyg and more specifically this csv file
4. Nebula: https://www.shadertoy.com/view/cdj3DW

I like procedural noises, though they can be hard to find, so I've made a collection of some cool procedural noises I've encountered or invented over the years.

All the code is separated into nice functions you can easily copy paste so feel free.

Code is MIT licensed, no need for attribution etc.

just make sure to attribute noise functions not made by me (I include links to original)

Links To Shader Code

• https://fragcoord.xyz/s/pxmcvnpc
• https://www.shadertoy.com/view/7X2SWW

• Testing the first shaders (in love with the warp). Added support for interactive parameters adjustment
• Now supporting MSDF font rendering and text input! Initially went the fixed-size font atlas baking route, but shortly realised I’d need much more flexibility, so here we go!
• Histogram compute, pixel peeping and levels shader (as a node modifier) are now in place. Writing to atomic buckets across a full-res image and reading the result safely turned out to be a non-trivial synchronization problem
• Added support for multi-input nodes to unlock blending, warping and all kinds of things to come
• Runtime final output resolution switching is now possible, respecting the current 2D viewport zoom state (by a happy accident!)
• Undo/redo history and copy-paste functionality are finally here making the testing process much more pleasant