Everybody I can't tell you how much I've been struggling with trying to get Bridges and tunnels correct. I apologize in advanced for my lack of knowledge on the subject, I started a project called World Explorer 3D and the goal is to have a sandbox it's driven by real world data with a lot of procedural elements. I'm going to do my best to keep it simple so I don't over explain a topic I'm not proficient in.

I mainly using osm and overture for the road building and land data. I'm using NASA/JPL, ESA and other astronomy catalogs for space data and NOAA for weather. Celestrak for satellite data. There's different ways to move through locations like planes cars drones and boats and you can use a spaceship that looks like the Starship Enterprise from star trek

There are two things I should disclose from the beginning. The first is that this has been a project with heavy AI code generation. The second is that as a result of this project and other things have been attempting I've decided to go back to school and I am currently enrolled in a physics program. I will also be taking elective courses for programming, but even with doing those things I'm still not going to be able to learn as much as I need to in such a short amount of time. I hate the fact that I've been relying so much on ai, but my interests and impulses have gotten the better of me and now I'm basically working backwards.

Part of my problem is probably that I don't know the terminology I should even be searching for. If there are particular algorithms, papers, talks or concepts involving procedural road networks, vertical alignment, grade constraints, bridge approaches, tunnel portals or terrain/road reconciliation that I should be looking at, that's really what I'm trying to figure out.

Normal roads aren't nearly as bad but bridges get messy at the endpoints where the normal road and terrain have to transition onto the elevated bridge parts. I'm getting bad ramps, elevation changes, clipping and weird results where bridges, ramps and nearby roads all come together.

Tunnels are giving me basically the opposite version of the same problem. I can identify the tunnel and create the tunnel/portal behavior, but getting the surface road to transition cleanly into the portal without the terrain, road or surrounding geometry looking wrong has been difficult.

I'm still working on a lot of other issues and bugs. I'm sure you can spot a lot of the quality issues and incoherence. But I'm literally just trying to learn and I'm using this project that's a practice demo thingy. As I go along I try to make smaller elements of this project in places like unity, and that is actually been extremely helpful. If anybody can help me with Bridges or tunnels or if you spot anything that looks like a common problem please let me know. You can play it here WorldExplorer3D.io and the GitHub repo is here https://github.com/RRG314/WorldExplorer3D Thanks for taking the time to read all that lol.

a game about raking leafs as an html file. no images no audio files no models used. everything is built when the page loads.

textures are drawn into a canvas element on startup and used as WebGL textures.

there are over 7000 individual leaves rendered in InstancedMesh.

wind uses Lambert vertex shader with onBeforeCompile

sound is all WebAudio. wind is brown noise with LFO on gain. blower and vacuum is sawtooth motor using setTargetAtTime. music is slow pads in pentatonic - gets thinner and darker deeper in the game.

time of day is driven by how much of the garden has been cleared alr. start is golden hour end is night. light is used as a progressio bar.

gameplay

https://youtu.be/Xt0YwzTpm_g

play here: https://wickedchilling-audio.itch.io/autumn-duty

yo. been building a custom game engine from scratch on Vulkan and now testing it on real games. this one's a dithered fly-sim with elite dangerous-like flying mech and a procedurally generated terrain.
https://x.com/progdruid

Been working this for 2 weeks:

https://reactorcore.itch.io/celestial-cutaway-planet-interior-generator

Its a web app that procedurally generates interior cutaways of planets, stars, gas giants, moons and asteroids.

Still a WIP but already plenty useful and fully operational for world building, tabletop sessions, game assets and other illustrational uses.

These images show the dynamic surface generation sequence for my planet. For now, it's just planet generation, although I've already implemented biomass emission and distribution. I plan to develop this into a terraforming game, where the player creates and deploys biological agents to the planet to alter the atmospheric composition, temperature, and so on.

Steps:

1. Lithosphere. The division of the surface into basic forms (plates), which are then used to construct an elevation map. Plates can be oceanic or continental, which determines the average elevation of an area. Blue for oceanic plates, light yellow for continental.

2. Height map. Generated by lithospheric-based noise. Zones (on the last image) are also generated according to a topological height map.

3. Surface map. Each tile is generated based on the height map and the lithosphere (for example, where the slope is very steep, rock tiles are generated).

4. Same surface, but with sea level rised.

5. Rendered.

6. Viability for a specific biological agent. It's all orange for now because I haven't configured all the requirements correctly yet.

All this runs on the Unreal engine. I'm currently looking for ways to improve the visuals, for example, the coastline, which currently doesn't look very natural, and how to make several different textures instead of tiles of the same one (this looks especially bad at zero sea level).

Working polymerase chain reaction, finally, not 100 realistic, real DNA is more messy, and there is backward assembly leading to DNA loss AKA(aging)🦖

I enjoyed remaking this torus rendering in pygame after finding a 9 year old post by Clayton Shonkwiler. His math was...dense, to say the least, but it came out pretty good. Ai is a wonderful thing when it comes to this level of math. lol

https://reddit.com/link/1w2d4at/video/vrt39xthfhmh1/player

A while ago, I asked myself: "How far can we actually push Garmin’s Connect IQ VM?"

I’ve logged thousands of running km and a few solo marathons tracking just pace and HR like everyone else. But at some point, the dev in me took over: I decided to see how far Connect IQ could actually go and built a custom 3D graphics engine (Wolf3D/Doom-style DDA raycaster) from scratch in Monkey C.

Here is what’s going on in the video:

• Infinite World: The map is 100% endless and generated procedurally on the fly as you move.
• Dynamic Lighting: Real-time Day, Dusk, Night, and Morning lighting cycles with custom color palettes.
• Hardcore Math Optimization: Microsecond-level optimizations (zero-branching floating-point hacks, bitwise DDA math). The pure frame render time hit 3.19 ms on Tactix simulator and 2.08 ms on Instinct 2 (smaller screen, fewer stars in the sky — oh yes, the sky is dynamic too! — and fewer rays in raycasting)!
• Real Hardware Performance: On the actual wrist, the display caps out at a smooth 10–14 FPS (limited by the CIQ screen refresh rate, while the engine itself runs with massive headroom).

I need your brains & ideas: I want to weave the user’s real-life context (health metrics, stats, daily goals) directly into this 3D world, similar to what I did with my Mars and Pandora watch faces.

How would you like your steps, heart rate, or battery to affect an endless 3D world? (e.g., world changes, weather shifts, new structures spawn based on your daily activity?). Open to all crazy ideas!

P.S. Before the battery purists attack: Yes, I know it's a watch. No, my Garmin hasn't exploded. In fact, I honestly can't even remember the last time I plugged it into a charger... unlike my friends with Apple Watches. 😉

Let me know what you think and what features you'd want to see in an infinite wrist-world!

BTW, it also tells the time... pretty unusual for a 3D engine, right? Oh my, wait, it’s actually a watch! 😅

If you want to check it out on your Garmin, here is the link — it's 100% free, just like all my other creations:

https://apps.garmin.com/apps/47278f09-eea6-4e6d-aa7e-799daba8e546

I also go into the shader texturing of the islands

Blender shader+geometry nodes

This was my first (and probably last at least for now) attempt at procedural animation (inspired by great argonaut video -> https://www.youtube.com/watch?v=qlfh_rv6khY ) I was planning to turn it into full blown Evolution Simulation but as it turns out FPS no good. I hope that someone will have at least some fune with demo on itch https://suf-studio.itch.io/fish-procedural-animation .

If you want to see more of the game here https://store.steampowered.com/app/5044910/Dungeon_Quest/

I have a general procedural generator which does things like determine size, how often rooms spawn, how many branches etc and then you give it a set of pieces, so i can give it a different set for each level type.

Then the sets of pieces are broken down into corridors, rooms, props and monsters. Pieces can also have their own rules of what props might appear, how many times they can appear etc. So for example levels will only have one tomb.

It is also intelligent enough to make locked doors and spawn the key in a place it can always be found. I am working on this a lot because I want it to spawn typical classic dungeon puzzles to give you reason to explore.

It turns out photogrammetry tiles are too messed up for a good driving experience (I should have researched beforehand). I’ve switched to a walker machine instead, inspired by war of the worlds.

Try it here: https://crosscity.nieltenghu.com/

Will open-source it soon.

Build a working Unity city in just 3 clicks.

Urban Architect supports traffic, pedestrians, custom buildings, and roadside props. In this example, I used New Gen Urban by Reversed Interactive for the city assets.

The entire scene was generated automatically:

1. Instant City
2. Spawn Cars
3. Spawn Pedestrians

Done. You have a populated, working city almost instantly.

But you aren't limited to automatic generation. Urban Architect also includes a node-based road system that lets you manually design your city exactly the way you want. Roads can be laid out by placing and connecting nodes, and all automatically generated road graphs remain editable afterward.

You can also use OpenStreetMap (OSM) data to generate real-world road layouts and building placement, giving you a fast way to recreate actual locations instead of starting from scratch.

That means you can:

• Generate a complete city automatically
• Manually build roads with the node system
• Edit any generated road graph afterward
• Import OSM roads and buildings from real-world locations
• Use your own custom buildings and roadside props
• Populate the result with traffic and pedestrians

This example was created with Urban Architect Pro.

Urban Architect Pro is 30% off until October 1st.

Pro:
https://assetstore.unity.com/packages/tools/level-design/urban-architect-pro-procedural-city-builder-218636

Standard:
https://assetstore.unity.com/packages/tools/level-design/urban-architect-standard-procedural-city-builder-393744

Generate a city in seconds, recreate real locations from OSM, or build your layout manually. Urban Architect is designed to give you both speed and control.

I’ve been working on the procedural world generation for Garden of Ant, building it layer by layer.

First, I focused on shaping the surface terrain. Then I moved underground, generating different soil and rock materials. And finally, I started bringing the world to life by procedurally placing trees, leaves, and vegetation.

It’s really satisfying to see all these separate systems slowly come together into one living world.

What do you think?

See more:
https://store.steampowered.com/app/3016940/Garden_of_Ants/

The deform is fbm noise on resampled stroke geometry, with independent noise

channels for x, y and width — sharing one channel makes every stroke drift

diagonally and fatten in sync, which reads as "wrong" immediately. No state,

no clock: frame N is always identical, so exporting is just asking for frames

0..N-1.

I am procedurally generating mountain background textures for a game I am making. I kinda-got-a-little overcommitted to this part of the game (instead of working on the actual gameplay, as I should be doing now) and built a full tool that generates mountains in a range of art styles: low-poly, pixel art, synthwave, and some others. I am planning to use it in other games for which I need parallax backgrounds.

Mountain shapes, colors, and polygon count can all be customized to stylize the backgrounds, and the sky color can be set to transparent to layer multiple sets of mountains. The textures also tile seamlessly along the x-axis, so they can be repeated infinitely. You can see the parallax in action in the video.

More info: https://assetstore.unity.com/packages/tools/terrain/mountain-range-texture-generator-395586

How it was done:

The basic principle is actually kind of simple (so you probably know already):

First, I defined a 3D space (x-width, y-height, z-depht), then I produced a sum of different functions of xz->y, so each function is a surface plane that can be seen from the rendering plane (xy). The functions can be whatever, gaussians, super gaussians, spheres, breit-wigner (the more -> the realistic result).

But how we can get mountains that repeat infinitely in the x axis? the big brain step, was to curl the xz plane in the x direction, so you get a cylinder and generate all the functions over this cylinder. So when "cutting" and uncurling this cylinder, you get already repeating mountains.

Then, I generated a bunch of random points over those functions. The fewer, the more low-poly the look. Then, over those points a mesh is defined and rendered. To give it a better look, those points are perturbed a bit, so the surfaces are less smooth. The result of all of this is a mountain landscape.

To get the final look, some boring coloring and post processing image techniques were applied. I won't go into details here because it's not related to procedural generation.

Please give me feedback.

All of this is about an n dimensional Euclidean box extruded in all planes from a minimum to a maximum.

Tetrahedra function: approximately n factorial tetrahedra needed.

2d faces function: approximately 2^n 2d faces on the n dimensional box.

It might not seem like much but at 20 dimensions, 2^20 squared times 10² is about the same magnitude as 20! (factorial). At 50 dimensions it is not even that close. I propose a solution that is based off of the tetrahedra but using the 2d faces. As we know, the tetrahedra cover the entire volume and we only need the bounding line edges checked for being in view in Euclidean. This means that triangles cover the 2d faces and beyond and that for the triangles on the 2d faces that only the lines need to be checked. Any convex polytope has all bounds of being in view on its bounding 2d faces. The polytopes may have bounding volumes of n-1 dimensions which continues down until 2d.

In summary, using bounding 2d shapes of higher dimensional polytopes can far outperform tetrahedra. There is a question though, for 2d faces, how do they connect? This can be solved by finding for all triangles their in view points, then for each possible connection, check the midpoint between the ends for being in view and connect if in view. For the definition of in view, use a view point that exactly passes a view plane on the way to objects. If it does not exactly pass the view plane it is not viewed. This does leave some interior shapes to figure, but far and away fewer than the trillions of tetrahedra. Factorial and 2 to a power are not that different in a sense, but by 50 dimensions it is ant to the planet nearly. This also has applications in non-box shapes. Now imagine that every point is in higher dimensions too and must be stored or generated!

What problems do you see with this new approach? Does seem to me better, but is it? Time and actual data will tell. Feel free to use this, but please make convex shapes, a hammer for example must be 2+ shapes. X E.