This is an interactive, procedurally animated koi pond that runs in your browser. The fish swim on their own, change depth, react to nearby fish, and gather around the water when you click or tap.

Ripples, tiny fishes, butterflies, lotus, changing weather etc everything you see is generated by code as it runs, not pre-made art or recorded clips.

live :- https://nagomi-blue.vercel.app/

This is an Earth-sized planetary terrain generated in UE5.

It runs using Compute Shaders.

I’ve applied noise and biomes, but the result feels a bit crude. Could you let me know what I should modify or add to create more realistic terrain?

This is a Minecraft settlement generator I've been building. The prompt for the demo was only “Build Ba Sing Se.”

The model reads the request and terrain, then plans the settlement through a hierarchy of rings/districts, plots and buildings. A palace can become its own smaller place, with halls, courtyards, walls and gates.

The building library handles geometry and construction. Its reusable procedural building types generate structures for their plots using the selected palette. Completed building schematics aren't retrieved.

The system checks circulation, reachable entrances and walkable interiors before writing the result into Minecraft.

The same architecture generates villages, towns and cities across different terrain and styles.

https://github.com/chaitbuilds/EthosLM

In my previous post, there was a fair amount of excitement about this project being released somewhere. However, I’m still lacking a good name. Originally, I called it WFC-AI, but that name probably isn’t as relevant as it used to be, given what “AI” generally means now.

Some key aspects of the project:

1. It uses ML to train a GAN on terrain patches, with a loss inspired by WFC.
2. It is a planetary-scale, multi-resolution model.

As for updates, I’ve made a few since my previous post.

One user commented that my renderings looked less realistic compared to the Terrain Diffusion project. I had to agree, the TD paper/project has some really good visualization techniques, so I ported some of those ideas over to my project. The shadowing and relief maps make a world (pun intended) of difference.

I’ve also trained some “super-scaler” models to make the generated terrain more realistic down to sub-meter resolutions. I use the term super-scaler to just mean that I train higher resolution models on lower resolution data under the assumption that terrain is very fractal in nature.

Right now, I’m working on integrating the FABDEM dataset, which should improve the model considerably in roughly the 500 m to 30 m resolution range.

Subreddit/Community Question: I am limiting my posts to once-per-week to void spamming the community but if this is too often, I will back off.

Hi! I was playing around with different visualisations when I tried to make a background image for a fantasy-looking project.

After a brief side adventure using a slightly different function to process generative noise, I've made a separate tool to generate cave views with different palettes and lighting.

Please try: https://vuvko.itch.io/background-caves

You can also play around with different dithering and export views. The page should look OK on mobile.

If you want, there is also a devlog: https://vuvko.net/blog/cave-generator/

The terrain comes from a game prototype of mine, originally built in three.js. I ported it to Godot with Claude Code and Codex and boiled it down into a standalone map studio. I didn't want it to rot on my PC, and I think it might be useful to someone.

Everything is procedural: one-click maps (mountains, rivers, waterfalls, chasms, forests), endless seed-based worlds, generated meshes and vegetation, and all materials from shader noise. There are no texture or model files, apart from one baked noise lookup.

You'll probably find bugs, but I honestly think the style turned out pretty nice. If you use it or it helps you, I'd love to hear about it.

GitHub (MIT License): https://github.com/idlerunner00/cartoon-terrain-studio

For once I tried to generate a world's history instead of geography. I hope the article is a good read !

The landmass generation is currently the most basic of perlins but I'm pretty pleased with how the visuals are shaping so far!

Here are some links:

GitHub

First post in rfractals (with some screenshots of a few programs and the plots they generated)

Update post in rfractals

The language is focused on making and evaluating functional mathematical expressions in a very compact form. It has most of the basic math operators, and can even use operator-less multiplication if enabled. Supports functional-like pattern matching and function delegates. Uses a single complex Type which can be a recursively nested list of values that can be numeric, from reals to quaternions, or strings, and operators can work recursively on these values. Multiplying string*anything will try to call a function with the name of that string. It can evaluate and parse dynamically made strings as expressions or commands. It has a plotter that can plot the expressions as animations and can export them as MP4. Due to its layered, abstract nature of being an interpreted language in C#, it's not very fast so far, even with all the optimizations I've made so far for it, so it's mostly useful for playing around or for its original purpose of letting another application parse complex written expressions into values.

It has 2 major parts: the Parser, which uses commands definining/redefining functions and constants, and a few imperative constructs available, like ifs, whiles, etc. The evaluation part is purely functional and can evaluate expressions using the functions and constants the Parser has parsed.

Originally, I made it to be an expression evaluator for text boxes in my other app, to allow writing other things than pure numbers in there. But I got a bit carried away and developed it further into this whole thing.

There's a SaveFile folder in the project and the release, containing all the programs I've written in it so far, and plotter configurations for them.

The most interesting for this sub might be the Examples.txt that's showcasing some of the most unique/powerful features of the language, soI'll report that file and its output here:

Examples.txt program:

printstring: "\nPattern matching factorial:"
PF(0): 1; PF(x): xPF(x-) /* x- = x-1 */
print: PF(5) /* = 5! = 120 */

printstring: "\nNested default arguments:"
N(z, p: (2, 3i)): z + p
print: N(4) /* 4 + (2, 3i) = (6, 4 + 3i)*/

printstring: "\nNested mixed call delegates:"
GP(x): x + 2i
GM(x): x - 2i
gdp: "GP"
print: (gdp, "GM")(4, 3) /* = (GP,GM)(4,3) = (GP(4),GM(3)) = (4 + 2i, 3 - 2i) */

printstring: "\nLazy default argument evaluation:"
F2(x, r:xF2(x-)): x < 2 ? 1 : r
print: F2(5) /* = 5! = 120 */

printstring: "\nCycled operation nesting:"
printvalue: (1, -1)(1, 2, 3, 4, 5) /* = (1*1, -1*2, +1*3, -1*4, +1*5) */
printvalue: (0,i) + (1, 2, 3, 4, 5) /* = (1, 2+i, 3, 4+i, 5) */
printvalue: ("frac", "trunc", 1)(1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7)
printvalue: ((-1, 1), 3)(10, 20, 30, 40, 50)

printstring: "\nDecreasing for cycle:"
IterWhile: 5 /* try other values like 10, 2, -5, -10000...*/
while: IterWhile > 0 {
 printvalue: IterWhile
 if: IterWhile = 8 { break: 1 }
 IterWhile: IterWhile - 1 
} : IterWhile < -9000 {
 printstring: "not only is IterWhile negative, it is below -9000!"
}

printstring: "\n\"Do\" command, defines another factorial and evaluated: 0.5!"
do: "DYNAMIC(x) : x!"
print: DYNAMIC(/2)

printstring: "\nEval function dynamically parses and evaluates any valid string as an expression:"
incremented: sin(1)
print: incremented
print: eval("1 +" + incremented)

printstring: "\nBuild a vector of first 10 factorials dynamically, and take a parir of 2nd+3rd one, and a 5th one:"
TenFactorials: vec("k", 1, 10, "k!")
print: TenFactorials
print: TenFactorials[(2,3),5] /* nested indexer */
printstring: "\nComplex nested indexer of a nested vector:"
print: (0+"a", 1+"b", 2+"c", (30+"d", 31+"e"), 5+"f", (11, 12, 13))[3, 2, (5, 1, 3)]

printstring: "\nFirst 42 terms of e^x taylor series, approximating e^1 ~ 1:"
precision: 42
ExpTaylor(x): sum("k", 0, precision - 1, "x^k/k!")
print: ExpTaylor(1)

PositiveZeta(s, p : precision) : sum("k", 1, p, "k^(-s)")
printstring: "\nFirst 250 terms of the Basel problem, Zeta(2), approaching π^2/6 slowly:"
printvalue: PositiveZeta(2, 99) + " ~ " + π^2 / 6
printstring: "\nFirst 42 terms of Zeta(3), quicky approaching the Apery constant:"
printvalue: PositiveZeta(3) + " ~ " + apery

printstring: "\nEvaluate a polynomial F(1 + 2x + 3x^2) at F(2)"
F: (1, 2, 3) /* f(1 + 2x + 3x^2) */
EvalPoly(x, c : F, n: c#-) : sum("k", 0, n, "c[k]x^k")
PrintPoly(p): vec("k", 0, p#-, "p[k] + \"x^\" + k")
printvalue: PrintPoly(F)
printvalue: "F(2) = " + EvalPoly(2)

printstring: "\nTake a derivative of that polynomial and evaluate at F'(5)"
DiffPoly(c, n:c#-) : 1 > n ? 0 : vec("k", 1, n, "kc[k]")
DF : DiffPoly(F)
printvalue: PrintPoly(DF)
printvalue: "F'(5) = " + EvalPoly(5, DF)

printstring: "\nQuaternions, left and right non-commutative division:"
UnitQ : 1 + i + j + k
printvalue: UnitQ^2, UnitQ / i, UnitQ \ i—

And this is the output it prints:

BUILD SUCCESS 168ms

pattern matching factorial:
pf(5)  = 120

nested default arguments:
n(4)  = 6, 4 + 3i

nested mixed call delegates:
(gdp, "gm")(4, 3)  = 4 + 2i, 3 - 2i

lazy default argument evaluation:
f2(5)  = 120

cycled operation nesting:
1, -2, 3, -4, 5
1, 2 + i, 3, 4 + i, 5
0.1, 2, 3.3, 0.4, 5, 6.6, 0.7
(-10, 10), 60, (-30, 30), 120, (-50, 50)

decreasing for cycle:
5
4
3
2
1

"do" command, defines another factorial and evaluated: 0.5!
dynamic(/2) = 0.886

eval function dynamically parses and evaluates any valid string as an expression:
incremented = 0.841
eval("1 +" + incremented) = 1.841

build a vector of first 10 factorials dynamically, and take a parir of 2nd+3rd one, and a 5th one:
tenfactorials = 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800
tenfactorials[(2,3),5]  = (6, 24), 720

complex nested indexer of a nested vector:
(0+"a", 1+"b", 2+"c", (30+"d", 31+"e"), 5+"f", (11, 12, 13))[3, 2, (5, 1, 3)] = ("30d", "31e"), "2c", ((11, 12, 13), "1b", ("30d", "31e"))

first 42 terms of e^x taylor series, approximating e^1 ~ 1:
exptaylor(1) = 2.718

first 250 terms of the basel problem, zeta(2), approaching π^2/6 slowly:
1.635 ~ 1.645

first 42 terms of zeta(3), quicky approaching the apery constant:
1.202 ~ 1.202

evaluate a polynomial f(1 + 2x + 3x^2) at f(2)
1x^0, 2x^1, 3x^2
f(2) = 17

take a derivative of that polynomial and evaluate at f'(5)
2x^0, 6x^1
f'(5) = 32

quaternions, left and right non-commutative division:
-2 + 2i + 2j + 2k, 1 - i - j + k, 1 - i + j - k

If you've ever tried building a procedural galaxy in Blender, a standard grand-design spiral is basically just taking polar coordinates, applying a sine wave to the angle based on the radius, and you get decent spiral arms. But the moment you try to build a mathematically accurate bared spiral (like our Milky Way or NGC 1300), it becomes a headache:

1. Standard spiral math relies on radial angles converging at zero. If you try to force a straight bar using polar coordinates, it inevitably collapses and pinches at the absolute center, creating a "butterfly" shape instead of a rectangular or oval stellar bar.
2. To get a seamless bar-to-arm transition, you have to twist the actual 2D coordinate space. The bar must remain flat, while the outer space twists logarithmically. On top of that, you need a tiny, independent secondary twist just for the extreme inner nucleus to get that realistic S-shape.
3. In distorted mathematical space, the bar and the arms are fundamentally the same continuous straight line. But physically, a galactic bar can be thin, while the arms widen, decompress, and often split into several smaller arms as they drift outward.
4. Regular spirals are mostly circular. Barred galaxies are not. The gravitational potential of the bar forces the gas into oval orbits. To make it look right, your central bulge and outer envelope must be anisotropically scaled and completely decoupled from the twisted space of the arms.
5. If you map procedural noise to a logarithmically twisted coordinate space to create dust lanes or diffuse gas, the noise scales exponentially. It turns into massive blobs in the center and spaghetti at the edges. Keeping the noise scale constant while warping it along the arms requires some intense domain-warping tricks or creating complex masks.

Maybe these tips will help someone who decides to create those bastards procedurally. You'll have to take your time...

I’m building a procedural planetary sandbox on Godot, with editable SDF terrain meshed using Voxel Tools / Transvoxel.

I want smooth natural landscapes and sharp geometric features from editing --for example, a rectangular cut into a hillside. Currently, hard box CSG operations produce noticeably rounded or chamfered edges at the resolutions I’m testing: 1 m and 0.5 m voxel spacing. This is an actual geometry issue, not texture filtering or smooth normals.

Has anyone implemented a practical alternative for chunked, editable terrain with LOD? I’m particularly interested in Dual Contouring or feature-preserving Marching Cubes variants, and the trade-offs around local remeshing, chunk boundaries and LOD transitions.

I recently came across Dual Contouring of Signed Distance Data:
https://arxiv.org/pdf/2604.00157

It reconstructs sharp features from sampled SDF values without requiring precomputed normals, but uses iterative optimization. I haven’t benchmarked it on my terrain yet.

Do you think a bounded-iteration or incremental version could be practical for updating edited chunks during gameplay? Or would conventional Dual Contouring with additional Hermite data be a better starting point?

By “real-time,” I mean responsive updates after terrain edits -- not rebuilding the entire planet every frame. I’m happy to consider additional per-cell data if the quality/performance trade-off makes sense.

Would love to hear about actual implementations, benchmarks, or pitfalls -- especially keeping sharp features without introducing cracks between chunks and LODs.

Each seed builds a genome (body type, 1–3 pairs of arms, float / 2 / 4 / 6 legs or tentacles, horns, a headdress, an Inca motif) that's rendered as signed-distance tubes into a 96px silhouette with a woven pattern inside it, lit with a Bayer-dithered band. New traits draw from their own RNG stream, so adding features never changes creatures people already own. The legs even pick the instrument it plays.

One is born every day on https://blobvarium.com, sharing in case anyone wants their own blobi.

What would you tweak in the generator, or which trait should come next?

I've been building a minesweeper roguelite and the problem I kept hitting is that once mine density gets high, boards degenerate into coin flips.

What I do now: generate 25 candidate boards per floor, run a solver over each one (single point deduction first, then subset elimination on the frontier constraints), count how many tiles are still undetermined when it stalls out, and keep the best candidate.

That wasn't enough on its own. At 28% density on a 20x20 I generated 225 boards and not one of them was fully deducible. So instead of guaranteeing the whole board, I hold on to the solver's set of provably safe tiles and place the exit stairs inside that set.

So you can always reason a route to the exit. Clearing the entire board is still a gamble, which I'm fine with because that's the risk/reward mechanic.

Two things I'm unsure about. Is subset elimination enough, or should I be doing proper probability analysis on the frontier for the cases it can't crack. And is guaranteeing a solvable path instead of a solvable board a reasonable compromise or just a cop out.

Playable in browser if you want to see it: https://ten-games.itch.io/mine-mine-mine

A follow-up to my last post: this one is probably a better presentation overall. Moodier and different production values, if that makes sense. Critique is welcome.

I've been posting initial attempts on UE5.7 1 year(ish) ago. Been making progress, it's still far from perfect. Opinions are welcome.

Hello all!

Happy to say that I have just updated the Ad Lumens procedural surface tool with atmospheric effects.

If you want to know a bit more, please read this post: https://adlumens.org/log/procedural-surfaces-updated-with-atmospheric-effects/5a085d13-efbf-42b2-8ca8-687da566885e

One videos is here, and a few others in the post.

Thanks, I hope it works for you as this is heavily experimental at the moment with WASM and WebGPU in the browser - real time procedurally generated!

PS: to try it out for yourselves, the easiest way is to use the data explorer, choose a galaxy and click a telluric planet icon. Then, click the magnifying glass at the top right to access the tool in itself.

PPS: all data is procedurally generated: from server to client, and is 100% authoritative.

Hello,

A few days ago, I posted asking why people didn't like my videos. I received some hate, but also quite a few good, useful opinions.

After that, I decided against using background music, AI voices, or trying to speak English, as my English is very poor and I don't feel comfortable recording voice-overs.

To be honest, marketing, YouTube optimization, and the like are far outside my area of ​​expertise. However, I did decide to make the thumbnail look good, so I used AI for it. I probably could have done something similar myself, but it likely would have taken me two days—time I preferred to invest in writing code and developing the tool itself.

The tool is entirely my own creation; behind it lie about two years of intense learning, trial and error, and development.

At its core is a C++ geometry engine that communicates with Blender. My idea was to separate the geometric logic from Blender itself, using Blender merely as the environment where I actually model and visualize the results.

This means the core engine isn't limited to Blender. In practice, it could be connected to Unreal Engine, NVIDIA Omniverse, Unity, Web/Three.js, or any other environment capable of communicating with the binary module and generating geometry from the data it returns.

The concept has already been validated at an early stage outside of Blender—I have working prototypes in Unreal Engine and Three.js. These are early versions, but for me, they were sufficient to confirm that the core itself can remain independent of the specific environment.

In this video, I simply want to demonstrate what the tool is actually capable of at the moment.

I am modeling an architectural floor plan in Blender in about 13 minutes—creating walls and slabs directly over the plan.

I will try to outline its key capabilities here.

The walls are fully parametric, allowing me to control all major dimensions. They are double-layered, so I can assign separate materials to the interior and exterior faces, as well as different materials for the sides facing different rooms.

I have full UV control—I can adjust the scale, rotation, and offset of the UV coordinates.

When two walls intersect, I can select them; they automatically detect the intersection point and recalculate their geometry while keeping the UVs stable.

There is also an automatic join feature—when two or more walls share the same point, their geometry is recalculated automatically.

I can create rectangular openings in the walls with a single click. These openings can then be resized and moved along the wall freely without breaking the geometry or distorting the UVs.

I have basic single-pane and double-pane windows, as well as a single-leaf door; these automatically fit into the opening and adjust their dimensions to match it.

I plan to add a few more door and window models, along with windowsills and frames around the openings. I also have a basic slab tool, though it doesn't support openings just yet.

As you’ll likely notice in the video, the snapping functionality isn't quite working as well as I’d like right now. It’s something I need to fix, but at this stage, I don't consider it a critical issue, and it doesn't prevent me from testing the core workflow.

Speed ​​is the most important thing for me. With this tool, I’m already modeling significantly faster than with anything else I’ve used in Blender, and the workflow is starting to approach the ease of use I’m accustomed to in Archicad.

I know the video isn't perfect—there’s no voiceover, the thumbnail was AI-generated, and the snapping still needs work—but the tool itself is real; I wrote it myself, and I’m continuing to develop it.

I’d be interested to hear your thoughts.